> **Источник:** https://python-all.ru/3.3/library/subprocess.html
>
> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.

---

# 17.5. [`subprocess`](https://python-all.ru/3.3/library/subprocess.html#module-subprocess) – Управление подпроцессами

Модуль [`subprocess`](https://python-all.ru/3.3/library/subprocess.html#module-subprocess) позволяет порождать новые процессы, подключаться к их каналам ввода/вывода/ошибок и получать коды возврата. Этот модуль призван заменить несколько более старых модулей и функций:

```python
os.system
os.spawn*
```

Информация о том, как модуль [`subprocess`](https://python-all.ru/3.3/library/subprocess.html#module-subprocess) может использоваться для замены этих модулей и функций, приведена в следующих разделах.

> **См. также**
>
> [**PEP 324**](https://python-all.ru/3.3/library/subprocess.html) – PEP, предлагающий модуль подпроцесса

## 17.5.1. Использование модуля [`subprocess`](https://python-all.ru/3.3/library/subprocess.html#module-subprocess)

Рекомендуемый способ запуска подпроцессов – использовать следующие удобные функции во всех случаях, где они применимы. Для более сложных случаев можно напрямую использовать низкоуровневый интерфейс [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen).

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

Выполняет команду, описанную аргументом *args*. Ожидает завершения команды, затем возвращает атрибут `returncode`.

Аргументы, перечисленные выше, являются лишь наиболее распространёнными; они описаны ниже в разделе [*Часто используемые аргументы*](https://python-all.ru/3.3/library/subprocess.html#frequently-used-arguments) (отсюда использование нотации только ключевых слов в сокращённой сигнатуре). Полная сигнатура функции в значительной степени совпадает с сигнатурой конструктора [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen) – эта функция передаёт все указанные аргументы, кроме *timeout*, напрямую этому интерфейсу.

Аргумент *timeout* передаётся в [`Popen.wait()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.wait). Если время ожидания истекает, дочерний процесс будет убит, после чего ожидание повторяется. Исключение [`TimeoutExpired`](https://python-all.ru/3.3/library/subprocess.html#subprocess.TimeoutExpired) будет возбуждено повторно после завершения дочернего процесса.

Примеры:

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

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

> **Предупреждение**
>
> Вызов системной оболочки с `shell=True` может быть опасен для безопасности, если используется вместе с недоверенными входными данными. Подробнее см. предупреждение в разделе [*Часто используемые аргументы*](https://python-all.ru/3.3/library/subprocess.html#frequently-used-arguments).

> **Примечание**
>
> Не используйте `stdout=PIPE` или `stderr=PIPE` с этой функцией. Поскольку каналы не читаются текущим процессом, дочерний процесс может заблокироваться, если он генерирует достаточно выходных данных для заполнения буфера канала ОС.

Изменено в версии 3.3: добавлен *timeout*.

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

Выполняет команду с аргументами. Ожидает завершения команды. Если код возврата равен нулю, возвращает управление, иначе возбуждает [`CalledProcessError`](https://python-all.ru/3.3/library/subprocess.html#subprocess.CalledProcessError). Объект [`CalledProcessError`](https://python-all.ru/3.3/library/subprocess.html#subprocess.CalledProcessError) будет содержать код возврата в атрибуте [`returncode`](https://python-all.ru/3.3/library/subprocess.html#subprocess.CalledProcessError.returncode).

Аргументы, перечисленные выше, являются лишь наиболее распространёнными; они описаны ниже в разделе [*Часто используемые аргументы*](https://python-all.ru/3.3/library/subprocess.html#frequently-used-arguments) (отсюда использование нотации только ключевых слов в сокращённой сигнатуре). Полная сигнатура функции в значительной степени совпадает с сигнатурой конструктора [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen) – эта функция передаёт все указанные аргументы, кроме *timeout*, напрямую этому интерфейсу.

Аргумент *timeout* передаётся в [`Popen.wait()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.wait). Если время ожидания истекает, дочерний процесс будет убит, после чего ожидание повторяется. Исключение [`TimeoutExpired`](https://python-all.ru/3.3/library/subprocess.html#subprocess.TimeoutExpired) будет возбуждено повторно после завершения дочернего процесса.

Примеры:

```python
>>> 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
```

> **Предупреждение**
>
> Вызов системной оболочки с `shell=True` может быть опасен для безопасности, если используется вместе с недоверенными входными данными. Подробнее см. предупреждение в разделе [*Часто используемые аргументы*](https://python-all.ru/3.3/library/subprocess.html#frequently-used-arguments).

> **Примечание**
>
> Не используйте `stdout=PIPE` или `stderr=PIPE` с этой функцией. Поскольку каналы не читаются текущим процессом, дочерний процесс может заблокироваться, если он генерирует достаточно выходных данных для заполнения буфера канала ОС.

Изменено в версии 3.3: добавлен *timeout*.

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

Выполняет команду с аргументами и возвращает её вывод.

Если код возврата был ненулевым, возбуждается исключение [`CalledProcessError`](https://python-all.ru/3.3/library/subprocess.html#subprocess.CalledProcessError). Объект [`CalledProcessError`](https://python-all.ru/3.3/library/subprocess.html#subprocess.CalledProcessError) будет содержать код возврата в атрибуте [`returncode`](https://python-all.ru/3.3/library/subprocess.html#subprocess.CalledProcessError.returncode) и весь вывод в атрибуте [`output`](https://python-all.ru/3.3/library/subprocess.html#subprocess.CalledProcessError.output).

Аргументы, показанные выше, – это лишь самые распространённые, описанные ниже в разделе [*Часто используемые аргументы*](https://python-all.ru/3.3/library/subprocess.html#frequently-used-arguments) (отсюда использование нотации только ключевых слов в сокращённой сигнатуре). Полная сигнатура функции в значительной мере совпадает с сигнатурой конструктора [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen) – эта функция передаёт все переданные аргументы, кроме *timeout*, непосредственно через этот интерфейс. Кроме того, *stdout* не допускается в качестве аргумента, так как он используется внутри для сбора вывода от подпроцесса.

Аргумент *timeout* передаётся в [`Popen.wait()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.wait). Если время ожидания истекает, дочерний процесс будет убит, после чего ожидание повторяется. Исключение [`TimeoutExpired`](https://python-all.ru/3.3/library/subprocess.html#subprocess.TimeoutExpired) будет возбуждено повторно после завершения дочернего процесса.

Примеры:

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

>>> subprocess.check_output(["echo", "Hello World!"], universal_newlines=True)
'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
```

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

Это поведение можно переопределить, установив *universal\_newlines* в `True`, как описано ниже в разделе [*Часто используемые аргументы*](https://python-all.ru/3.3/library/subprocess.html#frequently-used-arguments).

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

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

Новое в версии 3.1.

> **Предупреждение**
>
> Вызов системной оболочки с `shell=True` может быть опасен для безопасности, если используется вместе с недоверенными входными данными. Подробнее см. предупреждение в разделе [*Часто используемые аргументы*](https://python-all.ru/3.3/library/subprocess.html#frequently-used-arguments).

> **Примечание**
>
> Не используйте `stderr=PIPE` с этой функцией. Поскольку канал не читается текущим процессом, дочерний процесс может заблокироваться, если он генерирует достаточно выходных данных для заполнения буфера канала ОС.

Изменено в версии 3.3: добавлен *timeout*.

#### `subprocess.DEVNULL`

Специальное значение, которое может использоваться в качестве аргумента *stdin*, *stdout* или *stderr* для [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen) и указывает, что будет использоваться специальный файл [`os.devnull`](https://python-all.ru/3.3/library/os.html#os.devnull).

Новое в версии 3.3.

#### `subprocess.PIPE`

Специальное значение, которое может использоваться в качестве аргумента *stdin*, *stdout* или *stderr* для [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen) и указывает, что должен быть открыт канал к стандартному потоку.

#### `subprocess.STDOUT`

Специальное значение, которое может использоваться в качестве аргумента *stderr* для [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen) и указывает, что стандартный поток ошибок должен направляться в тот же дескриптор, что и стандартный вывод.

#### `exception subprocess.SubprocessError`

Базовый класс для всех остальных исключений из этого модуля.

Новое в версии 3.3.

#### `exception subprocess.TimeoutExpired`

Подкласс [`SubprocessError`](https://python-all.ru/3.3/library/subprocess.html#subprocess.SubprocessError), возникающий при истечении тайм-аута в ожидании дочернего процесса.

#### `cmd`

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

#### `timeout`

Тайм-аут в секундах.

#### `output`

Вывод дочернего процесса, если это исключение вызвано [`check_output()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.check_output). В противном случае – `None`.

Новое в версии 3.3.

#### `exception subprocess.CalledProcessError`

Подкласс [`SubprocessError`](https://python-all.ru/3.3/library/subprocess.html#subprocess.SubprocessError), возникающий, когда процесс, запущенный [`check_call()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.check_call) или [`check_output()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.check_output), возвращает ненулевой код возврата.

#### `returncode`

Код возврата дочернего процесса.

#### `cmd`

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

#### `output`

Вывод дочернего процесса, если это исключение вызвано [`check_output()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.check_output). В противном случае – `None`.

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

Для поддержки широкого круга сценариев использования конструктор [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen) (и удобные функции) принимают большое количество необязательных аргументов. В большинстве типичных случаев многие из этих аргументов можно смело оставить со значениями по умолчанию. Наиболее часто требуемые аргументы:

> *args* обязателен для всех вызовов и должен быть строкой или последовательностью аргументов программы. Передача последовательности аргументов, как правило, предпочтительнее, поскольку позволяет модулю позаботиться о необходимом экранировании и кавычках (например, для пробелов в именах файлов). Если передаётся одна строка, то либо *shell* должен быть [`True`](https://python-all.ru/3.3/library/constants.html#True) (см. ниже), либо строка должна просто задавать имя исполняемой программы без указания аргументов.
>
> *stdin*, *stdout* и *stderr* задают дескрипторы стандартного ввода, стандартного вывода и стандартного вывода ошибок выполняемой программы. Допустимые значения: [`PIPE`](https://python-all.ru/3.3/library/subprocess.html#subprocess.PIPE), [`DEVNULL`](https://python-all.ru/3.3/library/subprocess.html#subprocess.DEVNULL), существующий файловый дескриптор (положительное целое число), существующий файловый объект и `None`. [`PIPE`](https://python-all.ru/3.3/library/subprocess.html#subprocess.PIPE) означает, что следует создать новый канал к дочернему процессу. [`DEVNULL`](https://python-all.ru/3.3/library/subprocess.html#subprocess.DEVNULL) означает, что будет использоваться специальный файл [`os.devnull`](https://python-all.ru/3.3/library/os.html#os.devnull). При настройках по умолчанию (`None`) перенаправление не происходит; дескрипторы файлов дочернего процесса наследуются от родительского. Кроме того, *stderr* может быть [`STDOUT`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STDOUT), что означает, что данные stderr дочернего процесса должны быть направлены в тот же дескриптор, что и *stdout*.
>
> Если *universal\_newlines* равен `False`, файловые объекты *stdin*, *stdout* и *stderr* открываются как бинарные потоки, и преобразование концов строк не выполняется.
>
> Если *universal\_newlines* равен `True`, эти файловые объекты открываются как текстовые потоки в режиме [*universal newlines*](https://python-all.ru/3.3/glossary.html#term-universal-newlines) с использованием кодировки, возвращаемой [`locale.getpreferredencoding(False)`](https://python-all.ru/3.3/library/locale.html#locale.getpreferredencoding). Для *stdin* символы конца строки `'\n'` во входных данных преобразуются в разделитель строк по умолчанию [`os.linesep`](https://python-all.ru/3.3/library/os.html#os.linesep). Для *stdout* и *stderr* все концы строк в выводе преобразуются в `'\n'`. Дополнительную информацию см. в документации класса [`io.TextIOWrapper`](https://python-all.ru/3.3/library/io.html#io.TextIOWrapper), когда аргумент *newline* его конструктора равен `None`.
>
> > **Примечание**
> >
> > Атрибут newlines файловых объектов [`Popen.stdin`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.stdin), [`Popen.stdout`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.stdout) и [`Popen.stderr`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.stderr) не обновляется методом [`Popen.communicate()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.communicate).
>
> Если *shell* равен `True`, указанная команда будет выполняться через оболочку. Это может быть полезно, если Python используется в первую очередь из-за улучшенного управления потоком выполнения по сравнению с большинством системных оболочек, и при этом нужен удобный доступ к другим возможностям оболочки, таким как конвейеры, маски имён файлов, подстановка переменных окружения и подстановка `~` в домашний каталог пользователя. Однако следует отметить, что сам Python предоставляет реализации многих возможностей, похожих на оболочку (в частности, [`glob`](https://python-all.ru/3.3/library/glob.html#module-glob), [`fnmatch`](https://python-all.ru/3.3/library/fnmatch.html#module-fnmatch), [`os.walk()`](https://python-all.ru/3.3/library/os.html#os.walk), [`os.path.expandvars()`](https://python-all.ru/3.3/library/os.path.html#os.path.expandvars), [`os.path.expanduser()`](https://python-all.ru/3.3/library/os.path.html#os.path.expanduser) и [`shutil`](https://python-all.ru/3.3/library/shutil.html#module-shutil)).
>
> Изменено в версии 3.3: Когда *universal\_newlines* равен `True`, класс использует кодировку [`locale.getpreferredencoding(False)`](https://python-all.ru/3.3/library/locale.html#locale.getpreferredencoding) вместо `locale.getpreferredencoding()`. Подробнее об этом изменении см. в документации класса [`io.TextIOWrapper`](https://python-all.ru/3.3/library/io.html#io.TextIOWrapper).
>
> > **Предупреждение**
> >
> > Выполнение команд оболочки, содержащих непроверенные входные данные из недоверенного источника, делает программу уязвимой к [внедрению в оболочку](https://python-all.ru/3.3/library/subprocess.html) – серьёзной уязвимости безопасности, которая может привести к выполнению произвольных команд. По этой причине использование `shell=True` **настоятельно не рекомендуется** в случаях, когда командная строка формируется из внешних данных:
> >
> > ```python
> > >>> 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) # Ой-ой. Это плохо кончится...
> > ```
> >
> > `shell=False` отключает все функции на основе оболочки, но не подвержен этой уязвимости; обратитесь к примечанию в документации конструктора [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen) за полезными советами по настройке `shell=False`.
> >
> > При использовании `shell=True`, [`shlex.quote()`](https://python-all.ru/3.3/library/shlex.html#shlex.quote) может использоваться для правильного экранирования пробелов и метасимволов оболочки в строках, которые будут использоваться для построения команд оболочки.

Эти параметры, как и все остальные, более подробно описаны в документации конструктора [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen).

### 17.5.1.2. Конструктор Popen

Создание и управление процессами в этом модуле осуществляется классом [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen). Он предоставляет большую гибкость, позволяя разработчикам обрабатывать менее распространённые случаи, не охваченные удобными функциями.

#### `class subprocess.Popen(args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=True, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0, restore_signals=True, start_new_session=False, pass_fds=())`

Запускает дочернюю программу в новом процессе. На Unix класс использует поведение, подобное [`os.execvp()`](https://python-all.ru/3.3/library/os.html#os.execvp), для выполнения дочерней программы. На Windows класс использует функцию Windows `CreateProcess()`. Аргументы [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen) следующие.

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

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

> **Примечание**
>
> [`shlex.split()`](https://python-all.ru/3.3/library/shlex.html#shlex.split) может быть полезен при определении правильной токенизации *args*, особенно в сложных случаях:
>
> ```python
> >>> import shlex, subprocess
> >>> command_line = 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) # Успешно!
> ```
>
> Обратите внимание, что опции (такие как *-input*) и аргументы (такие как *eggs.txt*), разделённые пробелами в оболочке, помещаются в отдельные элементы списка, в то время как аргументы, требующие кавычек или обратной косой черты в оболочке (например, имена файлов, содержащие пробелы, или команда *echo*, показанная выше), являются отдельными элементами списка.

В Windows, если *args* является последовательностью, она будет преобразована в строку способом, описанным в разделе [*Преобразование последовательности аргументов в строку в Windows*](https://python-all.ru/3.3/library/subprocess.html#converting-argument-sequence). Это связано с тем, что базовая функция `CreateProcess()` работает со строками.

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

В Unix с `shell=True` оболочкой по умолчанию является `/bin/sh`. Если *args* – строка, она задаёт команду для выполнения через оболочку. Это означает, что строка должна быть отформатирована точно так, как если бы она была введена в приглашении оболочки. Сюда входит, например, экранирование кавычками или обратной косой чертой имён файлов с пробелами. Если *args* – последовательность, первый элемент задаёт командную строку, а все дополнительные элементы будут рассматриваться как дополнительные аргументы для самой оболочки. Иными словами, [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen) делает эквивалент следующего:

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

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

> **Предупреждение**
>
> Передача `shell=True` может быть опасна для безопасности при использовании с недоверенными входными данными. Подробнее см. предупреждение в разделе [*Часто используемые аргументы*](https://python-all.ru/3.3/library/subprocess.html#frequently-used-arguments).

*bufsize* будет передан как соответствующий аргумент функции [`open()`](https://python-all.ru/3.3/library/functions.html#open) при создании файловых объектов каналов stdin/stdout/stderr: `0` означает отсутствие буферизации (чтение и запись – один системный вызов, может вернуть меньше данных), `1` означает построчную буферизацию, любое другое положительное значение означает использование буфера приблизительно этого размера. Отрицательное значение bufsize (по умолчанию) означает, что будет использоваться системное значение по умолчанию io.DEFAULT\_BUFFER\_SIZE.

Изменено в версии 3.3.1: *bufsize* теперь по умолчанию равен -1, чтобы включить буферизацию по умолчанию, как того ожидает большинство кода. В версиях до Python 3.2.4 и 3.3.1 по умолчанию ошибочно использовалось `0`, что означало отсутствие буферизации и допускало короткие чтения. Это было непреднамеренно и не соответствовало поведению Python 2, как ожидал большинство кода.

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

*stdin*, *stdout* и *stderr* задают файловые дескрипторы стандартного ввода, стандартного вывода и стандартного вывода ошибок выполняемой программы соответственно. Допустимые значения: [`PIPE`](https://python-all.ru/3.3/library/subprocess.html#subprocess.PIPE), [`DEVNULL`](https://python-all.ru/3.3/library/subprocess.html#subprocess.DEVNULL), существующий файловый дескриптор (положительное целое число), существующий [*файловый объект*](https://python-all.ru/3.3/glossary.html#term-file-object) и `None`. [`PIPE`](https://python-all.ru/3.3/library/subprocess.html#subprocess.PIPE) означает, что должен быть создан новый канал к дочернему процессу. [`DEVNULL`](https://python-all.ru/3.3/library/subprocess.html#subprocess.DEVNULL) означает, что будет использоваться специальный файл [`os.devnull`](https://python-all.ru/3.3/library/os.html#os.devnull). При настройках по умолчанию `None` перенаправления не происходит; файловые дескрипторы дочернего процесса наследуются от родительского. Кроме того, *stderr* может быть [`STDOUT`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STDOUT), что означает, что данные stderr из приложений должны захватываться в тот же файловый дескриптор, что и stdout.

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

> **Предупреждение**
>
> Параметр *preexec\_fn* небезопасно использовать при наличии потоков в приложении. Дочерний процесс может зависнуть до вызова exec. Если его всё же нужно использовать, пусть он будет тривиальным! Сведите к минимуму количество вызываемых библиотек.

> **Примечание**
>
> Если нужно изменить окружение для дочернего процесса, используйте параметр *env* вместо изменения в *preexec\_fn*. Параметр *start\_new\_session* может заменить ранее распространённое использование *preexec\_fn* для вызова os.setsid() в дочернем процессе.

Если *close\_fds* имеет значение true, все файловые дескрипторы, кроме `0`, `1` и `2`, будут закрыты перед выполнением дочернего процесса. (Только Unix). Значение по умолчанию зависит от платформы: на Unix всегда true. На Windows оно равно true, когда *stdin*/*stdout*/*stderr* равны [`None`](https://python-all.ru/3.3/library/constants.html#None), и false в противном случае. На Windows, если *close\_fds* равно true, то дочерний процесс не наследует ни одного дескриптора. Обратите внимание, что в Windows нельзя одновременно установить *close\_fds* в true и перенаправлять стандартные дескрипторы, задавая *stdin*, *stdout* или *stderr*.

Изменено в версии 3.2: Значение по умолчанию для *close\_fds* было изменено с [`False`](https://python-all.ru/3.3/library/constants.html#False) на описанное выше.

*pass\_fds* – это необязательная последовательность файловых дескрипторов, которые должны оставаться открытыми между родительским и дочерним процессами. Если задан любой *pass\_fds*, то *close\_fds* принудительно устанавливается в [`True`](https://python-all.ru/3.3/library/constants.html#True). (Только Unix)

Новое в версии 3.2: Добавлен параметр *pass\_fds*.

Если *cwd* не равен `None`, функция меняет рабочий каталог на *cwd* перед выполнением дочернего процесса. В частности, функция ищет *executable* (или первый элемент в *args*) относительно *cwd*, если путь к исполняемому файлу является относительным.

Если *restore\_signals* имеет значение true (по умолчанию), все сигналы, которые Python установил в SIG\_IGN, восстанавливаются до SIG\_DFL в дочернем процессе перед exec. В настоящее время это включает сигналы SIGPIPE, SIGXFZ и SIGXFSZ. (Только Unix)

Изменено в версии 3.2: Добавлен *restore\_signals*.

Если *start\_new\_session* имеет значение true, системный вызов setsid() будет выполнен в дочернем процессе перед запуском подпроцесса. (Только Unix)

Изменено в версии 3.2: добавлен *start\_new\_session*.

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

> **Примечание**
>
> Если задан, то *env* должен предоставлять все переменные, необходимые для выполнения программы. В Windows, для запуска [side-by-side assembly](https://python-all.ru/3.3/library/subprocess.html), указанный *env* **обязан** включать корректный `SystemRoot`.

Если *universal\_newlines* равен `True`, файловые объекты *stdin*, *stdout* и *stderr* открываются как текстовые потоки в режиме универсальных новых строк, как описано выше в разделе [*Часто используемые аргументы*](https://python-all.ru/3.3/library/subprocess.html#frequently-used-arguments); в противном случае они открываются как двоичные потоки.

Если указан, *startupinfo* будет объектом [`STARTUPINFO`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STARTUPINFO), который передаётся базовой функции `CreateProcess`. *creationflags*, если заданы, могут быть [`CREATE_NEW_CONSOLE`](https://python-all.ru/3.3/library/subprocess.html#subprocess.CREATE_NEW_CONSOLE) или [`CREATE_NEW_PROCESS_GROUP`](https://python-all.ru/3.3/library/subprocess.html#subprocess.CREATE_NEW_PROCESS_GROUP) (только Windows).

Объекты Popen поддерживаются в качестве контекстных менеджеров с помощью оператора [`with`](https://python-all.ru/3.3/reference/compound_stmts.html#with): при выходе стандартные файловые дескрипторы закрываются, и выполняется ожидание завершения процесса.

```python
with Popen(["ifconfig"], stdout=PIPE) as proc:
    log.write(proc.stdout.read())
```

Изменено в версии 3.2: добавлена поддержка менеджера контекста.

### 17.5.1.3. Исключения

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

Наиболее часто возбуждаемым исключением является [`OSError`](https://python-all.ru/3.3/library/exceptions.html#OSError). Оно возникает, например, при попытке выполнить несуществующий файл. Приложения должны быть готовы к исключениям [`OSError`](https://python-all.ru/3.3/library/exceptions.html#OSError).

Исключение [`ValueError`](https://python-all.ru/3.3/library/exceptions.html#ValueError) будет возбуждено, если [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen) вызван с недопустимыми аргументами.

[`check_call()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.check_call) и [`check_output()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.check_output) возбудят [`CalledProcessError`](https://python-all.ru/3.3/library/subprocess.html#subprocess.CalledProcessError), если вызванный процесс вернёт ненулевой код возврата.

Все функции и методы, принимающие параметр *timeout*, такие как [`call()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.call) и [`Popen.communicate()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.communicate), возбудят [`TimeoutExpired`](https://python-all.ru/3.3/library/subprocess.html#subprocess.TimeoutExpired), если время ожидания истечёт до выхода процесса.

Все исключения, определённые в этом модуле, наследуются от [`SubprocessError`](https://python-all.ru/3.3/library/subprocess.html#subprocess.SubprocessError).

> Новое в версии 3.3: Был добавлен базовый класс [`SubprocessError`](https://python-all.ru/3.3/library/subprocess.html#subprocess.SubprocessError).

### 17.5.1.4. Безопасность

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

## 17.5.2. Объекты Popen

Экземпляры класса [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen) имеют следующие методы:

#### `Popen.poll()`

Проверяет, завершился ли дочерний процесс. Устанавливает и возвращает атрибут [`returncode`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.returncode).

#### `Popen.wait(timeout=None)`

Ожидает завершения дочернего процесса. Устанавливает и возвращает атрибут [`returncode`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.returncode).

Если процесс не завершается по истечении *timeout* секунд, возбуждается исключение [`TimeoutExpired`](https://python-all.ru/3.3/library/subprocess.html#subprocess.TimeoutExpired). Это исключение можно безопасно перехватить и повторить ожидание.

> **Предупреждение**
>
> Это приведёт к взаимоблокировке при использовании `stdout=PIPE` и/или `stderr=PIPE`, если дочерний процесс генерирует достаточно выходных данных для канала, так что он блокируется в ожидании, пока буфер канала ОС сможет принять больше данных. Используйте [`communicate()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.communicate), чтобы избежать этого.

Изменено в версии 3.3: добавлен *timeout*.

#### `Popen.communicate(input=None, timeout=None)`

Взаимодействует с процессом: отправляет данные в stdin. Читает данные из stdout и stderr до достижения конца файла. Ожидает завершения процесса. Необязательный аргумент *input* должен содержать данные для отправки дочернему процессу, или `None`, если данные отправлять не нужно. Тип *input* должен быть bytes или, если *universal\_newlines* был `True`, строкой.

[`communicate()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.communicate) возвращает кортеж `(stdoutdata, stderrdata)`.

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

Если процесс не завершится через *timeout* секунд, будет возбуждено исключение [`TimeoutExpired`](https://python-all.ru/3.3/library/subprocess.html#subprocess.TimeoutExpired). Перехват этого исключения и повторный вызов communication не приведёт к потере вывода.

Дочерний процесс не уничтожается по истечении тайм-аута, поэтому для корректной очистки хорошо написанное приложение должно уничтожить дочерний процесс и завершить обмен данными:

```python
proc = subprocess.Popen(...)
try:
    outs, errs = proc.communicate(timeout=15)
except TimeoutExpired:
    proc.kill()
    outs, errs = proc.communicate()
```

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

Изменено в версии 3.3: добавлен *timeout*.

#### `Popen.send_signal(signal)`

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

> **Примечание**
>
> В Windows SIGTERM – это псевдоним для [`terminate()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.terminate). Сигналы CTRL\_C\_EVENT и CTRL\_BREAK\_EVENT можно отправлять процессам, запущенным с параметром *creationflags*, включающим *CREATE\_NEW\_PROCESS\_GROUP*.

#### `Popen.terminate()`

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

#### `Popen.kill()`

Завершает дочерний процесс. В ОС POSIX функция отправляет дочернему процессу сигнал SIGKILL. В Windows [`kill()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.kill) – это псевдоним для [`terminate()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.terminate).

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

> **Предупреждение**
>
> Используйте [`communicate()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.communicate) вместо [`.stdin.write`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.stdin), [`.stdout.read`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.stdout) или [`.stderr.read`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.stderr), чтобы избежать взаимоблокировок из-за переполнения любого из буферов других каналов ОС, что блокирует дочерний процесс.

#### `Popen.args`

Аргумент *args* в том виде, в котором он был передан [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen): последовательность аргументов программы или одна строка.

Новое в версии 3.3.

#### `Popen.stdin`

Если аргумент *stdin* был равен [`PIPE`](https://python-all.ru/3.3/library/subprocess.html#subprocess.PIPE), этот атрибут содержит потоковый объект для записи, как возвращаемый функцией [`open()`](https://python-all.ru/3.3/library/functions.html#open). Если аргумент *universal\_newlines* был равен `True`, поток будет текстовым, иначе – байтовым. Если аргумент *stdin* не был равен [`PIPE`](https://python-all.ru/3.3/library/subprocess.html#subprocess.PIPE), этот атрибут равен `None`.

#### `Popen.stdout`

Если аргумент *stdout* был равен [`PIPE`](https://python-all.ru/3.3/library/subprocess.html#subprocess.PIPE), этот атрибут содержит потоковый объект для чтения, как возвращаемый функцией [`open()`](https://python-all.ru/3.3/library/functions.html#open). Чтение из потока даёт вывод дочернего процесса. Если аргумент *universal\_newlines* был равен `True`, поток будет текстовым, иначе – байтовым. Если аргумент *stdout* не был равен [`PIPE`](https://python-all.ru/3.3/library/subprocess.html#subprocess.PIPE), этот атрибут равен `None`.

#### `Popen.stderr`

Если аргумент *stderr* был равен [`PIPE`](https://python-all.ru/3.3/library/subprocess.html#subprocess.PIPE), этот атрибут содержит потоковый объект для чтения, как возвращаемый функцией [`open()`](https://python-all.ru/3.3/library/functions.html#open). Чтение из потока даёт вывод ошибок дочернего процесса. Если аргумент *universal\_newlines* был равен `True`, поток будет текстовым, иначе – байтовым. Если аргумент *stderr* не был равен [`PIPE`](https://python-all.ru/3.3/library/subprocess.html#subprocess.PIPE), этот атрибут равен `None`.

#### `Popen.pid`

PID дочернего процесса.

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

#### `Popen.returncode`

Код возврата дочернего процесса, устанавливаемый методами [`poll()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.poll) и [`wait()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.wait) (а косвенно и [`communicate()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.communicate)). Значение `None` указывает, что процесс ещё не завершён.

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

## 17.5.3. Вспомогательные средства Popen для Windows

Класс [`STARTUPINFO`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STARTUPINFO) и следующие константы доступны только в Windows.

#### `class subprocess.STARTUPINFO`

Частичная поддержка структуры Windows [STARTUPINFO](https://python-all.ru/3.3/library/subprocess.html) используется при создании [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen).

#### `dwFlags`

Битовое поле, определяющее, используются ли некоторые атрибуты структуры [`STARTUPINFO`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STARTUPINFO) при создании окна процесса.

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

#### `hStdInput`

Если в [`dwFlags`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STARTUPINFO.dwFlags) указан флаг [`STARTF_USESTDHANDLES`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STARTF_USESTDHANDLES), этот атрибут является дескриптором стандартного ввода процесса. Если [`STARTF_USESTDHANDLES`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STARTF_USESTDHANDLES) не указан, по умолчанию для стандартного ввода используется буфер клавиатуры.

#### `hStdOutput`

Если в [`dwFlags`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STARTUPINFO.dwFlags) указан флаг [`STARTF_USESTDHANDLES`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STARTF_USESTDHANDLES), этот атрибут является дескриптором стандартного вывода процесса. В противном случае этот атрибут игнорируется, и по умолчанию для стандартного вывода используется буфер окна консоли.

#### `hStdError`

If [`dwFlags`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STARTUPINFO.dwFlags) specifies [`STARTF_USESTDHANDLES`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STARTF_USESTDHANDLES), this attribute is the standard error handle for the process. Otherwise, this attribute is ignored and the default for standard error is the console window’s buffer.

#### `wShowWindow`

Если в [`dwFlags`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STARTUPINFO.dwFlags) указан флаг [`STARTF_USESHOWWINDOW`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STARTF_USESHOWWINDOW), то этот атрибут может принимать любое из значений, допустимых для параметра `nCmdShow` функции [ShowWindow](https://python-all.ru/3.3/library/subprocess.html), за исключением `SW_SHOWDEFAULT`. В противном случае данный атрибут игнорируется.

Для этого атрибута предусмотрено значение [`SW_HIDE`](https://python-all.ru/3.3/library/subprocess.html#subprocess.SW_HIDE). Оно используется, когда [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen) вызывается с параметром `shell=True`.

### 17.5.3.1. Константы

Модуль [`подпроцесс`](https://python-all.ru/3.3/library/subprocess.html#module-subprocess) предоставляет следующие константы.

#### `subprocess.STD_INPUT_HANDLE`

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

#### `subprocess.STD_OUTPUT_HANDLE`

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

#### `subprocess.STD_ERROR_HANDLE`

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

#### `subprocess.SW_HIDE`

Скрывает окно. Другое окно будет активировано.

#### `subprocess.STARTF_USESTDHANDLES`

Указывает, что атрибуты [`STARTUPINFO.hStdInput`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STARTUPINFO.hStdInput), [`STARTUPINFO.hStdOutput`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STARTUPINFO.hStdOutput) и [`STARTUPINFO.hStdError`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STARTUPINFO.hStdError) содержат дополнительную информацию.

#### `subprocess.STARTF_USESHOWWINDOW`

Указывает, что атрибут [`STARTUPINFO.wShowWindow`](https://python-all.ru/3.3/library/subprocess.html#subprocess.STARTUPINFO.wShowWindow) содержит дополнительную информацию.

#### `subprocess.CREATE_NEW_CONSOLE`

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

Этот флаг всегда устанавливается, когда [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen) создаётся с `shell=True`.

#### `subprocess.CREATE_NEW_PROCESS_GROUP`

Параметр `creationflags` функции [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen), указывающий, что будет создана новая группа процессов. Этот флаг необходим для использования [`os.kill()`](https://python-all.ru/3.3/library/os.html#os.kill) для подпроцесса.

Этот флаг игнорируется, если указан [`CREATE_NEW_CONSOLE`](https://python-all.ru/3.3/library/subprocess.html#subprocess.CREATE_NEW_CONSOLE).

## 17.5.4. Замена старых функций модулем [`подпроцесс`](https://python-all.ru/3.3/library/subprocess.html#module-subprocess)

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

> **Примечание**
>
> Все функции «a» в этом разделе при ненахождении исполняемой программы выдают ошибку (более или менее) молча; замены «b» вместо этого возбуждают исключение [`OSError`](https://python-all.ru/3.3/library/exceptions.html#OSError).
>
> Кроме того, замены с использованием [`check_output()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.check_output) завершатся ошибкой с исключением [`CalledProcessError`](https://python-all.ru/3.3/library/subprocess.html#subprocess.CalledProcessError), если запрошенная операция вернёт ненулевой код возврата. Вывод по-прежнему доступен как атрибут [`output`](https://python-all.ru/3.3/library/subprocess.html#subprocess.CalledProcessError.output) возбуждённого исключения.

В следующих примерах предполагается, что соответствующие функции уже импортированы из модуля [`подпроцесс`](https://python-all.ru/3.3/library/subprocess.html#module-subprocess).

### 17.5.4.1. Замена обратной кавычки оболочки /bin/sh

```python
output=`mycmd myarg`
# becomes
output = check_output(["mycmd", "myarg"])
```

### 17.5.4.2. Замена конвейера оболочки

```python
output=`dmesg | grep hda`
# becomes
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.

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

```python
output=`dmesg | grep hda`
# becomes
output=check_output("dmesg | grep hda", shell=True)
```

### 17.5.4.3. Замена [`os.system()`](https://python-all.ru/3.3/library/os.html#os.system)

```python
sts = os.system("mycmd" + " myarg")
# становится
sts = call("mycmd" + " myarg", shell=True)
```

Примечания:

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

Более реалистичный пример выглядит так:

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

### 17.5.4.4. Замена семейства [`os.spawn`](https://python-all.ru/3.3/library/os.html#os.spawnl)

Пример P\_NOWAIT:

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

Пример P\_WAIT:

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

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

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

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

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

### 17.5.4.5. Замена [`os.popen()`](https://python-all.ru/3.3/library/os.html#os.popen), `os.popen2()`, `os.popen3()`

```python
(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)
```

```python
(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)
```

```python
(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)
```

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

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

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

> **Примечание**
>
> Если аргумент cmd функций popen2 является строкой, команда выполняется через /bin/sh. Если это список, команда выполняется напрямую.

```python
(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)
```

```python
(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`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen), за исключением того, что:

- [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen) возбуждает исключение, если выполнение завершается неудачей.
- аргумент *capturestderr* заменён аргументом *stderr*.
- Необходимо указать `stdin=PIPE` и `stdout=PIPE`.
- popen2 по умолчанию закрывает все файловые дескрипторы, но для гарантии такого поведения на всех платформах или в старых версиях Python необходимо указать `close_fds=True` вместе с [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen).

## 17.5.5. Устаревшие функции вызова оболочки

Этот модуль также предоставляет следующие устаревшие функции из модуля `commands` версии 2.x. Эти операции неявно вызывают системную оболочку, и ни одно из описанных выше гарантий безопасности и согласованности обработки исключений для этих функций не действует.

#### `subprocess.getstatusoutput(cmd)`

Возвращает `(status, output)` выполнения *cmd* в оболочке.

Выполняет строку *cmd* в оболочке с помощью [`Popen`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen) и возвращает кортеж из двух элементов `(status, output)` через [`Popen.communicate()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.Popen.communicate). Используется режим универсальных новых строк; подробнее см. в примечаниях к [*Часто используемые аргументы*](https://python-all.ru/3.3/library/subprocess.html#frequently-used-arguments).

Завершающий символ новой строки удаляется из вывода. Код возврата команды можно интерпретировать по правилам для C-функции `wait()`. Пример:

```python
>>> subprocess.getstatusoutput('ls /bin/ls')
(0, '/bin/ls')
>>> subprocess.getstatusoutput('cat /bin/junk')
(256, 'cat: /bin/junk: No such file or directory')
>>> subprocess.getstatusoutput('/bin/junk')
(256, 'sh: /bin/junk: not found')
```

Доступность: Unix и Windows

Изменено в версии 3.3.4: Добавлена поддержка Windows

#### `subprocess.getoutput(cmd)`

Возвращает вывод (stdout и stderr) выполнения *cmd* в оболочке.

Аналогично [`getstatusoutput()`](https://python-all.ru/3.3/library/subprocess.html#subprocess.getstatusoutput), за исключением того, что код возврата игнорируется, а возвращаемое значение – строка, содержащая вывод команды. Пример:

```python
>>> subprocess.getoutput('ls /bin/ls')
'/bin/ls'
```

Доступность: Unix и Windows

Изменено в версии 3.3.4: Добавлена поддержка Windows

## 17.5.6. Примечания

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

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

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

> **См. также**
>
> **[`shlex`](https://python-all.ru/3.3/library/shlex.html#module-shlex)**
>
> Модуль, предоставляющий функцию для разбора и экранирования командных строк.