subprocess — Управление дочерними процессами

Модуль subprocess позволяет запускать новые процессы, подключаться к их каналам ввода/вывода/ошибок и получать их коды возврата. Этот модуль предназначен для замены нескольких более старых модулей и функций:

os.system
os.spawn*
os.popen*
popen2.*
commands.*

Информация о том, как этот модуль может быть использован для замены более старых функций, находится в разделе subprocess-replacements.

1. Использование модуля subprocess

Рекомендуемый способ запуска дочерних процессов — использование следующих удобных функций. Для более сложных случаев, когда этого недостаточно, используйте базовый интерфейс Popen.

subprocess.call(args, *, stdin=None, stdout=None, stderr=None, shell=False)

Запустить команду, описанную в args. Подождать завершения команды и вернуть атрибут returncode.

Приведенные выше аргументы — лишь наиболее распространённые, описанные ниже в разделе Часто используемые аргументы (отсюда немного странная нотация в сокращённой сигнатуре). Полная сигнатура функции такая же, как у конструктора Popen — эта функция передаёт все предоставленные аргументы непосредственно этому интерфейсу.

Примеры:

>>> subprocess.call(["ls", "-l"])
0

>>> subprocess.call("exit 1", shell=True)
1

Предупреждение

Использование shell=True может представлять собой угрозу безопасности. Подробности см. в предупреждении в разделе Часто используемые аргументы.

Примечание

Не используйте stdout=PIPE или stderr=PIPE с этой функцией, так как это может привести к тупиковой ситуации в зависимости от объёма вывода дочернего процесса. Используйте Popen с методом communicate(), когда вам нужны каналы.

subprocess.check_call(args, *, stdin=None, stdout=None, stderr=None, shell=False)

Запустить команду с аргументами. Подождать завершения команды. Если код возврата был нулевым, то вернуть, иначе поднять исключение CalledProcessError. Объект CalledProcessError будет содержать код возврата в атрибуте returncode.

Приведенные выше аргументы — лишь наиболее распространённые, описанные ниже в разделе Часто используемые аргументы (отсюда немного странная нотация в сокращённой сигнатуре). Полная сигнатура функции такая же, как у конструктора Popen — эта функция передаёт все предоставленные аргументы непосредственно этому интерфейсу.

Примеры:

>>> subprocess.check_call(["ls", "-l"])
0

>>> subprocess.check_call("exit 1", shell=True)
Traceback (most recent call last):
   ...
subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1

Новая в версии 2.5.

Предупреждение

Использование shell=True может представлять собой угрозу безопасности. Подробности см. в предупреждении в разделе Часто используемые аргументы.

Примечание

Не используйте stdout=PIPE или stderr=PIPE с этой функцией, так как это может привести к тупиковой ситуации в зависимости от объёма вывода дочернего процесса. Используйте Popen с методом communicate(), когда вам нужны каналы.

subprocess.check_output(args, *, stdin=None, stderr=None, shell=False, universal_newlines=False)

Запустить команду с аргументами и вернуть её вывод в виде строки байтов.

Если код возврата был ненулевым, то возбуждается исключение CalledProcessError. Объект CalledProcessError будет содержать код возврата в атрибуте returncode и любой вывод в атрибуте output.

Приведенные выше аргументы — лишь наиболее распространённые, описанные ниже в разделе Часто используемые аргументы (отсюда немного странная нотация в сокращённой сигнатуре). Полная сигнатура функции во многом совпадает с сигнатурой конструктора Popen, за исключением того, что stdout запрещён, так как используется внутри. Все остальные предоставленные аргументы передаются непосредственно в конструктор Popen.

Примеры:

>>> subprocess.check_output(["echo", "Hello World!"])
'Hello World!\n'

>>> subprocess.check_output("exit 1", shell=True)
Traceback (most recent call last):
   ...
subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1

Чтобы также захватить стандартную ошибку в результате, используйте stderr=subprocess.STDOUT:

>>> subprocess.check_output(
...     "ls non_existent_file; exit 0",
...     stderr=subprocess.STDOUT,
...     shell=True)
'ls: non_existent_file: No such file or directory\n'

Новая в версии 2.7.

Предупреждение

Использование shell=True может представлять собой угрозу безопасности. Подробности см. в предупреждении в разделе Часто используемые аргументы.

Примечание

Не используйте stderr=PIPE с этой функцией, так как это может привести к тупиковой ситуации в зависимости от объёма ошибок дочернего процесса. Используйте Popen с методом communicate(), когда вам нужен канал stderr.

subprocess.PIPE

Специальное значение, которое может использоваться в качестве аргумента stdin, stdout или stderr для Popen и указывает на то, что должен быть открыт канал к стандартному потоку.

subprocess.STDOUT

Специальное значение, которое может использоваться в качестве аргумента stderr для Popen и указывает на то, что стандартная ошибка должна направляться в тот же обработчик, что и стандартный вывод.

exception subprocess.CalledProcessError

Исключение, генерируемое, когда процесс, запущенный с помощью check_call() или check_output(), возвращает ненулевой код выхода.

returncode

Код выхода дочернего процесса.

cmd

Команда, которая была использована для запуска дочернего процесса.

output

Вывод дочернего процесса, если это исключение возбуждено функцией check_output(). В противном случае, None.

1.1. Часто используемые аргументы

Для поддержки широкого спектра случаев использования конструктор Popen (и удобные функции) принимают большое количество необязательных аргументов. Для большинства типичных случаев многие из этих аргументов можно безопасно оставить со значениями по умолчанию. Аргументы, которые чаще всего необходимы:

args требуется для всех вызовов и должен быть строкой или последовательностью аргументов программы. Передача последовательности аргументов предпочтительнее, поскольку модуль может обрабатывать любые необходимые экранирование и оформление аргументов (например, для разрешения пробелов в именах файлов). Если передаётся строка, то либо shell должен быть True (см. ниже), либо строка должна просто называть программу, которая должна быть запущена, не указывая никаких аргументов.

stdin, stdout и stderr задают стандартный вход, стандартный вывод и стандартную ошибку исполняемой программы соответственно. Допустимыми значениями являются PIPE, существующий дескриптор файла (положительное целое число), существующий файл-объект и None. PIPE указывает на то, что должен быть создан новый канал для дочернего процесса. При настройках по умолчанию None, перенаправление не произойдёт; дескрипторы файлов дочернего процесса будут унаследованы от родительского. Кроме того, stderr может быть STDOUT, что указывает на то, что данные стандартной ошибки дочернего процесса должны быть захвачены в тот же файл-обработчик, что и стандартный вывод.

Когда stdout или stderr являются каналами и universal_newlines равно True, все окончания строк будут преобразованы в '\n', как описано для аргумента режима универсальных символов новой строки 'U' для open().

Если shell равно True, указанная команда будет выполнена через оболочку. Это может быть полезно, если вы используете Python в основном для расширенного управления потоком по сравнению с большинством системных оболочек и всё же хотите иметь удобный доступ к другим функциям оболочки, таким как каналы оболочки, подстановки имен файлов, расширение переменных среды и расширение ~ до домашнего каталога пользователя. Однако обратите внимание, что Python сам предлагает реализации многих функций, подобных оболочке (в частности, glob, fnmatch, os.walk(), os.path.expandvars(), os.path.expanduser() и shutil).

>>> from subprocess import call
>>> filename = input("What file would you like to display?\n")
What file would you like to display?
non_existent; rm -rf / #
>>> call("cat " + filename, shell=True) # Uh-oh. This will end badly...

Эти параметры, наряду со всеми другими, подробно описаны в документации конструктора Popen.

1.2. Конструктор Popen

Подлежащее создание процесса и управление в этом модуле обрабатываются классом Popen. Он предлагает большую гибкость, чтобы разработчики могли обрабатывать менее распространённые случаи, не покрытые удобными функциями.

class subprocess.Popen(args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0)

Исполнение дочерней программы в новом процессе. В Unix, класс использует поведение, подобное os.execvp(), для запуска дочерней программы. В Windows, класс использует функцию Windows CreateProcess(). Аргументы для Popen следующие.

args должен быть последовательностью аргументов программы или одной строкой. По умолчанию, программа для выполнения - это первый элемент в args, если args является последовательностью. Если args является строкой, интерпретация зависит от платформы и описана ниже. Обратитесь к аргументам shell и executable для дополнительных различий от поведения по умолчанию. Если не указано иное, рекомендуется передавать args как последовательность.

В Unix, если args является строкой, строка интерпретируется как имя или путь к программе для выполнения. Однако это можно сделать только в случае отсутствия аргументов для программы.

Примечание

shlex.split() может быть полезным при определении правильной токенизации для args, особенно в сложных случаях:

>>> import shlex, subprocess
>>> command_line = raw_input()
/bin/vikings -input eggs.txt -output "spam spam.txt" -cmd "echo '$MONEY'"
>>> args = shlex.split(command_line)
>>> print args
['/bin/vikings', '-input', 'eggs.txt', '-output', 'spam spam.txt', '-cmd', "echo '$MONEY'"]
>>> p = subprocess.Popen(args) # Success!

Обратите внимание, что опции (например, -input) и аргументы (например, eggs.txt), разделенные пробелами в оболочке, попадают в отдельные элементы списка, в то время как аргументы, которые требуют кавычек или обратного слеша при использовании в оболочке (например, имена файлов, содержащие пробелы или команда echo, показанная выше), являются одиночными элементами списка.

В Windows, если args является последовательностью, она будет преобразована в строку способом, описанным в Преобразование последовательности аргументов в строку в Windows. Это связано с тем, что основная функция CreateProcess() работает со строками.

Аргумент shell (по умолчанию False) указывает, использовать ли оболочку в качестве программы для выполнения. Если shell True, рекомендуется передавать args как строку, а не как последовательность.

В Unix с shell=True, оболочка по умолчанию /bin/sh. Если args является строкой, строка задаёт команду для выполнения через оболочку. Это означает, что строка должна быть отформатирована точно так же, как она вводилась бы в командной строке оболочки. Это включает, например, кавычки или обратный слеш для имен файлов с пробелами в них. Если args является последовательностью, первый элемент задаёт строку команды, а все дополнительные элементы будут рассматриваться как дополнительные аргументы для самой оболочки. То есть, Popen делает эквивалент:

Popen(['/bin/sh', '-c', args[0], args[1], ...])

В Windows с shell=True, переменная среды COMSPEC задаёт оболочку по умолчанию. Единственный случай, когда вам нужно указать shell=True в Windows, это когда команда, которую вы хотите выполнить, встроенна в оболочку (например, dir или copy). Вам не нужен shell=True для запуска пакетного файла или консольной исполняемой программы.

Предупреждение

Передача shell=True может быть угрозой безопасности, если она сочетается с недоверенным вводом. Подробности см. в предупреждении в разделе Часто используемые аргументы.

bufsize, если задан, имеет то же значение, что и соответствующий аргумент встроенной функции open(): 0 означает небуферизованный, 1 означает буферизованный по строкам, любое другое положительное значение означает использование буфера размера (приблизительно) этого значения. Отрицательное значение bufsize означает использование системного значения по умолчанию, что обычно означает полностью буферизованный режим. Значение по умолчанию для bufsize - 0 (небуферизованный).

Примечание

Если у вас возникают проблемы с производительностью, рекомендуется попробовать включить буферизацию, установив bufsize либо в -1, либо в достаточно большое положительное значение (например, 4096).

Аргумент executable указывает заменяющую программу для выполнения. Он редко нужен. Когда shell=False, executable заменяет программу для выполнения, указанную args. Однако исходные args по-прежнему передаются программе. Большинство программ рассматривают программу, указанную args, как имя команды, которое может отличаться от фактически выполняемой программы. В Unix, имя args становится отображаемым именем исполняемого файла в таких утилитах, как ps. Если shell=True, в Unix, аргумент executable задаёт заменяющую оболочку для стандартной оболочки /bin/sh.

stdin, stdout и stderr соответственно указывают стандартный ввод, стандартный вывод и стандартный вывод ошибок выполняемой программы. Допустимые значения - PIPE, существующий дескриптор файла (положительное целое число), существующий объект файла и None. PIPE указывает на создание новой трубы с дочерним процессом. При стандартных настройках None, перенаправление не произойдёт; дескрипторы файлов дочернего процесса будут унаследованы от родительского. Кроме того, stderr может быть STDOUT, что указывает на то, что данные stderr дочернего процесса должны быть записаны в тот же файл, что и stdout.

Если preexec_fn задан как вызываемый объект, этот объект будет вызван в дочернем процессе непосредственно перед выполнением дочернего процесса. (Только Unix)

Если close_fds имеет значение true, все дескрипторы файлов, кроме 0, 1 и 2, будут закрыты до запуска дочернего процесса. (Только Unix). Или, в Windows, если close_fds имеет значение true, никакие дескрипторы не будут унаследованы дочерним процессом. Обратите внимание, что в Windows нельзя установить close_fds в true и одновременно перенаправить стандартные дескрипторы, установив stdin, stdout или stderr.

Если cwd не None, текущая директория дочернего процесса будет изменена на cwd перед его запуском. Обратите внимание, что эта директория не учитывается при поиске исполняемого файла, поэтому вы не можете указать путь к программе относительно cwd.

Если env не None, он должен быть отображением, определяющим переменные среды для нового процесса; они используются вместо наследования переменных среды текущего процесса, что является поведением по умолчанию.

Примечание

Если задано, env должен предоставить все переменные, необходимые для выполнения программы. В Windows, чтобы запустить side-by-side assembly, указанное env должно содержать действительную SystemRoot.

Если universal_newlines True, объекты файлов stdout и stderr открываются как текстовые файлы в режиме универсальных новых строк. Строки могут быть завершены любым из '\n', стандартной конвенцией Unix, '\r', старой конвенцией Macintosh или '\r\n', конвенцией Windows. Все эти внешние представления видны в программе Python как '\n'.

Примечание

Эта функция доступна только, если Python скомпилирован с поддержкой универсальных новых строк (по умолчанию). Также, атрибут newlines объектов файлов stdout, stdin и stderr не обновляются методом communicate().

Если задан, startupinfo будет объектом STARTUPINFO, который передаётся в функцию CreateProcess. creationflags, если задан, может быть CREATE_NEW_CONSOLE или CREATE_NEW_PROCESS_GROUP. (Только Windows)

1.3. Исключения

Исключения, возникшие в дочернем процессе до начала выполнения новой программы, будут повторно вызваны в родительском процессе. Кроме того, у объекта исключения будет дополнительный атрибут, называемый child_traceback, который является строкой, содержащей информацию о трассировке стека с точки зрения дочернего процесса.

Наиболее распространённое исключение - OSError. Это происходит, например, при попытке выполнить несуществующий файл. Приложения должны быть готовы к исключениям OSError.

Исключение ValueError будет вызвано, если Popen вызван с недопустимыми аргументами.

check_call() и check_output() вызовут CalledProcessError, если вызванный процесс вернёт код возврата, отличный от нуля.

1.4. Безопасность

В отличие от некоторых других функций popen, данная реализация никогда не вызывает систему оболочки неявно. Это означает, что все символы, включая метасимволы оболочки, могут безопасно передаваться дочерним процессам. Очевидно, если оболочка вызывается явно, то приложение несёт ответственность за правильное использование кавычек и метасимволов.

2. Объекты Popen

У экземпляров класса Popen есть следующие методы:

Popen.poll()

Проверить, завершился ли дочерний процесс. Установить и вернуть атрибут returncode.

Popen.wait()

Дождаться завершения дочернего процесса. Установить и вернуть атрибут returncode атрибут.

Предупреждение

Это может привести к тупиковой ситуации при использовании stdout=PIPE и/или stderr=PIPE и если дочерний процесс генерирует достаточный объем вывода в канал, так что он блокируется в ожидании, пока буфер канала ОС не примет больше данных. Используйте communicate(), чтобы избежать этого.

Popen.communicate(input=None)

Взаимодействие с процессом: Отправка данных в стандартный ввод. Чтение данных из стандартного вывода и стандартной ошибки, пока не достигнет конца файла. Дождаться завершения процесса. Необязательный аргумент input должен быть строкой, отправляемой дочернему процессу, или None, если данные не должны отправляться.

communicate() возвращает кортеж (stdoutdata, stderrdata).

Обратите внимание, что если вы хотите отправить данные в стандартный ввод процесса, вам нужно создать объект Popen с stdin=PIPE. Аналогично, для получения чего-либо, кроме None в кортеже результата, вам необходимо предоставить stdout=PIPE и/или stderr=PIPE.

Примечание

Считанные данные буферизуются в памяти, поэтому не используйте этот метод, если размер данных большой или неограничен.

Popen.send_signal(signal)

Отправка сигнала signal дочернему процессу.

Примечание

В Windows SIGTERM является псевдонимом для terminate(). CTRL_C_EVENT и CTRL_BREAK_EVENT могут быть отправлены процессам, запущенным с параметром creationflags, который включает CREATE_NEW_PROCESS_GROUP.

Добавлена в версии 2.6.

Popen.terminate()

Останавливает дочерний процесс. В операционных системах семейства POSIX метод отправляет сигнал SIGTERM дочернему процессу. В Windows вызывается функция Win32 API TerminateProcess() для остановки дочернего процесса.

Добавлена в версии 2.6.

Popen.kill()

Убивает дочерний процесс. В операционных системах семейства POSIX функция отправляет сигнал SIGKILL дочернему процессу. В Windows kill() является псевдонимом для terminate().

Добавлена в версии 2.6.

Также доступны следующие атрибуты:

Popen.stdin

Если аргумент stdin был PIPE, этот атрибут — это объект файла, который предоставляет ввод для дочернего процесса. В противном случае, это None.

Popen.stdout

Если аргумент stdout был PIPE, этот атрибут — это объект файла, который предоставляет вывод от дочернего процесса. В противном случае, это None.

Popen.stderr

Если аргумент stderr был PIPE, этот атрибут — это объект файла, который предоставляет вывод об ошибках от дочернего процесса. В противном случае, это None.

Popen.pid

Идентификатор процесса дочернего процесса.

Обратите внимание, что если вы установите аргумент shell в True, это идентификатор процесса запущенной оболочки.

Popen.returncode

Код возврата дочернего процесса, установленный poll() и wait() (и косвенно communicate()). Значение None указывает, что процесс еще не завершен.

Отрицательное значение -N указывает, что дочерний процесс был завершен сигналом N (только Unix).

3. Помощники Windows Popen

Класс STARTUPINFO и следующие константы доступны только в Windows.

class subprocess.STARTUPINFO

Частичная поддержка структуры Windows STARTUPINFO используется для создания Popen.

dwFlags

Поле битов, определяющее, используются ли определенные атрибуты STARTUPINFO при создании окна процесса.

si = subprocess.STARTUPINFO()
si.dwFlags = subprocess.STARTF_USESTDHANDLES | subprocess.STARTF_USESHOWWINDOW

hStdInput

Если dwFlags указывает STARTF_USESTDHANDLES, этот атрибут — это дескриптор стандартного ввода для процесса. Если STARTF_USESTDHANDLES не указан, по умолчанию стандартный ввод — буфер клавиатуры.

hStdOutput

Если dwFlags указывает STARTF_USESTDHANDLES, этот атрибут — это дескриптор стандартного вывода для процесса. В противном случае этот атрибут игнорируется, и по умолчанию стандартный вывод — буфер окна консоли.

hStdError

Если dwFlags указывает STARTF_USESTDHANDLES, этот атрибут — это дескриптор стандартной ошибки для процесса. В противном случае этот атрибут игнорируется, и по умолчанию стандартная ошибка — буфер окна консоли.

wShowWindow

Если dwFlags указывает STARTF_USESHOWWINDOW, этот атрибут может принимать любое из значений, которые могут быть указаны в параметре nCmdShow для функции ShowWindow, за исключением SW_SHOWDEFAULT. В противном случае этот атрибут игнорируется.

SW_HIDE предоставляется для этого атрибута. Он используется, когда Popen вызывается с shell=True.

3.1. Константы

Модуль subprocess предоставляет следующие константы.

subprocess.STD_INPUT_HANDLE

Устройство стандартного ввода. Изначально это буфер ввода консоли, CONIN$.

subprocess.STD_OUTPUT_HANDLE

Устройство стандартного вывода. Изначально это активный буфер экрана консоли, CONOUT$.

subprocess.STD_ERROR_HANDLE

Устройство стандартной ошибки. Изначально это активный буфер экрана консоли, CONOUT$.

subprocess.SW_HIDE

Скрывает окно. Активное станет другое окно.

subprocess.STARTF_USESTDHANDLES

Указывает, что атрибуты STARTUPINFO.hStdInput, STARTUPINFO.hStdOutput и STARTUPINFO.hStdError содержат дополнительную информацию.

subprocess.STARTF_USESHOWWINDOW

Указывает, что атрибут STARTUPINFO.wShowWindow содержит дополнительную информацию.

subprocess.CREATE_NEW_CONSOLE

Новый процесс получает новую консоль вместо наследования консоли родительского процесса (по умолчанию).

Этот флаг всегда устанавливается при создании объекта Popen с помощью shell=True.

subprocess.CREATE_NEW_PROCESS_GROUP

Параметр для объекта Popen creationflags, указывающий на создание новой группы процессов. Этот флаг необходим для использования os.kill() с подпроцессом.

Этот флаг игнорируется, если указан CREATE_NEW_CONSOLE.

4. Замена устаревших функций модулем subprocess

В этом разделе «a заменяется на b» означает, что b можно использовать вместо a.

В следующих примерах предполагается, что соответствующие функции уже импортированы из модуля subprocess.

4.1. Замена оболочки /bin/sh с обратными кавычками

output=`mycmd myarg`

становится:

output = check_output(["mycmd", "myarg"])

4.2. Замена командной цепочки оболочки

output=`dmesg | grep hda`

становится:

p1 = Popen(["dmesg"], stdout=PIPE)
p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
p1.stdout.close()  # Allow p1 to receive a SIGPIPE if p2 exits.
output = p2.communicate()[0]

Вызов p1.stdout.close() после запуска p2 важен, чтобы p1 получил SIGPIPE, если p2 завершится до p1.

В качестве альтернативы, для безопасного ввода, собственная поддержка командной цепочки оболочки может быть использована напрямую:

output=`dmesg | grep hda`

становится:

output=check_output("dmesg | grep hda", shell=True)

4.3. Замена os.system()

status = os.system("mycmd" + " myarg")
# becomes
status = subprocess.call("mycmd" + " myarg", shell=True)

Примечания:

• Вызов программы через оболочку обычно не требуется.

Более реалистичный пример:

try:
    retcode = call("mycmd" + " myarg", shell=True)
    if retcode < 0:
        print >>sys.stderr, "Child was terminated by signal", -retcode
    else:
        print >>sys.stderr, "Child returned", retcode
except OSError as e:
    print >>sys.stderr, "Execution failed:", e

4.4. Замена семейства функций os.spawn

Пример P_NOWAIT:

pid = os.spawnlp(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg")
==>
pid = Popen(["/bin/mycmd", "myarg"]).pid

Пример P_WAIT:

retcode = os.spawnlp(os.P_WAIT, "/bin/mycmd", "mycmd", "myarg")
==>
retcode = call(["/bin/mycmd", "myarg"])

Пример с векторами:

os.spawnvp(os.P_NOWAIT, path, args)
==>
Popen([path] + args[1:])

Пример с окружением:

os.spawnlpe(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg", env)
==>
Popen(["/bin/mycmd", "myarg"], env={"PATH": "/usr/bin"})

4.5. Замена os.popen(), os.popen2(), os.popen3()

pipe = os.popen("cmd", 'r', bufsize)
==>
pipe = Popen("cmd", shell=True, bufsize=bufsize, stdout=PIPE).stdout

pipe = os.popen("cmd", 'w', bufsize)
==>
pipe = Popen("cmd", shell=True, bufsize=bufsize, stdin=PIPE).stdin

(child_stdin, child_stdout) = os.popen2("cmd", mode, bufsize)
==>
p = Popen("cmd", shell=True, bufsize=bufsize,
          stdin=PIPE, stdout=PIPE, close_fds=True)
(child_stdin, child_stdout) = (p.stdin, p.stdout)

(child_stdin,
 child_stdout,
 child_stderr) = os.popen3("cmd", mode, bufsize)
==>
p = Popen("cmd", shell=True, bufsize=bufsize,
          stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True)
(child_stdin,
 child_stdout,
 child_stderr) = (p.stdin, p.stdout, p.stderr)

(child_stdin, child_stdout_and_stderr) = os.popen4("cmd", mode,
                                                   bufsize)
==>
p = Popen("cmd", shell=True, bufsize=bufsize,
          stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)
(child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout)

В Unix, os.popen2, os.popen3 и os.popen4 также принимают последовательность как команду для выполнения, в этом случае аргументы передаются программе напрямую без участия оболочки. Это использование можно заменить следующим образом:

(child_stdin, child_stdout) = os.popen2(["/bin/ls", "-l"], mode,
                                        bufsize)
==>
p = Popen(["/bin/ls", "-l"], bufsize=bufsize, stdin=PIPE, stdout=PIPE)
(child_stdin, child_stdout) = (p.stdin, p.stdout)

Обработка кода возврата преобразуется следующим образом:

pipe = os.popen("cmd", 'w')
...
rc = pipe.close()
if rc is not None and rc >> 8:
    print "There were some errors"
==>
process = Popen("cmd", shell=True, stdin=PIPE)
...
process.stdin.close()
if process.wait() != 0:
    print "There were some errors"

4.6. Замена функций из модуля popen2

(child_stdout, child_stdin) = popen2.popen2("somestring", bufsize, mode)
==>
p = Popen("somestring", shell=True, bufsize=bufsize,
          stdin=PIPE, stdout=PIPE, close_fds=True)
(child_stdout, child_stdin) = (p.stdout, p.stdin)

В Unix, popen2 также принимает последовательность как команду для выполнения, в этом случае аргументы передаются программе напрямую без участия оболочки. Это использование можно заменить следующим образом:

(child_stdout, child_stdin) = popen2.popen2(["mycmd", "myarg"], bufsize,
                                            mode)
==>
p = Popen(["mycmd", "myarg"], bufsize=bufsize,
          stdin=PIPE, stdout=PIPE, close_fds=True)
(child_stdout, child_stdin) = (p.stdout, p.stdin)

popen2.Popen3 и popen2.Popen4 в основном работают как subprocess.Popen, за исключением того, что:

• Popen генерирует исключение, если выполнение завершается неудачно.
• аргумент capturestderr заменяется аргументом stderr.
• stdin=PIPE и stdout=PIPE должны быть указаны.
• popen2 закрывает все дескрипторы файлов по умолчанию, но вы должны указать close_fds=True с Popen.

5. Примечания

5.1. Преобразование последовательности аргументов в строку в Windows

В Windows последовательность args преобразуется в строку, которую можно обработать с помощью следующих правил (которые соответствуют правилам, используемым MS C runtime):

1. Аргументы разделяются пробелами, которые могут быть пробелами или табуляцией.
2. Строка в двойных кавычках интерпретируется как один аргумент, независимо от пробелов внутри. В аргументе могут быть вложены строковые значения в кавычках.
3. Двойная кавычка, предшествуемая обратной косой чертой, интерпретируется как буквальная двойная кавычка.
4. Обратные косые черты интерпретируются буквально, за исключением случаев, когда они непосредственно предшествуют двойной кавычке.
5. Если обратные косые черты непосредственно предшествуют двойной кавычке, каждая пара обратных косых черт интерпретируется как буквальная обратная косая черта. Если число обратных косых черт нечетное, последняя обратная косая черта экранирует следующую двойную кавычку, как описано в правиле 3.