Python 调用系统命令的模块 Subprocess

来自:Python学习开发(微信号:python3-5),作者:陈祥安


有些时候需要调用系统内部的一些命令,或者给某个应用命令传不定参数时可以使用该模块。

初识 Subprocess 模块

Subprocess 模块提供了多个方法来运行额外的进程。在 Python2.7 的时候使用的方法主要有 call(),check_call(), check_output(),到了 Python3.5 的时候加入了一个更高级的方法 run(),该方法可以运行一个额外的进程同时它还能收集到运行之后的结果。Popen 类最为一个低级 API,它主要用于构建其他 API,在更复杂的流程交互中非常有用。Popen 的构造函数接受参数来设置新进程,以便父进程可以通过管道与它通信。它替换了其他模块和函数的所有功能,甚至更多。Subprocess 子进程模块旨在替换 os.system(), os.spawnv()等函数,os 和 popen2 模块中 popen()的变体,以及 commands()模块
注意:在 Unix 和 Windows 系统上工作的应用编程接口大致相同,但是底层的实现是不同的,因为操作系统中的过程模型不同。这里显示的所有示例都是在 Mac 操作系统上测试的。在非 Unix 操作系统上的行为可能会有所不同。例如 unix 系统查看文件列表使用 ls,windows 只能使用 dir.

Run 方法使用

运行外部命令

要实现和 os.system()命令相同的方式,运行外部命令而不与之交互时候,我们可以使用 run()函数。前面提到了这是一个高级函数
先看一下其语法结构。

subprocess.run(args,?*,?stdin=None,?input=None,?stdout=None,?stderr=None,?capture_output=False,?shell=False,?cwd=None,?timeout=None,?check=False,?encoding=None,?errors=None,?text=None,?env=None,?universal_newlines=None)

运行被 arg 描述的指令。等待指令完成,然后返回一个 CompletedProcess 示例。run 方法的参数和 Popen 的构造函数一样,接受的大多数参数都被传递给该接口。(timeout, input, check 和 capture_output 除外)。

import?subprocess
completed?=?subprocess.run(['ls',?'-1'])
print('returncode:',?completed.returncode)

输出内容:

subprocess_demo.py
returncode:?0

第一个参数传入的就是我们要运行的命令,其格式推荐使用列表字符串的形式,将命令进行分割。这避免了转义引号或 shell 可能解释的其他特殊字符的需要。
如果将 shell 参数设置为 true 值将导致子进程生成一个中间 shell 进程,然后运行该命令。默认情况下是直接运行命令。

import?subprocess

completed?=?subprocess.run('echo?$HOME',?shell=True)
print('returncode:',?completed.returncode)

输出

/Users/chenxiangan
returncode:?0

使用中间 shell 意味着在运行命令之前要处理命令字符串中的变量、glob 模式和其他特殊的 shell 特性。

错误处理

CompletedProcess 的 returncode 属性是程序的退出代码。 调用者负责解释它以检测错误。 如果 run()的 check 参数为 True,则检查退出代码,如果它指示发生错误,则引发 CalledProcessError 异常。

#公众号:python?学习开发
#author:陈祥安
import?subprocess

try:
????subprocess.run(['false'],?check=True)
except?subprocess.CalledProcessError?as?err:
????print('ERROR:',?err)

运行结果

ERROR:?Command?'['false']'?returned?non-zero?exit?status?1.

false 命令总是以非零状态代码退出,run()将其解释为错误。
将 run()函数的 check 属性设置为 True,等同于使用 check_call()方法。

获取结果

由于 run()启动的进程的标准输入和输出通道绑定到父输入和输出。 这意味着调用程序无法捕获命令的输出。 可以通过调整 stdout 和 stderr 参数来捕获输出的值。

#公众号:python?学习开发
#author:陈祥安
import?subprocess

completed?=?subprocess.run(
????['ls',?'-1'],
????stdout=subprocess.PIPE,
)
print('returncode:',?completed.returncode)
print(f"结果的字节长度?{len(completed.stdout)}:\n{?completed.stdout.decode('utf-8')}")

输出

returncode:?0
结果的字节长度?24:
subprocess_demo.py

ls -1 命令成功运行,捕获并返回输出结果。
下一个示例在子 shell 中运行一系列命令。 在命令退出并显示错误代码之前,消息将发送到标准输出和标准错误。

#公众号:python?学习开发

import?subprocess

try:
????completed?=?subprocess.run(
????????'echo?to?stdout;?echo?to?stderr?1>&2;?exit?1',
????????check=True,
????????shell=True,
????????stdout=subprocess.PIPE,
????)
except?subprocess.CalledProcessError?as?err:
????print('ERROR:',?err)
else:
????print('returncode:',?completed.returncode)
????print(f"stdout?中的字节长度?{len(completed.stdout)}?:?{completed.stdout.decode('utf-8')!r}")

输出结果

to?stderr
ERROR:?Command?'echo?to?stdout;?echo?to?stderr?1>&2;?exit?1'?returned?non-zero?exit?status?1.

发送到标准错误的消息被打印到控制台,但是发送到标准输出的消息是隐藏的。
为了防止通过 run()运行的命令的错误消息被写入控制台, 需要将 stderr 参数设置为 subprocess.PIPE。修改后代码如下

#公众号:python?学习开发

import?subprocess

try:
????completed?=?subprocess.run(
????????'echo?to?stdout;?echo?to?stderr?1>&2;?exit?1',
????????shell=True,
????????stdout=subprocess.PIPE,
????????stderr=subprocess.PIPE,
????)
except?subprocess.CalledProcessError?as?err:
????print('ERROR:',?err)
else:
????print('returncode:',?completed.returncode)
????print(f"stderr?字节长度{len(completed.stdout)}:?{completed.stdout.decode('utf-8')!r}")
????print(f"stderr?字节长度{len(completed.stderr)}:?{completed.stderr.decode('utf-8')!r}")

输出结果

returncode:?1
stderr?字节长度?10:?'to?stdout\n'
stderr?字节长度?10:?'to?stderr\n'

本示例未设置 check=True,因此会捕获并打印命令的输出。若要在使用 check_output()时捕获错误消息,请将 stderr 设置为 STDOUT,消息将与命令的其余输出合并。

禁止输出

对于不应该显示或捕获输出的情况,使用 DEVNULL 来抑制输出流,这个例子同时抑制了标准输出和错误流。

#?公众号:python?学习开发


import?subprocess

try:
????completed?=?subprocess.run(
????????'echo?to?stdout;?echo?to?stderr?1>&2;?exit?1',
????????shell=True,
????????stdout=subprocess.DEVNULL,
????????stderr=subprocess.DEVNULL,
????)
except?subprocess.CalledProcessError?as?err:
????print('ERROR:',?err)
else:
????print('returncode:',?completed.returncode)
????print(f'stdout?is?{completed.stdout!r}')
????print(f'stderr?is?{completed.stderr!r}')

输出

returncode:?1
stdout?is?None
stderr?is?None

名称 DEVNULL 来自于 Unix 特殊设备文件/DEVE/null,该文件在打开读取时以文件结尾响应,并在写入时接收但忽略任何数量的输入。

Popen 方法的使用

函数 run()、call()、check_call()和 check_output()是 Popen 类的包装器。直接使用 Popen 可以更好地控制命令的运行方式以及输入和输出流的处理方式。例如,通过传递 stdin、stdout 和 stderr 的不同参数,可以模拟 os.popen()。
Popen 的语法结构如下:

class?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=(),?*,?encoding=None,?errors=None,?text=None)?

args 应当是一个程序的参数列表或者一个简单的字符串。默认情况下,如果 args 是一个序列,将运行的程序是此序列的第一项。如果 args 是一个字符串,解释是平台相关的,如下所述。除非另有说明,推荐将 args 作为序列传递。
参数 shell (默认为 False)指定是否使用 shell 执行程序。如果 shell 为 True,更推荐将 args 作为字符串传递而非序列。
在 POSIX,当 shell=True, shell 默认为 /bin/sh。如果 args 是一个字符串,此字符串指定将通过 shell 执行的命令。这意味着字符串的格式必须和在命令提示符中所输入的完全相同。这包括,例如,引号和反斜杠转义包含空格的文件名。如果 args 是一个序列,第一项指定了命令,另外的项目将作为传递给 shell (而非命令) 的参数对待。也就是说, Popen 等同于:

Popen(['/bin/sh',?'-c',?args[0],?args[1],?...])

在 Windows,使用 shell=True,环境变量 COMSPEC 指定了默认 shell。在 Windows 你唯一需要指定 shell=True 的情况是你想要执行内置在 shell 中的命令(例如 dir 或者 copy)。在运行一个批处理文件或者基于控制台的可执行文件时,不需要 shell=True。

与进程的单向通信

要运行进程并读取其所有输出,需要将 stdout 值设置为 PIPE 并调用。

import?subprocess

print('read:')
proc?=?subprocess.Popen(
????['echo',?'"to?stdout"'],
????stdout=subprocess.PIPE,
)
stdout_value?=?proc.communicate()[0].decode('utf-8')
print('stdout:',?repr(stdout_value))

输出

read:
stdout:?'"to?stdout"\n'

如果要设置管道允许调用程序将数据写入管道,需要将 stdin 设置为 pipe。

import?subprocess

print('write:')
proc?=?subprocess.Popen(
????['cat',?'-'],
????stdin=subprocess.PIPE,
)
proc.communicate('stdin:?to?stdin\n'.encode('utf-8'))

输出

write:
stdin:?to?stdin

要一次将数据发送到进程的标准输入通道,可以使用返回对象的 communication()方法。 它与使用'w'模式的 popen()类似.

与进程的双向通信

要同时设置 Popen 实例进行读写,请结合使用以前的技术。

import?subprocess

print('popen2:')

proc?=?subprocess.Popen(
????['ls',?'-l'],
????stdin=subprocess.PIPE,
????stdout=subprocess.PIPE,
)
msg?=?'through?stdin?to?stdout'.encode('utf-8')
stdout_value?=?proc.communicate(msg)[0].decode('utf-8')
print('pass?through:',?repr(stdout_value))

输出

popen2:
pass?through:?'total?8\n-rw-r--r--??1?chenxiangan??staff??316?Jul??9?11:20?subprocess_demo.py\n'

使用 communicate() 而非 .stdin.write, .stdout.read 或者 .stderr.read 来避免由于任意其他 OS 管道缓冲区被子进程填满阻塞而导致的死锁。

错误捕获

Popen 还可以像使用 popen3()一样,同时监视 stdout 和 stderr 流。

import?subprocess

print('popen3:')
proc?=?subprocess.Popen(
????'ls?-l;?echo?"to?stderr"?1>&2',
????shell=True,
????stdin=subprocess.PIPE,
????stdout=subprocess.PIPE,
????stderr=subprocess.PIPE,
)
msg?=?'through?stdin?to?stdout'.encode('utf-8')
stdout_value,?stderr_value?=?proc.communicate(msg)
print('pass?through:',?repr(stdout_value.decode('utf-8')))
print('stderr??????:',?repr(stderr_value.decode('utf-8')))

输出

popen3:
pass?through:?'total?8\n-rw-r--r--??1?chenxiangan??staff??447?Jul??9?11:22?subprocess_os_system.py\n'
stderr??????:?'to?stderr\n'

从 stderr 读取的工作与 stdout 相同。 通过传入 PIPE 告诉 Popen 连接到通道,并且 communication()方法在返回结果之前可以从中读取所有数据。

结合常规输出和错误输出

要将进程的错误输出定向到其标准输出通道,可以使用 STDOUT 代替 stderr 而不是 PIPE。

#?公众号:python?学习开发


import?subprocess

print('popen4:')
proc?=?subprocess.Popen(
????'ls?-l;?echo?"to?stderr"?1>&2',
????shell=True,
????stdin=subprocess.PIPE,
????stdout=subprocess.PIPE,
????stderr=subprocess.STDOUT,
)
msg?=?'through?stdin?to?stdout\n'.encode('utf-8')
stdout_value,?stderr_value?=?proc.communicate(msg)
print('combined?output:',?repr(stdout_value.decode('utf-8')))
print('stderr?value???:',?repr(stderr_value))

输出

popen4:
combined?output:?'total?8\n-rw-r--r--??1?chenxiangan??staff??441?Jul??9?11:25?subprocess_os_system.py\nto?stderr\n'
stderr?value???:?None

以这种方式组合输出类似于 popen4()的工作方式。

管道之间的连接

通过创建单独的 Popen 实例并将它们的输入和输出链接在一起,可以类似于 Unix shell 的工作方式将多个命令连接到管道中。

#?公众号:python?学习开发


import?subprocess

cat?=?subprocess.Popen(
????['cat',?'subprocess_demo.py'],
????stdout=subprocess.PIPE,??#?提供输出的方式
)

grep?=?subprocess.Popen(
????['grep',?'公众号'],
????stdin=cat.stdout,??#?cat?的输出最为输入
????stdout=subprocess.PIPE,
)

cut?=?subprocess.Popen(
????['awk',?'-F',?':',?'{print?$2}'],
????stdin=grep.stdout,
????stdout=subprocess.PIPE,
)

end_of_pipe?=?cut.stdout

print(end_of_pipe.readline().decode('utf-8'))

输出

python?学习开发

上面的内容就等价于下面的命令

cat?subprocess_demo.py?|grep?"公众号"?|awk?-F?':'?'{print?$2}'

与另一个命令交互

前面的所有示例都假定了有限的交互量。方法读取所有输出并等待子进程退出后返回。在程序运行时,还可以增量地对 Popen 实例使用的各个管道句柄进行读写。一个简单的 echo 程序演示了这种技术,该程序从标准输入读取数据并将其写入标准输出。
在下一个示例中,脚本 repeat.py 用作子进程。它从 stdin 读取值并将值写入 stdout,每次一行,直到没有更多输入为止。它还在启动和停止时向 stderr 写入一条消息,显示子进程的生存期。

#?文件:repeater.py
#?公众号:python?学习开发
import?sys

sys.stderr.write('repeater.py:?starting\n')
sys.stderr.flush()

while?True:
????next_line?=?sys.stdin.readline()
????sys.stderr.flush()
????if?not?next_line:
????????break
????sys.stdout.write(next_line)
????sys.stdout.flush()

sys.stderr.write('repeater.py:?exiting\n')
sys.stderr.flush()

下一个交互示例以不同的方式使用 Popen 实例拥有的 stdin 和 stdout 文件句柄.
在第一个例子中,将 0-4 依次被写入进程的 stdin,并且在每次写入之后读回下一行输出。 在第二个示例中,写入这五个数字,但是使用 communic()一次读取所有输出。

import?io
import?subprocess

print('One?line?at?a?time:')
proc?=?subprocess.Popen(
????'python3?repeater.py',
????shell=True,
????stdin=subprocess.PIPE,
????stdout=subprocess.PIPE,
)
stdin?=?io.TextIOWrapper(
????proc.stdin,
????encoding='utf-8',
????line_buffering=True,??#?send?data?on?newline
)
stdout?=?io.TextIOWrapper(
????proc.stdout,
????encoding='utf-8',
)
for?i?in?range(5):
????line?=?'{}\n'.format(i)
????stdin.write(line)
????output?=?stdout.readline()
????print(output.rstrip())
remainder?=?proc.communicate()[0].decode('utf-8')
print(remainder)

print()
print('All?output?at?once:')
proc?=?subprocess.Popen(
????'python3?repeater.py',
????shell=True,
????stdin=subprocess.PIPE,
????stdout=subprocess.PIPE,
)
stdin?=?io.TextIOWrapper(
????proc.stdin,
????encoding='utf-8',
)
for?i?in?range(5):
????line?=?f'{i}\n'
????stdin.write(line)
stdin.flush()

output?=?proc.communicate()[0].decode('utf-8')
print(output)

“repeater.py:exiting”出现在每个循环位置的不同点。

One?line?at?a?time:
repeater.py:?starting
0
1
2
3
4
repeater.py:?exiting


All?output?at?once:
repeater.py:?starting
repeater.py:?exiting
0
1
2
3
4

信号之间的进程

正在 os 模块中的进程管理示例包括使用 os.fork()和 os.kill()在进程之间发送信号的演示。
由于每个 Popen 实例都提供了一个带有子进程的进程 id 的 pid 属性,所以可以对子进程执行类似的操作。下一个例子结合了两个脚本。这个子进程为 USR 信号设置一个信号处理器。

#signal_child.py
import?os
import?signal
import?time
import?sys

pid?=?os.getpid()
received?=?False


def?signal_usr1(signum,?frame):
????"Callback?invoked?when?a?signal?is?received"
????global?received
????received?=?True
????print(f'CHILD?{pid:>6}:?Received?USR1')
????sys.stdout.flush()


print(f'CHILD?{pid:>6}:?Setting?up?signal?handler')
sys.stdout.flush()
signal.signal(signal.SIGUSR1,?signal_usr1)
print(f'CHILD?{pid:>6}:?Pausing?to?wait?for?signal')
sys.stdout.flush()
time.sleep(3)

if?not?received:
????print(f'CHILD?{pid:>6}:?Never?received?signal')

然后再写一个文件,此脚本作为父进程运行。 它启动 signal_child.py,然后发送 USR1 信号。

import?os
import?signal
import?subprocess
import?time
import?sys

proc?=?subprocess.Popen(['python3',?'signal_child.py'])
print('PARENT??????:?Pausing?before?sending?signal...')
sys.stdout.flush()
time.sleep(1)
print('PARENT??????:?Signaling?child')
sys.stdout.flush()
os.kill(proc.pid,?signal.SIGUSR1)

运行之后

PARENT??????:?Pausing?before?sending?signal...
CHILD??46573:?Setting?up?signal?handler
CHILD??46573:?Pausing?to?wait?for?signal
PARENT??????:?Signaling?child
CHILD??46573:?Received?USR1

进程组

如果子进程是由 Popen 创建的进程产生的,那些子进程将不会收到发送给父进程的任何信号。 当 Popen 使用 shell 参数时,很难通过发送 SIGINT 或 SIGTERM 来使 shell 中启动的命令终止。
若要在不知道进程 id 的情况下向后代发送信号,请使用进程组将子进程关联起来,以便将它们一起发送信号。使用 os.setpgrp()创建进程组,将进程组 id 设置为当前进程的进程 id。

import?os
import?signal
import?subprocess
import?tempfile
import?time
import?sys

script?=?'''#!/bin/sh
echo?"Shell?script?in?process?$$"
set?-x
python3?signal_child.py
'''

script_file?=?tempfile.NamedTemporaryFile('wt')
script_file.write(script)
script_file.flush()

proc?=?subprocess.Popen(['sh',?script_file.name])
print('PARENT??????:?Pausing?before?signaling?{}...'.format(
????proc.pid))
sys.stdout.flush()
time.sleep(1)
print('PARENT??????:?Signaling?child?{}'.format(proc.pid))
sys.stdout.flush()
os.kill(proc.pid,?signal.SIGUSR1)
time.sleep(3)

输出

PARENT??????:?Pausing?before?signaling?46600...
Shell?script?in?process?46600
+?python3?signal_child.py
CHILD??46601:?Setting?up?signal?handler
CHILD??46601:?Pausing?to?wait?for?signal
PARENT??????:?Signaling?child?46600
CHILD??46601:?Never?received?signal

用于发送信号的 pid 与等待信号的 shell 脚本的子脚本的 pid 不匹配,因为在本例中有三个独立的进程在交互
1.程序子进程向父 shell.py 发送信号
2.shell 进程运行主 python 程序创建的脚本
3.signal_child.py 进程。
如果想在不知道其进程 ID 的情况下向后代发送信号,可以使用进程组来关联子进程,以便它们可以一起发出信号。可以使用 os.setpgrp()创建进程组,然后将进程组 id 设置为当前进程的进程 id。这样所有子进程都从父进程继承它们的进程组,因为它只能在 Popen 及其后代创建的 shell 中设置,所以不应该在创建 Popen 的同一进程中调用 os.setpgrp()。更改之后的代码如下:

import?os
import?signal
import?subprocess
import?tempfile
import?time
import?sys


def?show_setting_prgrp():
????print('Calling?os.setpgrp()?from?{}'.format(os.getpid()))
????os.setpgrp()
????print('Process?group?is?now?{}'.format(os.getpgrp()))
????sys.stdout.flush()


script?=?'''#!/bin/sh
echo?"Shell?script?in?process?$$"
set?-x
python3?signal_child.py
'''

script_file?=?tempfile.NamedTemporaryFile('wt')
script_file.write(script)
script_file.flush()

proc?=?subprocess.Popen(
????['sh',?script_file.name],
????preexec_fn=show_setting_prgrp,
)
print('PARENT??????:?Pausing?before?signaling?{}...'.format(
????proc.pid))
sys.stdout.flush()
time.sleep(1)
print('PARENT??????:?Signaling?process?group?{}'.format(
????proc.pid))
sys.stdout.flush()
os.killpg(proc.pid,?signal.SIGUSR1)
time.sleep(3)

输出结果

+?python3?signal_child.py
Calling?os.setpgrp()?from?46618
Process?group?is?now?46618
PARENT??????:?Pausing?before?signaling?46618...
Shell?script?in?process?46618
CHILD??46619:?Setting?up?signal?handler
CHILD??46619:?Pausing?to?wait?for?signal
PARENT??????:?Signaling?process?group?46618
CHILD??46619:?Received?USR1

事件发生的顺序如下:
1.父程序实例化 Popen。
2.Popen 实例派生了一个新的进程。
3.新进程运行 os.setpgrp()。
4.新进程会运行 exec()启动 shell。
5.shell 会运行 shell 脚本
6.shell 脚本再次 fork,该进程执行 Python。
7.python 运行脚本 signal_child.py
8.父程序使用 shell 的 pid 向进程组发出信号。
9.shell 和 Python 进程接收信号
10.运行 signal child.py 的 Python 进程调用信号处理程序。

参考资料

https://docs.python.org/3.7/library/subprocess.html

推荐↓↓↓
Python编程
上一篇:深入了解?Python上下文管理器模块--contextlib 下一篇:新手必会的pycharm使用技巧