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

---

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

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

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

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

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

> **См. также**
>
> Пользователям POSIX (Linux, BSD и т.д.) настоятельно рекомендуется установить и использовать гораздо более новый модуль [subprocess32](https://python-all.ru/2.7/library/subprocess.html) вместо версии, входящей в состав Python 2.7. Это прямая замена, которая во многих ситуациях ведёт себя лучше.
>
> [**PEP 324**](https://python-all.ru/2.7/library/subprocess.html) – PEP, предлагающий модуль подпроцесса

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

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

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

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

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

Примеры:

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

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

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

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

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

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

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

Примеры:

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

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

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

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

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

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

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

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

Примеры:

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

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

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

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

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

#### `subprocess.PIPE`

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

#### `subprocess.STDOUT`

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

#### `exception subprocess.CalledProcessError`

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

#### `returncode`

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

#### `cmd`

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

#### `output`

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

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

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

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

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

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

Создание и управление базовыми процессами в этом модуле осуществляется классом [`Popen`](https://python-all.ru/2.7/library/subprocess.html#subprocess.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()`](https://python-all.ru/2.7/library/os.html#os.execvp), для выполнения дочерней программы. В Windows класс использует функцию Windows `CreateProcess()`. Аргументы [`Popen`](https://python-all.ru/2.7/library/subprocess.html#subprocess.Popen) описаны ниже.

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

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

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

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

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

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

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

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

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

*stdin*, *stdout* и *stderr* задают дескрипторы файлов стандартного ввода, стандартного вывода и стандартного вывода ошибок выполняемой программы соответственно. Допустимые значения: [`PIPE`](https://python-all.ru/2.7/library/subprocess.html#subprocess.PIPE), существующий файловый дескриптор (положительное целое число), существующий файловый объект и `None`. [`PIPE`](https://python-all.ru/2.7/library/subprocess.html#subprocess.PIPE) указывает, что должен быть создан новый канал к дочернему процессу. При настройках по умолчанию `None` перенаправление не происходит; дескрипторы файлов дочернего процесса наследуются от родительского. Кроме того, *stderr* может быть [`STDOUT`](https://python-all.ru/2.7/library/subprocess.html#subprocess.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`, он должен быть отображением (mapping), определяющим переменные окружения для нового процесса; они используются вместо наследования окружения текущего процесса, что является поведением по умолчанию.

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

Если *universal\_newlines* равен `True`, файловые объекты *stdout* и *stderr* открываются как текстовые файлы в режиме [универсальных новых строк](https://python-all.ru/2.7/glossary.html#term-universal-newlines). Строки могут завершаться любым из `'\n'` (соглашение Unix о конце строки), `'\r'` (соглашение старого Macintosh) или `'\r\n'` (соглашение Windows). Все эти внешние представления интерпретируются программой Python как `'\n'`.

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

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

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

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

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

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

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

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

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

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

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

#### `Popen.poll()`

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

#### `Popen.wait()`

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

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

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

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

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

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

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

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

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

> **Примечание**
>
> В Windows SIGTERM является псевдонимом для [`terminate()`](https://python-all.ru/2.7/library/subprocess.html#subprocess.Popen.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()`](https://python-all.ru/2.7/library/subprocess.html#subprocess.Popen.kill) является псевдонимом для [`terminate()`](https://python-all.ru/2.7/library/subprocess.html#subprocess.Popen.terminate).

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

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

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

#### `Popen.stdin`

Если аргумент *stdin* был равен [`PIPE`](https://python-all.ru/2.7/library/subprocess.html#subprocess.PIPE), этот атрибут является файловым объектом, который предоставляет ввод дочернему процессу. В противном случае он равен `None`.

#### `Popen.stdout`

Если аргумент *stdout* был равен [`PIPE`](https://python-all.ru/2.7/library/subprocess.html#subprocess.PIPE), этот атрибут является файловым объектом, который предоставляет вывод дочернего процесса. В противном случае он равен `None`.

#### `Popen.stderr`

Если аргумент *stderr* был равен [`PIPE`](https://python-all.ru/2.7/library/subprocess.html#subprocess.PIPE), этот атрибут является файловым объектом, который предоставляет вывод ошибок дочернего процесса. В противном случае он равен `None`.

#### `Popen.pid`

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

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

#### `Popen.returncode`

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

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

## 17.1.3. Вспомогательные функции Popen для Windows

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

#### `class subprocess.STARTUPINFO`

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

#### `dwFlags`

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

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

#### `hStdInput`

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

#### `hStdOutput`

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

#### `hStdError`

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

#### `wShowWindow`

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

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

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

Модуль [`subprocess`](https://python-all.ru/2.7/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/2.7/library/subprocess.html#subprocess.STARTUPINFO.hStdInput), [`STARTUPINFO.hStdOutput`](https://python-all.ru/2.7/library/subprocess.html#subprocess.STARTUPINFO.hStdOutput) и [`STARTUPINFO.hStdError`](https://python-all.ru/2.7/library/subprocess.html#subprocess.STARTUPINFO.hStdError) содержат дополнительную информацию.

#### `subprocess.STARTF_USESHOWWINDOW`

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

#### `subprocess.CREATE_NEW_CONSOLE`

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

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

#### `subprocess.CREATE_NEW_PROCESS_GROUP`

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

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

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

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

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

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

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

```bash
output=`mycmd myarg`
```

становится:

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

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

```bash
output=`dmesg | grep hda`
```

становится:

```python
p1 = Popen(["dmesg"], stdout=PIPE)
p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
p1.stdout.close()  # Разрешить p1 получать SIGPIPE, если p2 завершается.
output = p2.communicate()[0]
```

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

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

```bash
output=`dmesg | grep hda`
```

становится:

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

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

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

Примечания:

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

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

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

### 17.1.4.4. Замена семейства [`os.spawn`](https://python-all.ru/2.7/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.1.4.5. Замена [`os.popen()`](https://python-all.ru/2.7/library/os.html#os.popen), [`os.popen2()`](https://python-all.ru/2.7/library/os.html#os.popen2), [`os.popen3()`](https://python-all.ru/2.7/library/os.html#os.popen3)

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

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

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

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

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

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

```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", shell=True, stdin=PIPE)
...
process.stdin.close()
if process.wait() != 0:
    print "There were some errors"
```

### 17.1.4.6. Замена функций из модуля [`popen2`](https://python-all.ru/2.7/library/popen2.html#module-popen2)

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

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

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

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

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

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

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

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