热门标签:
Q:

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

如何从Python脚本中调用外部命令(就好像我在Unix shell或Windows命令提示符下键入它一样)?

原网址
A:

使用标准库中的subprocess模块:

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

subprocess.runoveros.system是它更灵活(你可以得到stdoutstderr"真实"状态代码,更好的错误处理等。..).

甚至os.system建议使用subprocess代替:

subprocess模块为生成新进程和检索其结果提供了更强大的设施;使用该模块比使用此功能更可取。 有关一些有用的配方,请参阅subprocess文档中的用subprocess模块部分替换旧函数。

在Python3.4及更早版本上,使用subprocess.call而不是.run

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

所有回答

共 29 条

author avatar

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

  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 /"可能会擦除整个文件系统。

author avatar

典型实施:

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

author avatar

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

假设你想从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中启动后台进程的谷歌搜索还没有提供任何帮助。

author avatar
import os
os.system("your command")

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

author avatar

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

subprocess.call(['ping', 'localhost'])
author avatar
import os
cmd = 'ls -al'
os.system(cmd)

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

author avatar

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

资料来源

这些都是图书馆

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

子流程

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.systemos.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是更好的替代方案。

author avatar

与标准库

使用子进程模块(Python3):

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

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

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

ProTip:shlex。split可以帮助您解析runcall和其他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安装。

author avatar

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

检查"pexpect"Python库,太。

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

child = pexpect.spawn('ftp 192.168.0.24')

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

child.sendline('anonymous')

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

如果您需要正在调用的命令的输出, 然后你可以使用子进程。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)。

author avatar

更新资料:

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

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

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

如何从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传递给相应的stderrstdout

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

popenargskwargs被赋予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上的剩余文档将作为读者的练习。

author avatar

使用子进程

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

import os
os.system('cat testfile')
author avatar

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

在这里获取更多信息

author avatar

还有铅垂

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

截至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.stderrresult.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然后是Noneresult.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;将其更新为最新可用的版本。 否则,此堆栈溢出帖子中还有其他答案,向您展示较旧的替代解决方案。

author avatar

使用方法:

import os

cmd = 'ls -al'

os.system(cmd)

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

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

author avatar

可以这么简单:

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

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

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

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

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

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

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

author avatar

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

author avatar
如果您不想测试返回值,

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

author avatar

我倾向于将subprocessshlex一起使用(处理带引号的字符串的转义):

>>> 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)
author avatar

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

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

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

在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
author avatar

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

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

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

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

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

    ts -S <number-of-slots>

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

author avatar

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

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

from subprocess import Popen

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

签出子进程。Popen

相似问题