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

---

# 17.1. `subprocess` – Управление подпроцессами

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

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

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

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

## 17.1.1. Использование модуля подпроцесс

Этот модуль определяет один класс с именем [`Popen`](https://python-all.ru/3.1/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)`

Аргументы:

*args* должен быть строкой или последовательностью аргументов программы. Выполняемая программа обычно является первым элементом последовательности args или самой строкой, если передана строка, но может быть явно задана с помощью аргумента *executable*. Когда указан *executable*, первый элемент последовательности args по-прежнему воспринимается большинством программ как имя команды, которое может отличаться от реального имени исполняемого файла. В Unix он становится отображаемым именем выполняемой программы в таких утилитах, как **ps**.

В Unix с *shell=False* (по умолчанию): в этом случае класс Popen использует [`os.execvp()`](https://python-all.ru/3.1/library/os.html#os.execvp) для выполнения дочерней программы. *args* обычно должен быть последовательностью. Если для *args* указана строка, она будет использоваться как имя или путь к выполняемой программе; это сработает только если программе не передаются аргументы.

> **Примечание**
>
> [`shlex.split()`](https://python-all.ru/3.1/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*, показанная выше), являются отдельными элементами списка.

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

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

> **Предупреждение**
>
> Выполнение команд оболочки, содержащих непроверенные входные данные из ненадёжного источника, делает программу уязвимой для [внедрения команд оболочки](https://python-all.ru/3.1/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=False*.

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

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

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

Аргумент *executable* задаёт программу для выполнения. Он требуется очень редко: обычно выполняемая программа определяется аргументом *args*. Если `shell=True`, аргумент *executable* указывает, какую оболочку использовать. В Unix оболочкой по умолчанию является `/bin/sh`. В Windows оболочка по умолчанию задаётся переменной окружения **COMSPEC**. Единственная причина, по которой может потребоваться указать `shell=True` в Windows – это если команда, которую требуется выполнить, встроена в оболочку, например `dir`, `copy`. Для запуска пакетного файла или консольного исполняемого файла `shell=True` не требуется.

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

Если *shell* равен [`True`](https://python-all.ru/3.1/library/constants.html#True), указанная команда будет выполняться через оболочку.

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

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

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

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

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

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

#### `subprocess.PIPE`

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

*stdin*

,

*stdout*

или

*stderr*

для

[`Popen`](https://python-all.ru/3.1/library/subprocess.html#subprocess.Popen)

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

#### `subprocess.STDOUT`

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

*stderr*

для

[`Popen`](https://python-all.ru/3.1/library/subprocess.html#subprocess.Popen)

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

### 17.1.1.1. Вспомогательные функции

Этот модуль также определяет следующие сокращённые функции:

#### `subprocess.call(*popenargs, **kwargs)`

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

Аргументы такие же, как у конструктора Popen. Пример:

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

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

#### `subprocess.check_call(*popenargs, **kwargs)`

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

Аргументы такие же, как у конструктора Popen. Пример:

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

> **Предупреждение**
>
> См. предупреждение для [`call()`](https://python-all.ru/3.1/library/subprocess.html#subprocess.call).

#### `subprocess.check_output(*popenargs, **kwargs)`

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

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

Аргументы такие же, как у конструктора [`Popen`](https://python-all.ru/3.1/library/subprocess.html#subprocess.Popen). Пример:

```python
>>> subprocess.check_output(["ls", "-l", "/dev/null"])
b'crw-rw-rw- 1 root root 1, 3 Oct 18  2007 /dev/null\n'
```

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

```python
>>> subprocess.check_output(
...     ["/bin/sh", "-c", "ls non_existent_file; exit 0"],
...     stderr=subprocess.STDOUT)
b'ls: non_existent_file: No such file or directory\n'
```

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

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

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

Выполняет строку *cmd* в оболочке с помощью `os.popen()` и возвращает кортеж из двух элементов `(status, output)`. Строка *cmd* на самом деле выполняется как `{ cmd ; } 2>&1`, поэтому возвращаемый вывод содержит сообщения стандартного вывода и ошибок. Завершающий символ новой строки удаляется из вывода. Код завершения команды можно интерпретировать согласно правилам для 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.

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

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

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

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

Доступность: UNIX.

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

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

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

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

check\_call() возбуждает `CalledProcessError`, если вызванный процесс возвращает ненулевой код возврата.

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

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

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

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

#### `Popen.poll()`

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

[`returncode`](https://python-all.ru/3.1/library/subprocess.html#subprocess.Popen.returncode)

.

#### `Popen.wait()`

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

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

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

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

[`communicate()`](https://python-all.ru/3.1/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/3.1/library/subprocess.html#subprocess.Popen.terminate).

#### `Popen.terminate()`

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

`TerminateProcess()`

.

#### `Popen.kill()`

Завершает дочерний процесс. В ОС POSIX функция отправляет дочернему процессу сигнал SIGKILL. В Windows

[`kill()`](https://python-all.ru/3.1/library/subprocess.html#subprocess.Popen.kill)

– это псевдоним для

[`terminate()`](https://python-all.ru/3.1/library/subprocess.html#subprocess.Popen.terminate)

.

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

> **Предупреждение**
>
> Используйте `communicate()`, а не `.stdin.write`, `.stdout.read` или `.stderr.read`, чтобы избежать взаимных блокировок из-за переполнения буферов каналов ОС и блокировки дочернего процесса.

#### `Popen.stdin`

Если аргумент

*stdin*

был равен

[`PIPE`](https://python-all.ru/3.1/library/subprocess.html#subprocess.PIPE)

, то этот атрибут представляет собой

[*файловый объект*](https://python-all.ru/3.1/glossary.html#term-file-object)

, который передаёт входные данные дочернему процессу. В противном случае он равен

`None`

.

#### `Popen.stdout`

Если аргумент

*stdout*

был равен

[`PIPE`](https://python-all.ru/3.1/library/subprocess.html#subprocess.PIPE)

, то этот атрибут представляет собой

[*файловый объект*](https://python-all.ru/3.1/glossary.html#term-file-object)

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

`None`

.

#### `Popen.stderr`

Если аргумент

*stderr*

был равен

[`PIPE`](https://python-all.ru/3.1/library/subprocess.html#subprocess.PIPE)

, то этот атрибут представляет собой

[*файловый объект*](https://python-all.ru/3.1/glossary.html#term-file-object)

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

`None`

.

#### `Popen.pid`

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

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

#### `Popen.returncode`

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

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

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

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

#### `class subprocess.STARTUPINFO`

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

#### `dwFlags`

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

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

#### `hStdInput`

Если

[`dwFlags`](https://python-all.ru/3.1/library/subprocess.html#subprocess.STARTUPINFO.dwFlags)

указывает

[`STARTF_USESTDHANDLES`](https://python-all.ru/3.1/library/subprocess.html#subprocess.STARTF_USESTDHANDLES)

, этот член является дескриптором стандартного ввода для процесса. Если

[`STARTF_USESTDHANDLES`](https://python-all.ru/3.1/library/subprocess.html#subprocess.STARTF_USESTDHANDLES)

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

#### `hStdOutput`

Если

[`dwFlags`](https://python-all.ru/3.1/library/subprocess.html#subprocess.STARTUPINFO.dwFlags)

указывает

[`STARTF_USESTDHANDLES`](https://python-all.ru/3.1/library/subprocess.html#subprocess.STARTF_USESTDHANDLES)

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

#### `hStdError`

Если

[`dwFlags`](https://python-all.ru/3.1/library/subprocess.html#subprocess.STARTUPINFO.dwFlags)

указывает

[`STARTF_USESTDHANDLES`](https://python-all.ru/3.1/library/subprocess.html#subprocess.STARTF_USESTDHANDLES)

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

#### `wShowWindow`

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

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

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

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

#### `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.1/library/subprocess.html#subprocess.STARTUPINFO.hStdInput)

,

[`STARTUPINFO.hStdOutput`](https://python-all.ru/3.1/library/subprocess.html#subprocess.STARTUPINFO.hStdOutput)

и

[`STARTUPINFO.hStdError`](https://python-all.ru/3.1/library/subprocess.html#subprocess.STARTUPINFO.hStdError)

содержат дополнительную информацию.

#### `subprocess.STARTF_USESHOWWINDOW`

Указывает, что член

[`STARTUPINFO.wShowWindow`](https://python-all.ru/3.1/library/subprocess.html#subprocess.STARTUPINFO.wShowWindow)

содержит дополнительную информацию.

#### `subprocess.CREATE_NEW_CONSOLE`

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

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

## 17.1.4. Замена старых функций модулем подпроцесс

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

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

В следующих примерах предполагается, что модуль подпроцесс импортирован с помощью «from subprocess import \*».

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

```python
output=`mycmd myarg`
==>
output = Popen(["mycmd", "myarg"], stdout=PIPE).communicate()[0]
```

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

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

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

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

```python
sts = os.system("mycmd" + " myarg")
==>
p = Popen("mycmd" + " myarg", shell=True)
sts = os.waitpid(p.pid, 0)[1]
```

Примечания:

- Вызов программы через оболочку обычно не требуется.
- Проще смотреть на атрибут `returncode`, чем на код завершения.

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

```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.1.4.4. Замена семейства [`os.spawn`](https://python-all.ru/3.1/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()`, `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.1.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.1/library/subprocess.html#subprocess.Popen), за исключением того, что:

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

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

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

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

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