调用外部程序的方法总结，包括它们的优缺点:

1. os.system将命令和参数传递给系统的shell。 这很好，因为您实际上可以以这种方式一次运行多个命令，并设置管道和输入/输出重定向。 例如：

   os.system("some_command < input_file | another_command > output_file")  
   

   但是，虽然这很方便，但您必须手动处理shell字符（如空格等）的转义。 另一方面，这也允许您运行简单的shell命令而不是实际的外部程序的命令。

2. os.popen将做与os.system除了它为您提供了一个类似文件的对象，您可以使用它来访问该进程的标准输入/输出。 Popen还有其他3种变体，它们处理i/o的方式略有不同。 如果您将所有内容作为字符串传递，那么您的命令将传递给shell;如果您将它们作为列表传递，那么您无需担心转义任何内容。 例如：

   print(os.popen("ls -l").read())
   

3. subprocess.Popen。 这是作为os.popen，但由于如此全面，其缺点是稍微复杂一些。 例如，你会说：

   print subprocess.Popen("echo Hello World", shell=True, stdout=subprocess.PIPE).stdout.read()
   

   而不是

   print os.popen("echo Hello World").read()
   

   但是在一个统一的类中拥有所有选项而不是4个不同的popen函数是很好的。 请参阅文档。

4. subprocess.call。 这基本上就像Popen类一样，并采用所有相同的参数，但它只是等待命令完成并为您提供返回代码。 例如：

   return_code = subprocess.call("echo Hello World", shell=True)
   

5. subprocess.run。 仅Python3.5+。 与上述类似，但更灵活，并在命令执行完毕时返回CompletedProcess对象。

6. os.fork, os.exec, os.spawn 类似于他们的C语言同行，但我不建议直接使用它们。

subprocess模块可能应该是你使用的。

最后，请注意，对于您将最终命令作为字符串传递给shell执行的所有方法，您有责任转义它。 如果您传递的字符串的任何部分不能完全信任，则存在严重的安全隐患。 例如，如果用户正在输入字符串的某些/任何部分。 如果您不确定，请仅将这些方法与常量一起使用。 为了给你一个暗示的含义，请考虑以下代码：

print subprocess.Popen("echo %s " % user_input, stdout=PIPE).stdout.read()

想象一下，用户输入的"my mama didnt love me && rm -rf /"可能会擦除整个文件系统。

典型实施:

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()。

关于将子进程与调用进程分离的一些提示（在后台启动子进程）。

假设你想从CGI脚本开始一个长任务。 也就是说，子进程应该比CGI脚本执行进程活得更长。

Subprocess模块文档中的经典示例是:

import subprocess
import sys

# Some code here

pid = subprocess.Popen([sys.executable, "longtask.py"]) # Call subprocess

# Some more code here

这里的想法是，你不想在'call subprocess'行中等待，直到longtask.py 完成了。 但目前尚不清楚在示例中的"更多代码"行之后会发生什么。

我的目标平台是FreeBSD，但开发是在Windows上，所以我首先在Windows上遇到问题。

在Windows（Windows XP）上，父进程将不会完成，直到longtask.py 已经完成了它的工作。 这不是你在CGI脚本中想要的。 问题不是特定于Python的;在PHP社区中，问题是相同的。

解决方法是将DETACHED_PROCESS进程创建标志传递给Windows API中的底层CreateProcess函数。 如果你碰巧安装了pywin32，你可以从win32process模块导入标志，否则你应该自己定义它：

DETACHED_PROCESS = 0x00000008

pid = subprocess.Popen([sys.executable, "longtask.py"],
                       creationflags=DETACHED_PROCESS).pid

/*UPD2015.10.27@eryksun在下面的注释中指出，语义正确的标志是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行为的原因。 如果有人知道，请分享您的想法。 在Python中启动后台进程的谷歌搜索还没有提供任何帮助。

import os
os.system("your command")

请注意，这是危险的，因为命令没有被清理。 我把它留给你谷歌有关'os'和'sys'模块的相关文档。 有一堆函数（exec*和spawn*）会做类似的事情。

我建议使用subprocess模块而不是os。系统，因为它为你做外壳逃逸，因此更安全。

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

import os
cmd = 'ls -al'
os.system(cmd)

如果要返回命令的结果，可以使用os.popen。 但是，自2.6版本以来，这被弃用，有利于子进程模块，其他答案已经很好地复盖了这一点。

有许多不同的库，允许您使用Python调用外部命令。 对于每个库，我都给出了一个描述，并展示了调用外部命令的示例。 我用作示例的命令是ls -l（列出所有文件）。 如果您想了解有关我列出的任何库的更多信息，并链接了每个库的文档。

资料来源

• 子进程：https://docs.python.org/3.5/library/subprocess.html
• shlex：https://docs.python.org/3/library/shlex.html
• os：https://docs.python.org/3.5/library/os.html
• sh：https://amoffat.github.io/sh/
• 铅垂:https://plumbum.readthedocs.io/en/latest/
• pexpect：https://pexpect.readthedocs.io/en/stable/
• 面料:http://www.fabfile.org/
• 使节：https://github.com/kennethreitz/envoy
• 命令：https://docs.python.org/2/library/commands.html

这些都是图书馆

希望这将帮助您决定使用哪个库:)

子流程

Subprocess允许您调用外部命令并将它们连接到它们的输入/输出/错误管道（stdin，stdout和stderr）。 Subprocess是运行命令的默认选择，但有时其他模块更好。

subprocess.run(["ls", "-l"]) # Run command
subprocess.run(["ls", "-l"], stdout=subprocess.PIPE) # This will run the command and return any output
subprocess.run(shlex.split("ls -l")) # You can also use the shlex library to split the command

os

os用于"依赖于操作系统的功能"。 它也可以用来调用带有os.system和os.popen的外部命令（注意：还有一个子进程。popen）。 os将始终运行shell，对于不需要或不知道如何使用的人来说是一个简单的替代方案subprocess.run。

os.system("ls -l") # Run command
os.popen("ls -l").read() # This will run the command and return any output

sh

sh是一个子进程接口，它允许你像调用函数一样调用程序。 如果要多次运行命令，这很有用。

sh.ls("-l") # Run command normally
ls_cmd = sh.Command("ls") # Save command as a variable
ls_cmd() # Run command as if it were a function

铅垂

plumbum是一个用于"类似脚本"的Python程序的库。 您可以像sh中那样调用函数之类的程序。 如果您想在没有shell的情况下运行管道，Plumbum非常有用。

ls_cmd = plumbum.local("ls -l") # Get command
ls_cmd() # Run command

pexpect

pexpect允许您生成子应用程序，控制它们并在其输出中查找模式。 对于期望在Unix上使用tty的命令，这是一个更好的替代子进程。

pexpect.run("ls -l") # Run command as normal
child = pexpect.spawn('scp foo user@example.com:.') # Spawns child application
child.expect('Password:') # When this is the output
child.sendline('mypassword')

织物

fabric是一个Python2.5和2.7库。 它允许您执行本地和远程shell命令。 Fabric是在安全shell(SSH)中运行命令的简单替代方案

fabric.operations.local('ls -l') # Run command as normal
fabric.operations.local('ls -l', capture = True) # Run command and receive output

特使

envoy被称为"人类的子进程"。 它用作subprocess模块周围的方便包装器。

r = envoy.run("ls -l") # Run command
r.std_out # Get output

命令

commands包含os.popen的包装函数，但它已从Python3中删除，因为subprocess是更好的替代方案。

与标准库

使用子进程模块(Python3):

import subprocess
subprocess.run(['ls', '-l'])

是推荐的标准方式。 然而，更复杂的任务（管道，输出，输入等。）可以是繁琐的构造和编写。

注意Python版本：如果您仍在使用Python2，subprocess。call的工作方式类似。

ProTip：shlex。split可以帮助您解析run，call和其他subprocess函数的命令，以防您不想要（或者您不能！）以列表的形式提供它们：

import shlex
import subprocess
subprocess.run(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安装。

我总是使用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)

检查"pexpect"Python库，太。

它允许交互式控制外部程序/命令，甚至ssh，ftp，telnet等。 你可以输入类似的东西:

child = pexpect.spawn('ftp 192.168.0.24')

child.expect('(?i)name .*: ')

child.sendline('anonymous')

child.expect('(?i)password')

如果您需要正在调用的命令的输出, 然后你可以使用子进程。check_output（Python2.7+）。

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

还要注意shell参数。

如果shell为True，则指定的命令将通过shell执行。 如果您主要将Python用于它在大多数系统shell上提供的增强控制流，并且仍然希望方便地访问其他shell功能，例如shell管道，文件名通配符，环境变量扩展以及将~扩 但是，请注意，Python本身提供了许多类似shell的功能的实现（特别是, glob, fnmatch, os.walk(), os.path.expandvars(), os.path.expanduser(), 和shutil)。

更新资料:

subprocess.run是推荐的方法。 它更一致，并提供与Envoy类似的易用性。 （管道并不那么简单。 有关如何，请参阅这个问题。)

下面是来自文档的一些示例。

运行进程:

>>> 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。 它是子进程的包装器，子进程反过来旨在替换旧的模块和函数。 Envoy对人类来说是subprocess。

自述文件的示例用法:

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

这就是我运行命令的方式。 这段代码有你需要的一切

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

如何从Python执行程序或调用系统命令

简单，使用subprocess.run，它返回一个CompletedProcess对象：

>>> from subprocess import run
>>> from shlex import split
>>> completed_process = run(split('python --version'))
Python 3.8.8
>>> completed_process
CompletedProcess(args=['python', '--version'], returncode=0)

(run需要一个词法解析的shell参数列表--这是你在shell中键入的参数，用空格分隔，但不是在空格被引用的地方，所以使用一个专门的函数，split，把你从字面上输入到你的shell中）

为啥?

从Python3.5开始，文档推荐子进程。运行:

调用子流程的推荐方法是对它可以处理的所有用例使用run()函数。 对于更高级的用例，可以直接使用底层Popen接口。

下面是一个最简单的用法的例子--它完全按照要求做:

>>> from subprocess import run
>>> from shlex import split
>>> completed_process = run(split('python --version'))
Python 3.8.8
>>> completed_process
CompletedProcess(args=['python', '--version'], returncode=0)

run等待命令成功完成，然后返回一个CompletedProcess对象。 它可能会引发TimeoutExpired（如果你给它一个timeout=参数）或CalledProcessError（如果它失败并且你通过check=True）。

正如您从上面的示例中可能推断的那样，默认情况下，stdout和stderr都会通过管道传输到您自己的stdout和stderr。

我们可以检查返回的对象并查看给出的命令和returncode:

>>> completed_process.args
['python', '--version']
>>> completed_process.returncode
0

捕获输出

如果要捕获输出，可以将subprocess.PIPE传递给相应的stderr或stdout：

>>> from subprocess import PIPE
>>> completed_process = run(shlex.split('python --version'), stdout=PIPE, stderr=PIPE)
>>> completed_process.stdout
b'Python 3.8.8\n'
>>> completed_process.stderr
b''

和那些各自的属性返回字节。

传递命令列表

人们可能很容易从手动提供命令字符串（如问题所示）转变为以编程方式构建的字符串。 不要以编程方式构建字符串。这是一个潜在的安全问题。 最好假设你不信任输入。

>>> import textwrap
>>> args = ['python', textwrap.__file__]
>>> cp = run(args, stdout=subprocess.PIPE)
>>> cp.stdout
b'Hello there.\n  This is indented.\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：

超时参数传递给Popen。沟通（）。 如果超时 过期，子进程将被杀死并等待。 该 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)

请注意，这表明只有args列表应该按位置传递。 因此，将其余参数作为关键字参数传递。

波本

当使用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=True,
             shell=False, cwd=None, env=None, universal_newlines=None,
             startupinfo=None, creationflags=0,
             restore_signals=True, start_new_session=False,
             pass_fds=(), *, user=None, group=None, extra_groups=None,
             encoding=None, errors=None, text=None, umask=-1, pipesize=-1):

但更具信息性的是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=None, startupinfo=None, creationflags=0, 
restore_signals=True, start_new_session=False, pass_fds=(), *, group=None, 
extra_groups=None, user=None, umask=-1, encoding=None, errors=None, 
text=None)

在新进程中执行子程序。 在POSIX上，该类使用 操作系统。执行子程序的类似execvp()的行为。 在Windows上, 该类使用Windows CreateProcess()函数。 的论点 Popen如下。

了解Popen上的剩余文档将作为读者的练习。

使用子进程。

...或者对于一个非常简单的命令:

import os
os.system('cat testfile')

os.system还可以，但有点过时了。 它也不是很安全。 相反，尝试subprocess。 subprocess不直接调用sh，因此比os.system更安全。

在这里获取更多信息。

还有铅垂

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

截至Python3.7.0于2018年6月27日发布（https://docs.python.org/3/whatsnew/3.7.html），您可以以最强大而同样简单的方式实现您想要的结果。 这个答案旨在以简短的方式向您展示各种选项的基本摘要。 有关深入的答案，请参阅其他答案。

TL;2021年博士

os.system(...)的最大优点是它的简单性。 subprocess更好，仍然易于使用，特别是从Python3.5开始。

import subprocess
subprocess.run("ls -a", shell=True)

注意：这是你的问题的确切答案-运行一个命令

就像在贝壳里一样

首选方式

如果可能，请删除shell开销并直接运行命令（需要列表）。

import subprocess
subprocess.run(["help"])
subprocess.run(["ls", "-a"])

在列表中传递程序参数。 不要包含\"-转义包含空格的参数。

高级用例

检查输出

下面的代码不言自明:

import subprocess
result = subprocess.run(["ls", "-a"], capture_output=True, text=True)
if "stackoverflow-logo.png" in result.stdout:
    print("You're a fan!")
else:
    print("You're not a fan?")

result.stdout是所有正常的程序输出排除错误。 阅读result.stderr以获得它们。

capture_output=True-打开捕获。 否则result.stderr和result.stdout将是None。 可从Python3.7获得。

text=True-在Python3.7中添加了一个方便的参数，它将接收到的二进制数据转换为您可以轻松使用的Python字符串。

检查返回码

做

if result.returncode == 127: print("The program failed for some weird reason")
elif result.returncode == 0: print("The program succeeded")
else: print("The program failed unexpectedly")

如果你只是想检查程序是否成功（returncode==0），否则抛出异常，有一个更方便的功能:

result.check_returncode()

但它是Python，所以有一个更方便的参数check它会自动为你做同样的事情：

result = subprocess.run(..., check=True)

stderr应该在stdout内部

您可能希望将所有程序输出都包含在stdout中，甚至是错误。 要做到这一点，运行

result = subprocess.run(..., stderr=subprocess.STDOUT)

result.stderr然后是None，result.stdout将包含所有内容。

使用shell=False与参数字符串

shell=False期望参数的列表。 但是，您可以使用shlex自行拆分参数字符串。

import subprocess
import shlex
subprocess.run(shlex.split("ls -a"))

就这样。

常见问题

当你遇到这个问题时，你刚开始使用Python的机会很高。 让我们来看看一些常见的问题。

FileNotFoundError:[Errno2]没有这样的文件或目录:'ls-a':'ls-a'

你正在运行一个没有shell=True的子进程。 使用列表(["ls", "-a"])或设置shell=True。

TypeError：[。..]NoneType[...]

检查是否已设置capture_output=True。

TypeError：需要一个类似字节的对象，而不是[。..]

您总是从程序接收字节结果。 如果你想像一个普通的字符串一样使用它，设置text=True。

子进程。CalledProcessError：命令'[。..]'返回非零退出状态1。

您的命令没有成功运行。 您可以禁用returncode检查或检查实际程序的有效性。

TypeError:init()得到了一个意想不到的关键字参数[。..]

您可能使用的Python版本早于3.7.0;将其更新为最新可用的版本。 否则，此堆栈溢出帖子中还有其他答案，向您展示较旧的替代解决方案。

使用方法:

import os

cmd = 'ls -al'

os.system(cmd)

os-该模块提供了一种使用依赖于操作系统的功能的便携方式。

对于更多的os函数，这里的是文档。

可以这么简单:

import os
cmd = "your command"
os.system(cmd)

这里还有一个区别，前面没有提到。

subprocess.Popen作为子进程执行<命令>。 在我的情况下，我需要执行文件它需要与另一个程序进行通信，。

我尝试了subprocess，执行成功。 但是无法与通信。 当我从终端运行两者时，一切正常。

再来一个: （注意：kwrite的行为与其他应用程序不同。 如果您使用Firefox尝试以下操作，结果将不相同。)

如果尝试os.system("kwrite")，程序流会冻结，直到用户关闭kwrite。 为了克服这一点，我尝试了os.system(konsole -e kwrite)。 这次程序继续流动，但kwrite成为控制台的子进程。

任何人运行的kwrite都不是子进程（即在系统监视器中，它必须出现在树的最左边缘）。

os.system不允许你存储结果，所以如果你想将结果存储在某个列表或其他东西中，asubprocess.call可以工作。

subprocess.check_call很方便。 它会对任何错误抛出异常。

我倾向于将subprocess与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)

我为此写了一个库，shell.py.

它现在基本上是popen和shlex的包装。 它还支持管道命令，因此您可以在Python中更轻松地链接命令。 所以你可以做这样的事情:

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

在Windows中，您可以通过调用subprocess.Popen().wait()，subprocess.Popen()和subprocess.Popen().communicate()来导入subprocess.Popen().wait()模块并运行外部命令，如下所示：

# Python script to run a command line
import subprocess

def execute(cmd):
    """
        Purpose  : To execute a command and return exit status
        Argument : cmd - command to execute
        Return   : exit_code
    """
    process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    (result, error) = process.communicate()

    rc = process.wait()

    if rc != 0:
        print "Error: failed to execute command:", cmd
        print error
    return result
# def

command = "tasklist | grep python"
print "This process detail: \n", execute(command)

输出:

This process detail:
python.exe                     604 RDP-Tcp#0                  4      5,660 K

在Linux下，如果你想调用一个独立执行的外部命令（在Python脚本终止后继续运行），你可以使用一个简单的队列作为任务后台处理程序或at命令。

任务后台处理程序的示例:

import os
os.system('ts <your-command>')

关于task spooler(ts)的注意事项：

1. 您可以设置要运行的并发进程的数量（"插槽"）:

   ts -S <number-of-slots>

2. 安装ts不需要管理员权限。 你可以用一个简单的make从源代码下载并编译它，将它添加到你的路径中，你就完成了。

Invoke是一个Python（2.7和3.4+）任务执行工具和库。 它为运行shell命令提供了一个干净的高级API：

>>> from invoke import run
>>> cmd = "pip install -r requirements.txt"
>>> result = run(cmd, hide=True, warn=True)
>>> print(result.ok)
True
>>> print(result.stdout.splitlines()[-1])
Successfully installed invocations-0.13.0 pep8-1.5.7 spec-1.3.1

您可以使用Popen，然后可以检查过程的状态:

from subprocess import Popen

proc = Popen(['ls', '-l'])
if proc.poll() is None:
    proc.kill()

签出子进程。Popen。