Python 调用系统命令的模块 Subprocess

Python 调用系统命令的模块 Subprocess

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

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