问题描述：

如何在 Python 中调用外部命令，就像我在 shell 或命令提示符中输入它一样？

解决方案 1：

使用subprocess.run：

import subprocess

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

另一种常见的方法是，os.system但您不应该使用它，因为如果命令的任何部分来自程序外部或可能包含空格或其他特殊字符，则不安全，而且subprocess.run通常更灵活（您可以获得stdout、、 “stderr真实”状态代码、更好的错误处理等）。甚至文档os.system也建议使用subprocess。

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

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

解决方案 2：

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

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

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

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

1. os.popen将执行与 相同的操作，os.system只不过它会为您提供一个文件类对象，您可以使用该对象来访问该进程的标准输入/输出。popen 有 3 种其他变体，它们处理 i/o 的方式略有不同。如果您将所有内容作为字符串传递，那么您的命令将传递给 shell；如果您将它们作为列表传递，那么您不必担心转义任何内容。示例：

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

1. 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 函数。请参阅文档。

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

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

1. subprocess.run。仅适用于 Python 3.5+。与上面的类似，但更加灵活，并CompletedProcess在命令执行完毕时返回一个对象。

2. os.fork，，与 C 语言中的类似os.exec，os.spawn但我不建议直接使用它们。

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

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

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

想象一下用户输入一些“ my mama didnt love me && rm -rf /” 的内容，这可能会删除整个文件系统。

解决方案 3：

典型实现：

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

解决方案 4：

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

假设您想从 CGI 脚本启动一个长任务。也就是说，子进程的存活时间应该比 CGI 脚本执行进程更长。

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

import subprocess
import sys

# Some code here

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

# Some more code here

这里的想法是，您不想在“call subprocess”行中等待，直到 longtask.py 完成。但是，从示例中看，不清楚“some more code here”行之后会发生什么。

我的目标平台是 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

/ 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 上出现此行为的原因。如果有人知道，请分享您的想法。在 Google 上搜索有关在 Python 中启动后台进程的信息，目前还没有找到任何线索。

解决方案 5：

import os
os.system("your command")

请注意，这很危险，因为命令没有被清理。请参阅和模块os的文档sys。有很多函数（exec*和spawn*）可以做类似的事情。

解决方案 6：

我建议使用subprocess模块而不是 os.system，因为它可以为您执行 shell 转义，因此更安全。

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

解决方案 7：

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

如果要返回命令的结果，可以使用os.popen。但是，从 2.6 版开始，此功能已弃用，取而代之的是subprocess 模块，其他答案已对此进行了很好的介绍。

解决方案 8：

有许多不同的库允许您使用 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

• 简体中文: 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.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。如果您想在没有 shell 的情况下运行管道，Plumbum 非常有用。

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

期望

pexpect 可让您生成子应用程序、控制它们并在其输出中查找模式。对于在 Unix 上需要 tty 的命令，这是 subprocess 的更好替代方案。

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 是在安全 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，但是由于它是一个更好的替代方案，因此已从 Python 3 中删除subprocess。

解决方案 9：

使用标准库

使用子进程模块（Python 3）：

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

这是推荐的标准方法。但是，更复杂的任务（管道、输出、输入等）的构建和编写可能会很繁琐。

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

专业提示：如果您不想（或者不能！）以列表形式提供这些函数， shlex.splitrun可以帮助您解析、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。

解决方案 10：

我经常用它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)

解决方案 11：

也检查“pexpect”Python 库。

它允许交互式控制外部程序/命令，甚至 ssh、ftp、telnet 等。您只需输入类似以下内容：

child = pexpect.spawn('ftp 192.168.0.24')

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

child.sendline('anonymous')

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

解决方案 12：

如果您需要所调用命令的输出，那么您可以使用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
'

还请注意shell参数。

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

解决方案 13：

更新：

subprocess.run如果您的代码不需要与早期 Python 版本保持兼容性，则从 Python 3.5 开始推荐使用这种方法。它更一致，并且提供与 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
')

原始答案：

我建议尝试一下Envoy。它是 subprocess 的包装器，旨在替换较旧的模块和功能。Envoy 是面向人类的 subprocess。

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

解决方案 14：

这就是我运行命令的方式。此代码几乎包含您需要的一切

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

解决方案 15：

如何从 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
'
>>> completed_process.stderr
b''

并且这些相应的属性返回字节。

传递命令列表

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

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

注意，args只能按位置传递。

完整签名

这是源中的实际签名，如下所示help(run)：

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

和被赋予构造函数。可以是字节字符串（或unicode，如果指定编码或） popenargs，它将被传输到子进程的标准输入。kwargs`Popeninputuniversal_newlines=True`

该文档描述timeout=得比check=True我能做的更好：

timeout 参数传递给 Popen.communicate()。如果超时，子进程将被终止并等待。子进程终止后，将重新引发 TimeoutExpired 异常。

如果 check 为真，并且进程以非零退出代码退出，则将引发 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但是，直接使用将使您能够访问其方法，包括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 上，该类使用类似 os.execvp() 的行为来执行子程序。在 Windows 上，该类使用 Windows CreateProcess() 函数。Popen 的参数如下。

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

解决方案 16：

使用子进程。

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

import os
os.system('cat testfile')

解决方案 17：

从2018 年 6 月 27 日发布的 Python 3.7.0（https://docs.python.org/3/whatsnew/3.7.html）开始，您可以以最强大而又最简单的方式实现所需的结果。此答案旨在以简短的方式向您展示各种选项的基本摘要。有关深入的答案，请参阅其他答案。

2021 年的 TL;DR

的最大优点os.system(...)是它的简单性。subprocess更好并且仍然易于使用，尤其是从Python 3.5开始。

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

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

就像在壳里

首选方式

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

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

以列表形式传递程序参数。对于包含空格的参数，不要包含"-escaping。

高级用例

检查输出

下面的代码说明了一切：

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将是。从Python 3.7None开始可用。

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)

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：[Errno 2] 没有这样的文件或目录：'ls -a'：'ls -a'

您正在运行一个没有 的子进程shell=True。请使用 list( ["ls", "-a"]) 或 set shell=True。

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

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

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

您始终会从程序中收到字节结果。如果您想像处理普通字符串一样处理它，请设置text=True。

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

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

TypeError：init（）得到了一个意外的关键字参数[...]

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

解决方案 18：

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

在此处获取更多信息。

解决方案 19：

还有Plumbum

>>> from plumbum import local
>>> ls = local["ls"]
>>> ls
LocalCommand(<LocalPath /bin/ls>)
>>> ls()
u'build.py
dist
docs
LICENSE
plumbum
README.rst
setup.py
tests
todo.txt
'
>>> notepad = local["c:\\windows\\notepad.exe"]
>>> notepad()                                   # Notepad window pops up
u''                                             # Notepad window is closed by user, command returns

解决方案 20：

使用：

import os

cmd = 'ls -al'

os.system(cmd)

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

对于更多os功能，请参阅这里提供文档。

解决方案 21：

它可以这么简单：

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

解决方案 22：

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

subprocess.Popen将 <command> 作为子进程执行。在我的例子中，我需要执行文件 ，而该文件需要与另一个程序 进行通信。

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

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

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

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

解决方案 23：

os.system不允许您存储结果，因此如果您想将结果存储在某个列表或某些东西中，那么subprocess.call可以使用。

解决方案 24：

subprocess.check_call如果您不想测试返回值，则很方便。它会在任何错误上引发异常。

解决方案 25：

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

解决方案 26：

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

目前它基本上是 popen 和 shlex 的包装器。它还支持管道命令，因此您可以在 Python 中更轻松地链接命令。因此您可以执行以下操作：

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

解决方案 27：

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

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

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

有关任务假脱机程序的注意事项 ( ts)：

1. 您可以使用以下命令设置要运行的并发进程数（“槽”）：

ts -S <number-of-slots>

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

解决方案 28：

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

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

解决方案 29：

在 Windows 中，您只需导入subprocess模块并通过调用来运行外部命令，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: 
", execute(command)

输出：

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

解决方案 30：

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

from subprocess import Popen

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

检查subprocess.Popen。