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

使用标准库中的 subprocess 模块：

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

subprocess.run 相对于 os.system 的优势在于它更灵活（您可以获得 stdout、stderr、"real" status code、更好的 error handling 等...）。

甚至 the documentation for os.system 也建议使用 subprocess：

subprocess 模块提供了更强大的工具来生成新进程并检索它们的结果；使用该模块优于使用此功能。请参阅子流程文档中的用子流程模块替换旧功能部分以获取一些有用的秘诀。

在 Python 3.4 及更早版本上，使用 subprocess.call 而不是 .run：

subprocess.call(["ls", "-l"])

---

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

os.system 将命令和参数传递给系统的 shell。这很好，因为您实际上可以以这种方式一次运行多个命令并设置管道和输入/输出重定向。例如： os.system("some_command < input_file | another_command > output_file") 但是，虽然这很方便，但您必须手动处理空格等 shell 字符的转义。另一方面，这也允许您运行只是 shell 命令而不是实际外部程序的命令。 os.popen 将做与 os.system 相同的事情，只是它为您提供了一个类似文件的对象，您可以使用该对象来访问该进程的标准输入/输出。 popen 还有 3 个其他变体，它们对 i/o 的处理都略有不同。如果您将所有内容都作为字符串传递，那么您的命令将传递给 shell；如果您将它们作为列表传递，那么您无需担心转义任何内容。示例：print(os.popen("ls -l").read()) 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 函数。请参阅文档。子进程调用。这基本上就像 Popen 类并接受所有相同的参数，但它只是等待命令完成并为您提供返回码。例如：return_code = subprocess.call("echo Hello World", shell=True) subprocess.run。仅限 Python 3.5+。与上述类似，但更加灵活，并在命令执行完成时返回 CompletedProcess 对象。 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 脚本执行进程长。

子流程模块文档中的经典示例是：

import subprocess
import sys

# Some code here

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

# Some more code here

这里的想法是，您不想在“调用子进程”行中等待，直到 longtask.py 完成。但尚不清楚示例中的“这里有更多代码”行之后会发生什么。

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

在 Windows (Windows XP) 上，父进程在 longtask.py 完成其工作之前不会完成。这不是您在 CGI 脚本中想要的。该问题并非特定于 Python；在 PHP 社区中，问题是一样的。

解决方案是将 DETACHED_PROCESS Process Creation Flag 传递给 Windows API 中的底层 CreateProcess 函数。如果你碰巧安装了pywin32，你可以从win32process模块导入flag，否则你应该自己定义：

DETACHED_PROCESS = 0x00000008

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

/* UPD 2015.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.system，因为它会为您进行 shell 转义，因此更安全。

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

---

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

如果要返回命令的结果，可以使用 os.popen。但是，自 2.6 版起已弃用此功能，转而支持 subprocess module，其他答案已经很好地涵盖了这一点。

---

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

来源

子进程：https://docs.python.org/3.5/library/subprocess.html

shlex：https://docs.python.org/3/library/shlex.html

操作系统：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

这些都是图书馆

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

子进程

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

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.system 和 os.popen 的外部命令（注意：还有一个 subprocess.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.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 中的函数等程序。如果您想在没有外壳的情况下运行管道，Plumbum 很有用。

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

期待

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 是一个 Python 2.5 和 2.7 库。它允许您执行本地和远程 shell 命令。 Fabric 是在安全外壳 (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 的包装函数，但它已从 Python 3 中删除，因为 subprocess 是更好的选择。

---

使用标准库

使用 subprocess module (Python 3)：

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

这是推荐的标准方式。然而，更复杂的任务（管道、输出、输入等）的构建和编写可能会很乏味。

关于 Python 版本的注意事项：如果您仍在使用 Python 2，subprocess.call 的工作方式类似。

专业提示：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 subprocess interface)。

看一个例子：

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

---

如果您需要正在调用的命令的输出，则可以使用 subprocess.check_output (Python 2.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）。

---

更新：

如果您的代码不需要保持与早期 Python 版本的兼容性，subprocess.run 是推荐的方法 as of Python 3.5。它更加一致，并提供与 Envoy 类似的易用性。 （但管道并不那么简单。参见this question for how。）

以下是来自 the documentation 的一些示例。

运行一个进程：

>>> 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。它是子进程的包装器，它反过来 aims to replace 较旧的模块和函数。 Envoy 是人类的子进程。

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

---

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

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）

为什么？

从 Python 3.5 开始，文档推荐 subprocess.run：

调用子流程的推荐方法是对它可以处理的所有用例使用 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。

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

>>> 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），将通过管道传送到子进程的标准输入。

该文档比我更好地描述了 timeout= 和 check=True：

超时参数被传递给 Popen.communicate()。如果超时，子进程将被杀死并等待。 TimeoutExpired 异常将在子进程终止后重新引发。如果检查为真，并且进程以非零退出代码退出，则会引发 CalledProcessError 异常。该异常的属性包含参数、退出代码以及标准输出和标准错误（如果它们被捕获）。

check=True 的这个例子比我想出的要好：

>>> subprocess.run("exit 1", shell=True, check=True) Traceback (last last 最近调用): ... subprocess.CalledProcessError: Command 'exit 1' 返回非零退出状态 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”。

这是 the source 中给出的 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):

但更多信息是 the Popen documentation：

subprocess.Popen(args, bufsize=-1, 可执行文件=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 上，该类使用类似 os.execvp() 的行为来执行子程序。在 Windows 上，该类使用 Windows CreateProcess() 函数。 Popen 的论点如下。

理解 Popen 上的其余文档将留给读者作为练习。

---

使用 subprocess。

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

import os
os.system('cat testfile')

---

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

获取更多信息here。

---

从 2018 年 6 月 27 日发布的 Python 3.7.0 (https://docs.python.org/3/whatsnew/3.7.html)开始，您可以以最强大同时同样简单的方式实现您想要的结果。该答案旨在以简短的方式向您展示各种选项的基本摘要。如需深入解答，请参阅其他答案。

TL;2021 年博士

os.system(...) 的最大优势在于其简单性。 subprocess 更好并且仍然易于使用，尤其是从 Python 3.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。可从 Python 3.7 获得。

text=True - Python 3.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)

标准错误应该在标准输出里面

您可能希望在标准输出中包含所有程序输出，甚至是错误。为此，运行

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

result.stderr 将成为 None，而 result.stdout 将包含所有内容。

使用带有参数字符串的 shell=False

shell=False 需要一个list 参数。但是，您可以使用 shlex 自行拆分参数字符串。

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

而已。

常见问题

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

FileNotFoundError：[Errno 2] 没有这样的文件或目录：'ls -a'：'ls -a'

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

类型错误：[...] NoneType [...]

检查您是否设置了 capture_output=True。

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

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

subprocess.CalledProcessError：命令“[...]”返回非零退出状态 1。

您的命令未成功运行。您可以禁用返回码检查或检查您的实际程序的有效性。

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

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

---

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

---

利用：

import os

cmd = 'ls -al'

os.system(cmd)

os - 该模块提供了一种使用操作系统相关功能的可移植方式。

对于更多 os 函数，here 是文档。

---

可以这么简单：

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

---

这里还有一个之前没有提到的区别。

subprocess.Popen 执行 <command>作为子进程。就我而言，我需要执行文件 <a>它需要与另一个程序进行通信，<b>。

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

还有一个：（注意：kwrite 的行为与其他应用程序不同。如果您使用 Firefox 尝试以下操作，结果将不一样。）

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

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

---

“任何人都运行 kwrite 而不是子进程”是什么意思？

subprocess 运行一个子进程确实令人费解。