Вызов внешней команды в Python

Простой, используйте subprocess.run, который возвращает объект CompletedProcess:

>>> import subprocess
>>> completed_process = subprocess.run('python --version')
Python 3.6.1 :: Anaconda 4.4.0 (64-bit)
>>> completed_process
CompletedProcess(args='python --version', returncode=0)

Почему?

Начиная с Python 3.5, в документации рекомендуется subprocess.run :

. Рекомендуемым подходом к вызову подпроцессов является использование функции run () для всех случаев использования, которые он может обрабатывать.

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

>>> import subprocess
>>> completed_process = subprocess.run('python --version')
Python 3.6.1 :: Anaconda 4.4.0 (64-bit)
>>> completed_process
CompletedProcess(args='python --version', returncode=0)

run ждет завершения команды, а затем возвращает объект CompletedProcess. Он может вместо этого поднимать TimeoutExpired (если вы дадите ему аргумент timeout=) или CalledProcessError (если он терпит неудачу и вы пройдете check=True).

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

Мы можем проверить возвращаемый объект и увидеть команду, которая была указана, и код возврата:

>>> completed_process.args
'python --version'
>>> completed_process.returncode
0

Захват output

Если вы хотите захватить вывод, вы можете передать subprocess.PIPE в соответствующие stderr или stdout:

>>> cp = subprocess.run('python --version', 
                        stderr=subprocess.PIPE, 
                        stdout=subprocess.PIPE)
>>> cp.stderr
b'Python 3.6.1 :: Anaconda 4.4.0 (64-bit)\r\n'
>>> cp.stdout
b''

(я нахожу это интересным и слегка что информация о версии попадает в stderr вместо stdout.)

Передача списка команд

Можно легко перейти от ручного предоставления командной строки (например, вопрос) к предоставлению строка построена программно. Не стройте строки программно. Это потенциальная проблема безопасности. Лучше предположить, что вы не доверяете входным данным.

>>> import textwrap
>>> args = ['python', textwrap.__file__]
>>> cp = subprocess.run(args, stdout=subprocess.PIPE)
>>> cp.stdout
b'Hello there.\r\n  This is indented.\r\n'

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

Полная подпись

Вот фактическая сигнатура в источнике и как показано на рисунке help(run):

def run(*popenargs, input=None, timeout=None, check=False, **kwargs):

popenargs и kwargs присваиваются конструктору Popen. input может быть строкой байтов (или unicode, если указать кодировку или universal_newlines=True), которые будут переданы по каналу в stdin подпроцесса.

Документация описывает timeout= и check=True лучше, чем I can:

Аргумент timeout передается Popen.communicate (). Если истечет время ожидания, дочерний процесс будет убит и будет ждать. Исключение TimeoutExpired будет повторно поднято после завершения дочернего процесса.

Если проверка верна, и процесс завершается с ненулевым кодом выхода, будет вызвано исключение CalledProcessError. Атрибуты этого исключения содержат аргументы, код выхода и stdout и stderr, если они были захвачены.

, и этот пример для check=True лучше, чем один, который я мог бы придумать:

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

Расширенная подпись

Вот расширенная подпись, указанная в документации:

subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, 
shell=False, cwd=None, timeout=None, check=False, encoding=None, 
errors=None)

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

Popen

При использовании Popen вместо этого? Я бы изо всех сил пытался найти прецедент, основанный только на аргументах. Однако прямое использование Popen даст вам доступ к его методам, включая poll, «send_signal», «terminate» и «wait».

Вот подпись Popen, как указано в источнике . Я думаю, что это наиболее точное инкапсулирование информации (в отличие от help(Popen)):

def __init__(self, args, bufsize=-1, executable=None,
             stdin=None, stdout=None, stderr=None,
             preexec_fn=None, close_fds=_PLATFORM_DEFAULT_CLOSE_FDS,
             shell=False, cwd=None, env=None, universal_newlines=False,
             startupinfo=None, creationflags=0,
             restore_signals=True, start_new_session=False,
             pass_fds=(), *, encoding=None, errors=None):

Но более информативным является документация Popen :

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=(), *, encoding=None, errors=None)

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

Понимание оставшейся документации в Popen будет оставлено как упражнение для читателя.

subprocess.check_call удобно, если вы не хотите проверять возвращаемые значения. Он генерирует исключение при любой ошибке.

Я бы рекомендовал использовать модуль подпроцесса вместо os.system, потому что для него выполняется экранирование оболочки и, следовательно, гораздо безопаснее: http://docs.python.org/library/subprocess.html

subprocess.call(['ping', 'localhost'])

Обновление:

subprocess.run является рекомендуемым подходом к Python 3.5 , если вашему коду не требуется поддерживать совместимость с более ранними версиями Python. Это более последовательно и предлагает аналогичную простоту использования в качестве посланника. (Трубопровод не так прост. См. этот вопрос, как .)

Вот несколько примеров из документов .

Запустите процесс:

>>> subprocess.run(["ls", "-l"])  # doesn't capture output
CompletedProcess(args=['ls', '-l'], returncode=0)

Поднять при неудачном прогоне:

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

Выход захвата:

>>> subprocess.run(["ls", "-l", "/dev/null"], stdout=subprocess.PIPE)
CompletedProcess(args=['ls', '-l', '/dev/null'], returncode=0,
stdout=b'crw-rw-rw- 1 root root 1, 3 Jan 23 16:23 /dev/null\n')

Оригинальный ответ:

Я рекомендую попробовать Envoy . Это оболочка для подпроцесса, которая, в свою очередь, стремится заменить более старые модули и функции. Посланник является подпроцессом для людей.

Пример использования из readme :

>>> r = envoy.run('git config', data='data to pipe in', timeout=2)

>>> r.status_code
129
>>> r.std_out
'usage: git config [options]'
>>> r.std_err
''

Материал трубы тоже:

>>> r = envoy.run('uptime | pbcopy')

>>> r.command
'pbcopy'
>>> r.status_code
0

>>> r.history
[<Response 'uptime'>]

Я склонен использовать подпроцесс вместе с shlex (для обработки экранирования цитируемых строк):

>>> import subprocess, shlex
>>> command = 'ls -l "/your/path/with spaces/"'
>>> call_params = shlex.split(command)
>>> print call_params
["ls", "-l", "/your/path/with spaces/"]
>>> subprocess.call(call_params)

Я всегда использую fabric для таких вещей, как:

from fabric.operations import local
result = local('ls', capture=True)
print "Content:/n%s" % (result, )

Но это кажется хорошим инструментом: sh (интерфейс подпроцесса Python) .

Посмотрите пример:

from sh import vgdisplay
print vgdisplay()
print vgdisplay('-v')
print vgdisplay(v=True)

С помощью стандартной библиотеки

Используйте модуль подпроцесса :

from subprocess import call
call(['ls', '-l'])

Это рекомендуемый стандартный способ. Однако более сложные задачи (трубы, выходные данные, вход и т. Д.) Могут быть утомительными для построения и записи.

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

import shlex
from subprocess import call
call(shlex.split('ls -l'))

С внешним Зависимости

Если вы не против внешних зависимостей, используйте plumbum :

from plumbum.cmd import ifconfig
print(ifconfig['wlan0']())

Это лучшая обертка subprocess. Это кросс-платформенный, т. Е. Он работает как в Windows, так и в Unix-подобных системах. Установите pip install plumbum.

Еще одна популярная библиотека - sh :

from sh import ifconfig
print(ifconfig('wlan0'))

Однако sh отказалась от поддержки Windows, поэтому она не такая потрясающая как это было раньше. Установите pip install sh.

Бесстыдный плагин, я написал для этого библиотеку: P https://github.com/houqp/shell.py

Это в основном оболочка для popen и shlex для Теперь. Он также поддерживает команды конвейеров, чтобы упростить цепочку команд в Python. Таким образом, вы можете делать такие вещи, как:

ex('echo hello shell.py') | "awk '{print $2}'"

Чтобы получить идентификатор сети из нейтрона openstack:

#!/usr/bin/python
import os
netid= "nova net-list | awk '/ External / { print $2 }'"
temp=os.popen(netid).read()  /* here temp also contains new line (\n) */
networkId=temp.rstrip()
print(networkId)

Выход nova net-list

+--------------------------------------+------------+------+
| ID                                   | Label      | CIDR |
+--------------------------------------+------------+------+
| 431c9014-5b5d-4b51-a357-66020ffbb123 | test1      | None |
| 27a74fcd-37c0-4789-9414-9531b7e3f126 | External   | None |
| 5a2712e9-70dc-4b0e-9281-17e02f4684c9 | management | None |
| 7aa697f5-0e60-4c15-b4cc-9cb659698512 | Internal   | None |
+--------------------------------------+------------+------+

Вывод печати (networkId)

27a74fcd-37c0-4789-9414-9531b7e3f126

os.system в порядке, но как-то датировано. Это также не очень безопасно. Вместо этого попробуйте subprocess. subprocess не вызывает sh напрямую и поэтому более безопасен, чем os.system.

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