subprocess Python执行系统命令最优选模块

简介

subprocess 是 Python 中执行操作系统级别的命令的模块，所谓系级级别的命令就是如ls /etc/user ifconfig 等和操作系统有关的命令。
subprocess 创建子进程来执行相关命令，并连接它们的输入、输出和错误管道，获取它们的返回状态。

subprocess 来源

Subprocess模块开发之前，标准库已有大量用于执行系统级别命令的的方法，如os.system、os.spawn等。但是略显混乱使开发者难以抉择，因此subprocess的目的是打造一个统一模块来替换之前执行系统界别命令的方法。
所以推荐使用subprocess替代了一些老的方法，比如：os.system、os.spawn*等。

模块常用函数

函数清单总览

Subprocess 模块推荐使用run方法替换低版本方法，如果想要更加精细的控制可以使用Popen方法。所以本教程中重点介绍run和Popen方法。

subprocess.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, 
    **other_popen_kwargs
)

简单使用

执行简单shell命令
默认情况下，子进程会继承父进程的设置，会将输出显示在终端上

import subprocess

res = subprocess.run("ls -al /home/ljk/Videos", shell=True)
>>>
(ymir) ➜  subprocess_demo python3 subprocess_demo.py
总用量 96
drwxr-xr-x  3 ljk ljk  4096 4月  11 11:04  .
drwxr-x--- 62 ljk ljk  4096 7月   6 13:40  ..
-rw-r--r--  1 ljk ljk 84176 4月  11 11:04  346e30f4-9119-11eb-bb4a-4a238cf0c417.mp4
lrwxrwxrwx  1 ljk ljk    36 10月 21  2022  dde-introduction.mp4 -> /usr/share/dde-introduction/demo.mp4
drwxr-xr-x  2 ljk ljk  4096 4月  11 18:26 'Screen Recordings'

如果命令没有输出则不会打印输出信息

获取状态码
returncode 是subprocess的返回码

import subprocess

res = subprocess.run("ls -al /home/ljk/Videos", shell=True)

print("returncode:", res.returncode)
>>>
总用量 96
drwxr-xr-x  3 ljk ljk  4096 7月   6 13:41  .
drwxr-x--- 62 ljk ljk  4096 7月   6 13:47  ..
-rw-r--r--  1 ljk ljk 84176 4月  11 11:04  346e30f4-9119-11eb-bb4a-4a238cf0c417.mp4
-rw-r--r--  1 ljk ljk     0 7月   6 13:41  a.txt
lrwxrwxrwx  1 ljk ljk    36 10月 21  2022  dde-introduction.mp4 -> /usr/share/dde-introduction/demo.mp4
drwxr-xr-x  2 ljk ljk  4096 4月  11 18:26 'Screen Recordings'
0

参数介绍

args：要执行的命令，可以是字符串形式或由命令及其参数组成的列表。例如，['ls', '-l'] 或 'ls -l'。
input：允许将字节或字符串传递给子进程的标准输入(stdin)。
stdin：子进程的标准输入。默认为None，可以是以下三个参数：

subprocess.PIPE 创建一个管道，允许与子进程进行通信
subprocess.DEVNULL 特殊的文件对象，可以将其用于丢弃子进程的输出
一个打开的文件对象，将内容写入文件

stdout: 同 stdin
stderr: 同 stdin
capture_output ：这个参数控制是否捕获外部命令的标准输出(stdout)和标准错误(stderr)。如果将其设置为True，run()函数将返回一个CompletedProcess对象，该对象具有stdout和stderr属性，分别存储了命令的标准输出和标准错误输出。如果设置为False，标准输出和标准错误将被发送到控制台。默认为False。
shell：指定是否通过shell来执行命令。如果为True，命令将在shell中执行；如果为False，则直接调用可执行文件。默认为False。
cwd：设置子进程的工作目录。默认为None，表示使用当前工作目录。
timeout：设置子进程的超时时间（秒）。如果子进程在指定的时间内没有运行完成，则会引发TimeoutExpired异常。
check：设置是否检查子进程的返回码。如果为True，并且子进程的返回码不为零，则会引发CalledProcessError异常。
encoding：该参数指定输出结果的字符编码。默认情况下，它是None，表示使用原始的字节数据。如果提供了有效的编码名称(如"utf-8"、"gbk"等)，run()函数将自动将输出解码为字符串。
errors：该参数定义在解码输出时如何处理编码错误。它与Python的str.decode()函数的相同参数含义相匹配。常用的值包括"strict" (默认值，抛出异常)、"ignore" (忽略错误字符) 和 "replace" (用替代字符代替错误字符)。
text：指定是否将输出结果以文本形式返回。如果为True，则结果以字符串形式返回，同时input或者stdin参数也需要输入String；如果为False，则返回字节流。默认为False。
env：该参数允许您为子进程指定环境变量。它可以接受一个字典类型的对象，其中键是环境变量的名称，值是环境变量的值。通过设置env参数，您可以在子进程中使用特定的环境变量。
universal_newlines：该参数影响的是输入与输出的数据格式，比如它的值默认为False，此时stdout和stderr的输出是字节序列；当该参数的值设置为True时，stdout和stderr的输出是字符串。

args 执行命令

args传入的是要执行的系统命令，可以接收两种方法：字符串或列表。

使用列表形式subprocess.run(["ls", "-al"])
使用字符串形式 subprocess.run("ls -al", shell=True)。使用字符串形式必须设置参数shell=True

import subprocess

subprocess.run(["ls", "-al", "/Users/ljk/Documents/code/daily_dev"])

subprocess.run("ls -al /Users/ljk/Documents/code/daily_dev", shell=True)

>>>
➜  subprocess_demo python3 subprocess_demo.py
total 0
drwxr-xr-x   5 ljk  staff  160  7 11 22:27 .
drwxr-xr-x@ 18 ljk  staff  576  7  3 22:11 ..
drwxr-xr-x   3 ljk  staff   96  6 24 18:28 docker_dev
drwxr-xr-x   3 ljk  staff   96  6 17 22:08 requests_demo
drwxr-xr-x   4 ljk  staff  128  7 11 22:30 subprocess_demo
total 0
drwxr-xr-x   5 ljk  staff  160  7 11 22:27 .
drwxr-xr-x@ 18 ljk  staff  576  7  3 22:11 ..
drwxr-xr-x   3 ljk  staff   96  6 24 18:28 docker_dev
drwxr-xr-x   3 ljk  staff   96  6 17 22:08 requests_demo
drwxr-xr-x   4 ljk  staff  128  7 11 22:30 subprocess_demo

默认情况下，命令的输出是直接打印到控制台上的。

stdin、stdout、sterr 设置命令输出输入的对象

这三个值是用来设置标准输入，标准输出，标准错误的。默认情况下，子进程会继承父进程的设置，会将输出显示在控制台上，除此之外也可以设置成如下三个值：

subprocess.PIPE 创建一个管道，允许与子进程进行通信
subprocess.DEVNULL 特殊的文件对象，可以将其用于丢弃子进程的输出
一个打开的文件对象，将内容写入文件
以studout为例子，验证这三个输出选项。

将命令输出保存到管道

import subprocess

res = subprocess.run(["ls", "-al", "/Users/ljk/Documents/code/daily_dev"], stdout=subprocess.PIPE)

print(res.returncode)
print(res.stdout)
>>>
0
b'total 0\ndrwxr-xr-x   5 ljk  staff  160  7 11 22:27 .\ndrwxr-xr-x@ 18 ljk  staff  576  7  3 22:11 ..\ndrwxr-xr-x   3 ljk  staff   96  6 24 18:28 docker_dev\ndrwxr-xr-x   3 ljk  staff   96  6 17 22:08 requests_demo\ndrwxr-xr-x   4 ljk  staff  128  7 11 22:44 subprocess_demo\n'

命令输出不再打印到控制台上，而是保存到对象里，通过对象的stdout获取到。此时命令输出结果是字节串格式的。可以通过设置text=True，将命令输出以文本形式保存。

import subprocess

res = subprocess.run(["ls", "-al", "/Users/ljk/Documents/code/daily_dev"], stdout=subprocess.PIPE, text=True)

print(res.returncode)
print(res.stdout)
>>>
0
total 0
drwxr-xr-x   5 ljk  staff  160  7 11 22:27 .
drwxr-xr-x@ 18 ljk  staff  576  7  3 22:11 ..
drwxr-xr-x   3 ljk  staff   96  6 24 18:28 docker_dev
drwxr-xr-x   3 ljk  staff   96  6 17 22:08 requests_demo
drwxr-xr-x   4 ljk  staff  128  7 11 22:48 subprocess_demo

命令输出保存到文件中
可以将命令的输出保存到一个文件中，stdout传入一个打开的文件对象即可。

import subprocess

with open("a.txt", "a+") as f:
    res = subprocess.run(["ls", "-al", "/Users/ljk/Documents/code/daily_dev"], stdout=f, text=True)
    print(res.returncode)
    print(res.stdout)
    
>>>
0
None

此时在目录下生成了a.txt文件，里面保存的是命令的输出结果

capture_output 捕获控制台输出

捕获命令输出。默认为false，所有的命令输出都打印到控制台。设置为true，所有命令的输出都被捕获保存到返回对象中。

import subprocess

res = subprocess.run("ls -al /Users/ljk/Documents/code/daily_dev", shell=True, capture_output=True)
print(res.returncode)
print(res.stdout)
>>>
0
b'total 0\ndrwxr-xr-x   5 ljk  staff  160  7 11 22:27 .\ndrwxr-xr-x@ 18 ljk  staff  576  7  3 22:11 ..\ndrwxr-xr-x   3 ljk  staff   96  6 24 18:28 docker_dev\ndrwxr-xr-x   3 ljk  staff   96  6 17 22:08 requests_demo\ndrwxr-xr-x   5 ljk  staff  160  7 13 20:38 subprocess_demo\n'

cwd 设置命令执行的目录

设置子进程的工作目录。默认为None，表示使用当前工作目录

import subprocess

res = subprocess.run("pwd", shell=True, cwd="/Users/ljk/Documents/code/")
print(res.returncode)

/Users/ljk/Documents/code
0

如果脚本需要在特定的目录中执行，可以设置该参数

timeout 设置命令超执行时时间

当一些命令有时间上的要求，可以设置命令执行的超时时间。如果命令在指定的时间内没有运行完成，则会引发TimeoutExpired异常。

import subprocess

res = subprocess.run("sleep 10 && ls", shell=True, timeout=5)
print(res.returncode)
>>>
Traceback (most recent call last):
  File "/Users/ljk/Documents/code/daily_dev/subprocess_demo/subprocess_demo.py", line 22, in <module>
    res = subprocess.run("sleep 10 && ls", shell=True, timeout=5)
  File "/Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.9/lib/python3.9/subprocess.py", line 507, in run
    stdout, stderr = process.communicate(input, timeout=timeout)
  File "/Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.9/lib/python3.9/subprocess.py", line 1134, in communicate
    stdout, stderr = self._communicate(input, endtime, timeout)
  File "/Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.9/lib/python3.9/subprocess.py", line 2005, in _communicate
    self.wait(timeout=self._remaining_time(endtime))
  File "/Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.9/lib/python3.9/subprocess.py", line 1189, in wait
    return self._wait(timeout=timeout)
  File "/Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.9/lib/python3.9/subprocess.py", line 1909, in _wait
    raise TimeoutExpired(self.args, timeout)
subprocess.TimeoutExpired: Command 'sleep 10 && ls' timed out after 4.999915208999999 seconds

执行的命令是先睡眠10s，然后执行ls。设置的超时时间是5秒，所以执行的第5s就抛出timeout错误。

check 返回码非1抛出错误

检查子进程的返回码。如果为True，并且子进程的返回码不为零，则会引发CalledProcessError异常。以下代码做了一组对比，ls一个不存在目录，设置check=True的会抛出异常。

res = subprocess.run("ls no_exsit.txt", shell=True)
print(res.returncode)
>>>
ls: no_exsit.txt: No such file or directory
1

res = subprocess.run("ls no_exsit.txt", shell=True, check=True)
print(res.returncode)
>>>
ls: no_exsit.txt: No such file or directory
Traceback (most recent call last):
  File "/Users/ljk/Documents/code/daily_dev/subprocess_demo/subprocess_demo.py", line 25, in <module>
    res = subprocess.run("ls no_exsit.txt", shell=True, check=True)
  File "/Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.9/lib/python3.9/subprocess.py", line 528, in run
    raise CalledProcessError(retcode, process.args,
subprocess.CalledProcessError: Command 'ls no_exsit.txt' returned non-zero exit status 1.

encoding、text 设置输出结果的格式

encoding 用于设置命令输出的编码格式。默认情况下，它是None，表示使用原始的字节数据。如果提供了有效的编码名称，如"utf-8"、"gbk"，将自动将输出解码为字符串。示例演示encoding=True

# 原始输出
res = subprocess.run("ls -al /Users/ljk/Documents/code/daily_dev", shell=True, capture_output=True)
print(res.returncode)
print(res.stdout)
>>>
0
b'total 0\ndrwxr-xr-x   5 ljk  staff  160  7 11 22:27 .\ndrwxr-xr-x@ 18 ljk  staff  576  7  3 22:11 ..\ndrwxr-xr-x   3 ljk  staff   96  6 24 18:28 docker_dev\ndrwxr-xr-x   3 ljk  staff   96  6 17 22:08 requests_demo\ndrwxr-xr-x   5 ljk  staff  160  7 13 21:07 subprocess_demo\n'

# 设置encoding="utf-8"
res = subprocess.run("ls -al /Users/ljk/Documents/code/daily_dev", shell=True, capture_output=True, encoding="utf-8")
print(res.returncode)
print(res.stdout)

>>>
0
total 0
drwxr-xr-x   5 ljk  staff  160  7 11 22:27 .
drwxr-xr-x@ 18 ljk  staff  576  7  3 22:11 ..
drwxr-xr-x   3 ljk  staff   96  6 24 18:28 docker_dev
drwxr-xr-x   3 ljk  staff   96  6 17 22:08 requests_demo
drwxr-xr-x   5 ljk  staff  160  7 13 21:07 subprocess_demo

text 参数是用于设置命令输出的格式。命令输出默认是字节串，text=True表示输出格式为字符串。和encoding=True 基本等价。

# 原始输出
res = subprocess.run("ls -al /Users/ljk/Documents/code/daily_dev", shell=True, capture_output=True)
print(res.returncode)
print(res.stdout)
>>>
0
b'total 0\ndrwxr-xr-x   5 ljk  staff  160  7 11 22:27 .\ndrwxr-xr-x@ 18 ljk  staff  576  7  3 22:11 ..\ndrwxr-xr-x   3 ljk  staff   96  6 24 18:28 docker_dev\ndrwxr-xr-x   3 ljk  staff   96  6 17 22:08 requests_demo\ndrwxr-xr-x   5 ljk  staff  160  7 13 21:10 subprocess_demo\n'

# 设置text=True
res = subprocess.run("ls -al /Users/ljk/Documents/code/daily_dev", shell=True, capture_output=True, text=True)
print(res.returncode)
print(res.stdout)
>>>
0
total 0
drwxr-xr-x   5 ljk  staff  160  7 11 22:27 .
drwxr-xr-x@ 18 ljk  staff  576  7  3 22:11 ..
drwxr-xr-x   3 ljk  staff   96  6 24 18:28 docker_dev
drwxr-xr-x   3 ljk  staff   96  6 17 22:08 requests_demo
drwxr-xr-x   5 ljk  staff  160  7 13 21:10 subprocess_demo

返回对象

subprocess.run()函数返回值是一个CompletedProcess类的实例，subprocess.completedPorcess类是Python 3.5以上才存在的。它表示的是一个已结束进程的状态信息，它所包含的属性和方法如下：
args：用于加载该进程的参数，这可能是一个列表或一个字符串。
returncode：子进程的退出状态码。通常情况下，退出状态码为0则表示进程成功运行了；一个负值-N表示这个子进程被信号N终止了。
stdout：从子进程捕获的stdout。这通常是一个字节串。如果设置了encoding或text参数，返回就是字符串。
stderr：从子进程捕获的stderr。它的值与stdout一样，是一个字节序列或一个字符串。如果stderr没有被捕获的话，它的值就为None。
check_returncode()：如果returncode是一个非0值，则该方法会抛出一个CalledProcessError异常。

示例：

import subprocess

res = subprocess.run("ls -al /home/ljk/Videos", shell=True)


print("args:", res.args)
print("returncode:", res.returncode)
print("stdout:", res.stdout)
print("stderr:", res.stderr)
print("returncode():", res.check_returncode())

>>>
➜ subprocess_demo python3 subprocess_demo.py
总用量 96
drwxr-xr-x  3 ljk ljk  4096 7月   6 13:41  .
drwxr-x--- 62 ljk ljk  4096 7月   6 13:47  ..
-rw-r--r--  1 ljk ljk 84176 4月  11 11:04  346e30f4-9119-11eb-bb4a-4a238cf0c417.mp4
-rw-r--r--  1 ljk ljk     0 7月   6 13:41  a.txt
lrwxrwxrwx  1 ljk ljk    36 10月 21  2022  dde-introduction.mp4 -> /usr/share/dde-introduction/demo.mp4
drwxr-xr-x  2 ljk ljk  4096 4月  11 18:26 'Screen Recordings'
args: ls -al /home/ljk/Videos
returncode: 0
stdout: None
stderr: None
returncode(): None

subprocess.Popen()

popen是一个功能更强大的方法，而run是它的一个简化版。如果run函数不能满足功能的要求，可以尝试功能更多的popen方法。
除了方法的多少之外，run和popen最大的区别在于：run方法是阻塞调用，会一直等待命令执行完成或失败；popen是非阻塞调用，执行之后立刻返回，结果通过返回对象获取。

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, 
    pipesize=- 1, 
    process_group=None
)

简单使用

和run一样执行命令

import subprocess

subprocess.Popen("ls -al /Users/ljk/Documents/code/daily_dev", shell=True)

>>>>
None
total 0
drwxr-xr-x   5 ljk  staff  160  7 11 22:27 .
drwxr-xr-x@ 18 ljk  staff  576  7  3 22:11 ..
drwxr-xr-x   3 ljk  staff   96  6 24 18:28 docker_dev
drwxr-xr-x   3 ljk  staff   96  6 17 22:08 requests_demo
drwxr-xr-x   5 ljk  staff  160  7 13 21:32 subprocess_demo

执行阻塞命令

import subprocess

res = subprocess.Popen("sleep 10 && ls -al", shell=True)
print(res)
>>>
<Popen: returncode: None args: 'sleep 10 && ls -al'>

遇到阻塞命令也会直接返回，返回是一个对象。可以通过对象获取命令执行的结果。

参数介绍

注意：因为run是popen的一个简化版本，所以run拥有的函数popen也拥有。这里就不再重复说明了。

bufsize：定义了子进程的缓冲大小。可选参数，默认为-1，表示使用系统默认的缓冲大小。
executable：指定要执行的程序路径。如果未提供该值，则通过PATH环境变量来确定可执行文件的位置。
preexec_fn：指定在子进程启动之前将要执行的函数。该函数将在fork()调用成功，但exec()调用之前被调用。
close_fds：指定是否关闭所有文件描述符。默认为False。
start_new_session（仅 POSIX）：如果该参数设置为True，则在启动子进程时创建一个新的进程会话。默认为False。
pass_fds（仅 POSIX）：通过这个参数传递一个文件描述符集合，这些文件描述符将保持打开状态并传递给子进程。默认为None。
startupinfo：一个可选的subprocess.STARTUPINFO对象，用于指定子进程的启动信息，如窗口大小、窗口标题等。默认为None。
creationflags：用于指定子进程的创建标志，控制子进程的各种行为。可以使用subprocess.CREATE_NEW_CONSOLE、subprocess.CREATE_NEW_PROCESS_GROUP等常量进行设置。默认为0。
restore_signals（仅 POSIX）：用于确定是否在子进程中恢复信号处理程序的默认行为。默认为True。
group（仅 POSIX）: 如果 group 不为 None，则 setregid() 系统调用将于子进程执行之前在下级进程中进行。如果所提供的值为一个字符串，将通过 grp.getgrnam() 来查找它，并将使用 gr_gid 中的值。如果该值为一个整数，它将被原样传递。（POSIX 专属）
extra_groups（仅 POSIX）: 如果 extra_groups 不为 None，则 setgroups() 系统调用将于子进程之前在下级进程中进行。在 extra_groups 中提供的字符串将通过 grp.getgrnam() 来查找，并将使用 gr_gid 中的值。整数值将被原样传递。
user（仅 POSIX）: 如果 user 不为 None，则 setreuid() 系统调用将于子进程执行之前在下级进程中进行。如果所提供的值为一个字符串，将通过 pwd.getpwnam() 来查找它，并将使用 pw_uid 中的值。如果该值为一个整数，它将被原样传递。（POSIX 专属）

Popen类的方法与参数介绍

communicate(input=None, timeout=None): 与子进程进行交互，发送输入并获取输出结果。可以在参数input中指定要发送给子进程的输入内容。该方法会阻塞当前进程，直到子进程完成并返回输出结果。可选的timeout参数用于设置超时时间。
poll(): 检查子进程是否已经退出，如果已退出则返回退出状态码，否则返回None。
wait(timeout=None): 等待子进程完成并返回退出状态码。可选的timeout参数用于设置超时时间。
terminate(): 向子进程发送终止信号。这通常是优雅地终止子进程。
kill(): 强制终止子进程。
send_signal(signal): 向子进程发送信号，其中signal参数表示要发送的信号类型，如SIGINT、SIGTERM等。

communicate 获取命令输出

发送输入并获取输出结果。可以在参数input中指定要发送给子进程的输入内容。该方法会阻塞当前进程，直到子进程完成并返回输出结果。函数返回一个元组： (stdoutdata , stderrdata )

import subprocess

res = subprocess.Popen("sleep 3 && ls -al", shell=True)
print(res.communicate())
>>>
total 24
drwxr-xr-x  5 ljk  staff   160  7 13 21:40 .
drwxr-xr-x  5 ljk  staff   160  7 11 22:27 ..
-rw-r--r--  1 ljk  staff   269  7 11 22:50 a.txt
-rwxrwxrwx  1 ljk  staff    42  7 11 22:29 ls_demo.sh
-rw-r--r--  1 ljk  staff  1069  7 13 21:40 subprocess_demo.py
(None, None)

该方法和run函数行为一致，将非阻塞调用变成阻塞调用。
subprocess.Popen().communicate() 等价于 subprocess.run()

poll 检查子进程

Poll 检查子进程是否已经退出，如果已退出则返回退出状态码，否则返回None。

import time

res = subprocess.Popen("sleep 3 && ls -al", shell=True)
print(res.poll())
time.sleep(4)
print(res.poll())
>>>>

None
total 24
drwxr-xr-x  5 ljk  staff   160  7 13 21:39 .
drwxr-xr-x  5 ljk  staff   160  7 11 22:27 ..
-rw-r--r--  1 ljk  staff   269  7 11 22:50 a.txt
-rwxrwxrwx  1 ljk  staff    42  7 11 22:29 ls_demo.sh
-rw-r--r--  1 ljk  staff  1097  7 13 21:39 subprocess_demo.py
0

在执行命令之后立刻用poll检查发现返回None，此时因为子进程还没有退出。程序睡眠4s之后命令已经退出，再次执行poll返回了状态码。在两次打印中间是命令的标准输出。

检查命令执行状态并获取返回值

res = subprocess.Popen("sleep 3 && ls -al", shell=True, stdout=subprocess.PIPE, encoding="utf-8")
while res.poll() is None:
    time.sleep(0.5)
    print("命令还在执行中...")
print("命令执行完成，获取结果：")
print(res.communicate())

wait 用于等待命令执行完成

等待子进程完成并返回退出状态码。可选的timeout参数用于设置超时时间。

# 等待，不设置超时
import subprocess

res = subprocess.Popen("sleep 3 && ls -al", shell=True)
print(res.wait())

>>>
total 24
drwxr-xr-x  5 ljk  staff   160  7 13 22:04 .
drwxr-xr-x  5 ljk  staff   160  7 11 22:27 ..
-rw-r--r--  1 ljk  staff   269  7 11 22:50 a.txt
-rwxrwxrwx  1 ljk  staff    42  7 11 22:29 ls_demo.sh
-rw-r--r--  1 ljk  staff  1071  7 13 22:04 subprocess_demo.py
0

# 等待，设置超时，报错
res = subprocess.Popen("sleep 6 && ls -al", shell=True)
print(res.wait(timeout=5))

>>>
Traceback (most recent call last):
  File "/Users/ljk/Documents/code/daily_dev/subprocess_demo/subprocess_demo.py", line 41, in <module>
    print(res.wait(timeout=5))
  File "/Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.9/lib/python3.9/subprocess.py", line 1189, in wait
    return self._wait(timeout=timeout)
  File "/Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.9/lib/python3.9/subprocess.py", line 1909, in _wait
    raise TimeoutExpired(self.args, timeout)
subprocess.TimeoutExpired: Command 'sleep 6 && ls -al' timed out after 5 seconds

drwxr-xr-x  5 ljk  staff   160  7 13 22:04 .
drwxr-xr-x  5 ljk  staff   160  7 11 22:27 ..
-rw-r--r--  1 ljk  staff   269  7 11 22:50 a.txt
-rwxrwxrwx  1 ljk  staff    42  7 11 22:29 ls_demo.sh
-rw-r--r--  1 ljk  staff  1071  7 13 22:04 subprocess_demo.py

wait 设置了超时，在指定时间之内没有执行完成会抛出异常，但是命令还是会在后端继续执行，没有停止

terminate 优雅的终止执行的命令

Terminate 可以终止一个还没有执行完成的命令。wait设置超时之后虽然会抛出异常，但是并不会终止命令。而terminate就可以优雅的终止命令。

import subprocess

res = subprocess.Popen("sleep 3 && ls -al", shell=True)
print(res.poll())
res.terminate()
>>>
None

如果没有终止会打印输出信息，而终止之后就不会再打印出来了。所谓优雅可能是停止命令之前会关闭打开的文件，管道，套接字等。

kill 强制终止执行的命令

使用kill可以强制将执行的命令杀死，类似于linux系统中的kill命令。kill不会关闭已经打开的文件句柄等。

import subprocess

res = subprocess.Popen("sleep 3 && ls -al", shell=True)
print(res.poll())
res.kill()

异常捕获

subprocess 会抛出一些异常，自带的异常捕获模块可以完成相关异常的捕获

TimeoutExpired

异常类型：class subprocess.TimeoutExpired(cmd, timeout, output=None)
当子进程执行时间超过指定的超时时间时引发。
属性：

cmd：执行的命令。
timeout：设定的超时时间。
output：子进程输出的内容。

CalledProcessError

异常类型：class subprocess.CalledProcessError(returncode, cmd, output=None, stderr=None)
在使用 check_output() 或 check_call() 函数执行外部命令并返回非零退出码时引发。
属性：

returncode：子进程的返回码。
cmd：已执行的命令。
output：标准输出的内容（如果没有重定向则为 None）
stderr：标准错误的内容（如果没有重定向则为 None）

使用示例：

import subprocess

try:
    res = subprocess.run("ls no_exsit.txt", shell=True, check=True)
except subprocess.CalledProcessError as e:
    print("returncode:", e.returncode)
    print("cmd:", e.cmd)
    print("output:", e.output)
    print("stderr:", e.stderr
    
>>>
ls: 无法访问'no_exsit.txt': 没有那个文件或目录
returncode: 2
cmd: ls no_exsit.txt
output: None
stderr: None

subprocess.SubprocessError

这是其他subprocess常类的基类，可以用于捕获所有与子进程相关的异常。

旧函数简介

subprocess.call()
函数执行给定的命令，并等待其完成。它返回命令的退出码。
示例代码：

import subprocess

return_code = subprocess.call(["ls", "-l"])
print(f"Command returned with exit code: {return_code}")

subprocess.check_call()
check_call() 函数也执行给定的命令，但与 call() 不同的是，如果命令返回非零的退出码，则会引发 CalledProcessError 异常。

示例代码：

import subprocess

subprocess.check_call(["ls", "-l"])
print("Command executed successfully")

subprocess.getoutput()
getoutput() 函数执行给定的命令，并返回其输出作为字符串。
示例代码：

import subprocess

output = subprocess.getoutput("echo Hello, subprocess!")
print(output)

subprocess.getstatusoutput()
getstatusoutput() 函数执行给定的命令，并返回一个元组，包含命令的退出状态码和输出结果的字符串。
示例代码：

import subprocess

status, output = subprocess.getstatusoutput("ls -l")
print(f"Exit status: {status}")
print(f"Output: {output}")

subprocess.check_output()
check_output() 函数执行给定的命令，并返回其输出结果作为字节字符串。
示例代码：

import subprocess

output = subprocess.check_output(["ls", "-l"])
print(output.decode("utf-8"))

subprocess 和 os 模块比较

与os模块对比而言，subprocess模块具有以下这些优势：

更丰富的功能
subprocess模块提供了更多的方法和选项来执行子进程，并与其进行交互。例如，可以捕获子进程的输出、发送输入数据、设置超时时间等。
更强的灵活性
subprocess模块允许您以多种不同的方式执行子进程，包括使用管道、重定向输入输出、执行shell命令等。这使得您能够更灵活地控制和处理子进程的输入输出。
更好的安全性
subprocess模块提供了更严格的参数处理机制，可以帮助避免常见的安全问题，如命令注入攻击。它支持传递参数列表而不是字符串，从而减少了潜在的安全漏洞。

因此，当执行复杂的子进程操作、需要更多控制权和灵活性、以及考虑到安全性时，优先选择subprocess模块是更好的选择。而对于简单的命令执行需求或与操作系统相关的功能，os模块可能更加适合。

posted @ 2023-07-17 09:00 金色旭光阅读(3703) 评论(0) 编辑收藏举报

刷新页面返回顶部

金色旭光

subprocess Python执行系统命令最优选模块

简介

subprocess 来源

模块常用函数

函数清单总览

subprocess.run()

参数介绍

args 执行命令

stdin、stdout、sterr 设置命令输出输入的对象

capture_output 捕获控制台输出

cwd 设置命令执行的目录

timeout 设置命令超执行时时间

check 返回码非1抛出错误

encoding、text 设置输出结果的格式

返回对象

subprocess.Popen()

简单使用

参数介绍

Popen类的方法与参数介绍

communicate 获取命令输出

poll 检查子进程

检查命令执行状态并获取返回值

wait 用于等待命令执行完成

terminate 优雅的终止执行的命令

kill 强制终止执行的命令

异常捕获

TimeoutExpired

CalledProcessError

subprocess.SubprocessError

旧函数简介

subprocess 和 os 模块比较

公告