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

引用文章链接:https://www.cnblogs.com/goldsunshine/p/17558075.html
引用文章链接
subprocess 是 Python 中执行操作系统级别的命令的模块，所谓系级级别的命令就是如ls /etc/user ifconfig 等和操作系统有关的命令。
subprocess 创建子进程来执行相关命令，并连接它们的输入、输出和错误管道，获取它们的返回状态。

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

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

函数签名

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文件，里面保存的是命令的输出结果
image

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

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 专属）

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
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 会抛出一些异常，自带的异常捕获模块可以完成相关异常的捕获

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

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

异常类型：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常类的基类，可以用于捕获所有与子进程相关的异常。

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

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

更丰富的功能
subprocess模块提供了更多的方法和选项来执行子进程，并与其进行交互。例如，可以捕获子进程的输出、发送输入数据、设置超时时间等。
更强的灵活性
subprocess模块允许您以多种不同的方式执行子进程，包括使用管道、重定向输入输出、执行shell命令等。这使得您能够更灵活地控制和处理子进程的输入输出。
更好的安全性
subprocess模块提供了更严格的参数处理机制，可以帮助避免常见的安全问题，如命令注入攻击。它支持传递参数列表而不是字符串，从而减少了潜在的安全漏洞。
因此，当执行复杂的子进程操作、需要更多控制权和灵活性、以及考虑到安全性时，优先选择subprocess模块是更好的选择。而对于简单的命令执行需求或与操作系统相关的功能，os模块可能更加适合。