Не уверен, что это все еще актуально, но такое же поведение имеет место и для словарей. Посмотрите на этот пример.
a = {'par' : [1,21,3], 'sar' : [5,6,8]}
b = a
c = a.copy()
a['har'] = [1,2,3]
a
Out[14]: {'har': [1, 2, 3], 'par': [1, 21, 3], 'sar': [5, 6, 8]}
b
Out[15]: {'har': [1, 2, 3], 'par': [1, 21, 3], 'sar': [5, 6, 8]}
c
Out[16]: {'par': [1, 21, 3], 'sar': [5, 6, 8]}
Вы можете использовать Popen, а затем вы можете проверить статус процедуры:
from subprocess import Popen
proc = Popen(['ls', '-l'])
if proc.poll() is None:
proc.kill()
Проверить subprocess.Popen .
Здесь есть другая разница, которая не упоминается ранее.
subprocess.Popen
выполняет команду & lt; command> как подпроцесс. В моем случае мне нужно выполнить файл & lt; a>, который должен связываться с другой программой, & lt; b>.
Я попробовал подпроцесс, и выполнение было успешным. Однако & lt; b> не удалось установить связь с & lt; a>. Все нормально, когда я запускаю оба из терминала.
Еще одно: (ПРИМЕЧАНИЕ: kwrite ведет себя отличным от других приложений. Если вы попробуете ниже с Firefox, результаты будут не такими.)
Если вы попытаетесь os.system("kwrite")
, поток программы зависает, пока пользователь не закроет kwrite. Чтобы преодолеть это, я попытался вместо этого os.system(konsole -e kwrite)
. Эта программа продолжилась, но kwrite стал подпроцессом консоли.
Кто-нибудь запускает kwrite, не являющийся подпроцессом (то есть в системном мониторе он должен появляться на крайнем левом краю дерева).
echo $PATH
с помощью call(["echo", "$PATH"])
, но он просто повторил буквенную строку $PATH
вместо любой подстановки. Я знаю, что могу получить переменную среды PATH, но мне интересно, есть ли простой способ заставить команду вести себя так, как если бы я выполнил ее в bash.
– Kevin Wheeler
1 September 2015 в 23:17
shell=True
для этого.
– SethMMorton
2 September 2015 в 20:38
shell=True
, для этого Python поставляется с os.path.expandvars . В вашем случае вы можете написать: os.path.expandvars("$PATH")
. @SethMMorton, пожалуйста, пересмотреть свой комментарий - & gt; Почему бы не использовать shell = True
– Murmel
11 November 2015 в 21:24
subprocess.run
вместо subprocess.call
. docs.python.org/3/library/subprocess.html
– Hannes Karppila
4 July 2016 в 19:31
ls -l
, но не дает доступа к его выводу (stdout
недоступен). Я нахожу это запутанным - вместо этого вы можете использовать команду без stdout, например touch
.
– florisla
12 July 2017 в 10:02
check_output
требуется список, а не строка. Если вы не полагаетесь на цитируемые пробелы, чтобы сделать ваш звонок действительным, самым простым и удобным для чтения способом является subprocess.check_output("ls -l /dev/null".split())
.
– Bruno Bronosky
30 January 2018 в 19:18
Вызов внешней команды в 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
.
Получить дополнительную информацию здесь .
.readlines()
считывает строки all i> сразу, т. е. блокирует до выхода подпроцесса (закрывает его конец). Чтобы читать в режиме реального времени (если нет проблем с буферизацией), вы можете: for line in iter(p.stdout.readline, ''): print line,
– jfs
16 November 2012 в 16:12
p.stdout.readline()
(примечание: no s
в конце) не будет видеть никаких данных, пока ребенок не заполнит свой буфер. Если ребенок не производит много данных, тогда выход не будет в режиме реального времени. См. Вторую причину в Q: Почему бы просто не использовать трубу (popen ())? . В этом ответе приведены некоторые обходные пути (pexpect, pty, stdbuf)
– jfs
17 November 2012 в 15:51
https://docs.python.org/2/library/subprocess.html
... или для очень простой команды:
import os
os.system('cat testfile')
os.system
не позволяет сохранять результаты, поэтому, если вы хотите сохранить результаты в каком-то списке или что-то работает subprocess.call
.
Мне очень нравится shell_command за его простоту. Он построен поверх модуля подпроцесса.
Вот пример из документов:
>>> from shell_command import shell_call
>>> shell_call("ls *.py")
setup.py shell_command.py test_shell_command.py
0
>>> shell_call("ls -l *.py")
-rw-r--r-- 1 ncoghlan ncoghlan 391 2011-12-11 12:07 setup.py
-rw-r--r-- 1 ncoghlan ncoghlan 7855 2011-12-11 16:16 shell_command.py
-rwxr-xr-x 1 ncoghlan ncoghlan 8463 2011-12-11 16:17 test_shell_command.py
0
import os
cmd = 'ls -al'
os.system(cmd)
Если вы хотите вернуть результаты команды, вы можете использовать os.popen
. Однако это не рекомендуется с версии 2.6 в пользу модуля подпроцесса , который хорошо освещает другие ответы.
Некоторые подсказки по отсоединению дочернего процесса от вызывающего (начало дочернего процесса в фоновом режиме).
Предположим, вы хотите запустить длинную задачу из CGI-скрипта, то есть дочерний процесс должен живут дольше, чем процесс выполнения CGI-скрипта.
Классический пример из документов модуля подпроцесса:
import subprocess
import sys
# some code here
pid = subprocess.Popen([sys.executable, "longtask.py"]) # call subprocess
# some more code here
Идея здесь заключается в том, что вы не хотите ждать в line 'call subprocess', пока не будет закончен longtask.py. Но неясно, что происходит после строки «еще один код здесь» из примера.
Моя целевая платформа была бесплатной, но разработка была на окнах, поэтому я столкнулся с проблемой сначала в Windows
В окнах (win xp) родительский процесс не завершится, пока longtask.py не завершит свою работу. Это не то, что вы хотите в CGI-скрипте. Проблема не специфична для Python, в сообществе PHP проблемы одинаковы.
Решение состоит в передаче DETACHED_PROCESS Флаг создания процесса в базовую функцию CreateProcess в win API. Если вы установили pywin32, вы можете импортировать флаг из модуля win32process, иначе вы должны определить его самостоятельно:
DETACHED_PROCESS = 0x00000008
pid = subprocess.Popen([sys.executable, "longtask.py"],
creationflags=DETACHED_PROCESS).pid
/ * UPD 2015.10.27 @eryksun in комментарий ниже отмечает, что семантически правильный флаг CREATE_NEW_CONSOLE (0x00000010) * /
В freebsd у нас есть другая проблема: когда родительский процесс завершен, он также завершает дочерние процессы. И это не то, что вы хотите в CGI-скрипте. Некоторые эксперименты показали, что проблема, по-видимому, заключается в совместном использовании sys.stdout. И рабочим решением было следующее:
pid = subprocess.Popen([sys.executable, "longtask.py"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
Я не проверял код на других платформах и не знаю причин поведения на freebsd. Если кто-нибудь знает, пожалуйста, поделитесь своими идеями. Googling при запуске фоновых процессов в Python еще не проливает свет.
DETACHED_PROCESS
в creationflags
позволяет избежать этого, не позволяя ребенку наследовать или создавать консоль. Если вы хотите использовать новую консоль, используйте CREATE_NEW_CONSOLE
(0x00000010).
– eryksun
27 October 2015 в 01:27
os.devnull
, потому что в некоторых консольных программах с ошибкой выйдет ошибка. Создайте новую консоль, если вы хотите, чтобы дочерний процесс взаимодействовал с пользователем одновременно с родительским процессом. Было бы странно пытаться сделать это как в одном окне.
– eryksun
27 October 2015 в 18:37
Это может быть так просто:
import os
cmd = "your command"
os.system(cmd)
Существует также Plumbum
>>> from plumbum import local
>>> ls = local["ls"]
>>> ls
LocalCommand(<LocalPath /bin/ls>)
>>> ls()
u'build.py\ndist\ndocs\nLICENSE\nplumbum\nREADME.rst\nsetup.py\ntests\ntodo.txt\n'
>>> notepad = local["c:\\windows\\notepad.exe"]
>>> notepad() # Notepad window pops up
u'' # Notepad window is closed by user, command returns
Вот краткое описание способов вызова внешних программ и преимуществ и недостатков каждого из них:
os.system("some_command with args")
передает команду и аргументы в оболочку вашей системы. Это хорошо, потому что вы можете запускать сразу несколько команд таким образом и настраивать каналы и перенаправление ввода / вывода. Например: os.system("some_command < input_file | another_command > output_file")
Однако, хотя это удобно, вы должны вручную обрабатывать экранирование символов оболочки, таких как пробелы и т. Д. С другой стороны, это также позволяет запускать команды, которые являются просто командами оболочки, а не фактически внешними программами , См. документацию . stream = os.popen("some_command with args")
будет делать то же самое, что и os.system
, за исключением того, что он дает файл-подобный объект, который вы можете использовать для доступа к стандартному вводу / выводу для этого процесса. Есть еще 3 варианта popen, которые все обрабатывают i / o немного по-другому. Если вы передаете все как строку, ваша команда передается в оболочку; если вы передадите их в список, то вам не нужно беспокоиться о том, чтобы избежать чего-либо. См. документацию . Popen
модуля subprocess
. Это предназначено для замены os.popen
, но имеет недостаток в том, что он немного усложняется благодаря тому, что он настолько всеобъемлющий. Например, вы могли бы сказать: print subprocess.Popen("echo Hello World", shell=True, stdout=subprocess.PIPE).stdout.read()
вместо: print os.popen("echo Hello World").read()
, но хорошо иметь все варианты там в одном унифицированном классе вместо 4 различных функций popen. См. документацию . call
из модуля subprocess
. Это в основном так же, как класс Popen
, и принимает все те же аргументы, но он просто ждет, пока команда не завершится, и вы получите код возврата. Например: return_code = subprocess.call("echo Hello World", shell=True)
См. документацию . subprocess.run
, что очень похоже на выше, но еще более гибкое и возвращает объект CompletedProcess
, когда команда завершает выполнение. Возможно, модуль subprocess
- это то, что вы используете.
Наконец, имейте в виду, что для всех методов, в которых вы передаете окончательную команду для выполнения оболочкой в виде строки, и вы несете ответственность за ее выход из нее. Имеются серьезные последствия для безопасности, если какая-либо часть передаваемой строки не может быть полностью доверена. Например, если пользователь вводит какую-либо / любую часть строки. Если вы не уверены, используйте эти методы только с константами. Чтобы дать вам намек на последствия, рассмотрите этот код:
print subprocess.Popen("echo %s " % user_input, stdout=PIPE).stdout.read()
и представьте, что пользователь вводит «моя мама не любила меня & amp; & amp; rm -rf /".
open
.
– Jean
26 May 2015 в 21:16
subprocess.run()
. docs.python.org/3.5/library/subprocess.html#subprocess.run
– phoenix
7 October 2015 в 16:37
subprocess.run(..)
, что именно делает & quot; Это не фиксирует stdout или stderr по умолчанию. & Quot; i> подразумевает? Как насчет subprocess.check_output(..)
и STDERR?
– Evgeni Sergeev
1 June 2016 в 10:44
for
, как это сделать, не блокируя мой скрипт python? Я не забочусь о выходе команды, я просто хочу запустить много из них.
– Charlie Parker
24 October 2017 в 19:08
Вот как я запускаю свои команды. У этого кода есть все, что вам нужно в значительной степени
from subprocess import Popen, PIPE
cmd = "ls -l ~/"
p = Popen(cmd , shell=True, stdout=PIPE, stderr=PIPE)
out, err = p.communicate()
print "Return code: ", p.returncode
print out.rstrip(), err.rstrip()
В Linux, если вы хотите вызвать внешнюю команду, которая будет выполняться независимо (будет работать после завершения сценария python), вы можете использовать простую очередь в качестве диспетчера задач или в команде
Пример с диспетчером очереди задач:
import os
os.system('ts <your-command>')
Примечания о диспетчере очереди задач (ts
):
ts -S <number-of-slots>
ts
не требует прав администратора. Вы можете загрузить и скомпилировать его из источника с помощью простого make
, добавить его в свой путь, и все готово. Я обычно использую:
import subprocess
p = subprocess.Popen('ls', shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
for line in p.stdout.readlines():
print line,
retval = p.wait()
Вы можете делать то, что хотите, с данными stdout
в трубе. Фактически вы можете просто опустить эти параметры (stdout=
и stderr=
), и он будет вести себя как os.system()
.
.readlines()
считывает строки all i> сразу, т. е. блокирует до выхода подпроцесса (закрывает его конец). Чтобы читать в режиме реального времени (если нет проблем с буферизацией), вы можете: for line in iter(p.stdout.readline, ''): print line,
– jfs
16 November 2012 в 16:12
p.stdout.readline()
(примечание: no s
в конце) не будет видеть никаких данных, пока ребенок не заполнит свой буфер. Если ребенок не производит много данных, тогда выход не будет в режиме реального времени. См. Вторую причину в Q: Почему бы просто не использовать трубу (popen ())? . В этом ответе приведены некоторые обходные пути (pexpect, pty, stdbuf)
– jfs
17 November 2012 в 15:51
echo $PATH
с помощьюcall(["echo", "$PATH"])
, но он просто повторил буквенную строку$PATH
вместо любой подстановки. Я знаю, что могу получить переменную среды PATH, но мне интересно, есть ли простой способ заставить команду вести себя так, как если бы я выполнил ее в bash. – Kevin Wheeler 1 September 2015 в 23:17shell=True
для этого. – SethMMorton 2 September 2015 в 20:38shell=True
, для этого Python поставляется с os.path.expandvars . В вашем случае вы можете написать:os.path.expandvars("$PATH")
. @SethMMorton, пожалуйста, пересмотреть свой комментарий - & gt; Почему бы не использовать shell = True – Murmel 11 November 2015 в 21:24subprocess.run
вместоsubprocess.call
. docs.python.org/3/library/subprocess.html – Hannes Karppila 4 July 2016 в 19:31ls -l
, но не дает доступа к его выводу (stdout
недоступен). Я нахожу это запутанным - вместо этого вы можете использовать команду без stdout, напримерtouch
. – florisla 12 July 2017 в 10:02check_output
требуется список, а не строка. Если вы не полагаетесь на цитируемые пробелы, чтобы сделать ваш звонок действительным, самым простым и удобным для чтения способом являетсяsubprocess.check_output("ls -l /dev/null".split())
. – Bruno Bronosky 30 January 2018 в 19:18