subprocess

Python 的 subprocess 模块用于创建新进程、执行外部命令或程序，并能与这些进程的输入/输出/错误流交互，获取其执行结果（如返回码、输出内容）。它是 Python 中替代旧有模块（如 os.system、os.popen）的推荐方案，提供了更灵活、安全的进程管理能力。

一、核心功能与基本概念

subprocess 模块的核心是启动外部进程（如系统命令 ls/dir、可执行文件 exe、其他脚本 bash/python 等），并通过以下方式与进程交互：

向进程发送输入（stdin）。
捕获进程的输出（stdout）和错误信息（stderr）。
获取进程的退出码（returncode），判断执行是否成功（通常 0 表示成功，非 0 表示失败）。

二、核心函数：`subprocess.run()`（推荐）

Python 3.5+ 引入 subprocess.run() 作为主要函数，统一了进程创建和管理的接口，功能覆盖了旧有函数（如 call、check_call），推荐优先使用。

函数签名

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

关键参数说明

参数	功能描述
`args`	要执行的命令（必需），可以是字符串（如 `ls -l`）或列表（如 `["ls", "-l"]`）。推荐列表形式（避免 shell 注入风险）。
`shell`	是否通过 shell 执行命令（默认 `False`）。`shell=True` 时可使用 shell 特性（如管道 `\|`、通配符 `*`），但有安全风险。
`stdout`/`stderr`	控制输出/错误的处理方式： - `None`（默认）：输出到当前进程的终端（与脚本共享 stdout/stderr）。 - `subprocess.PIPE`：捕获输出到管道（可通过 `result.stdout` 获取）。 - `subprocess.DEVNULL`：忽略输出（丢弃）。 - 文件名或文件对象：输出重定向到文件。
`text`（`universal_newlines`）	若为 `True`，则输出/输入以字符串（`str`）形式处理（默认 `False`，返回字节 `bytes`）。等价于 `encoding="utf-8"` 的简化设置。
`check`	若为 `True`，当命令退出码非 `0` 时，会抛出 `subprocess.CalledProcessError` 异常（方便错误处理）。
`cwd`	设置子进程的工作目录（默认使用当前进程的工作目录）。
`timeout`	超时时间（秒），若进程执行超过此时长，会抛出 `subprocess.TimeoutExpired` 异常。
`input`	向子进程的 `stdin` 发送输入数据（需是字符串或字节，配合 `text=True` 时为字符串）。

返回值：`CompletedProcess` 对象

run() 执行完成后返回 CompletedProcess 实例，包含以下属性：
- returncode：进程退出码（0 表示成功）。
- stdout：进程的标准输出（仅当 stdout=PIPE 时有效）。
- stderr：进程的标准错误（仅当 stderr=PIPE 时有效）。

三、常用示例

1. 执行简单命令，不捕获输出（默认行为）

执行命令并让输出直接打印到终端（适合不需要处理输出的场景）。

import subprocess

# 执行 "ls -l"（Linux/macOS）或 "dir"（Windows）
# 推荐用列表形式传递命令和参数（避免解析问题）
result = subprocess.run(["ls", "-l"])  # Linux/macOS
# result = subprocess.run(["dir"], shell=True)  # Windows 需 shell=True（dir 是 shell 内置命令）

print("退出码：", result.returncode)  # 0 表示成功

2. 捕获命令输出（`stdout=PIPE`）

获取命令的输出内容（如 ls 的结果、python --version 的版本信息）。

# 捕获 stdout（输出）和 stderr（错误）
result = subprocess.run(
    ["python", "--version"],
    stdout=subprocess.PIPE,  # 捕获输出
    stderr=subprocess.PIPE,  # 捕获错误（python --version 实际输出到 stderr）
    text=True  # 输出转为字符串（否则是 bytes）
)

print("stdout:", result.stdout)  # 可能为空（因 python --version 输出到 stderr）
print("stderr:", result.stderr)  # 如 "Python 3.9.7"
print("退出码:", result.returncode)  # 0

3. 检查命令是否执行成功（`check=True`）

当命令可能失败时（如文件不存在），用 check=True 自动抛出异常，避免手动判断 returncode。

try:
    # 尝试删除一个不存在的文件（会失败）
    subprocess.run(
        ["rm", "不存在的文件.txt"],
        check=True,  # 退出码非 0 时抛异常
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        text=True
    )
except subprocess.CalledProcessError as e:
    print(f"命令执行失败！退出码：{e.returncode}")
    print(f"错误信息：{e.stderr}")  # 如 "rm: 无法删除'不存在的文件.txt': 没有那个文件或目录"

4. 使用 shell 特性（`shell=True`）

当需要使用 shell 的管道（|）、通配符（*）、环境变量（$PATH）等特性时，需设置 shell=True。

# 示例：通过管道统计当前目录下的文件数（Linux/macOS）
# 命令：ls -l | wc -l（ls 列文件，wc -l 统计行数）
result = subprocess.run(
    "ls -l | wc -l",  # 字符串形式的命令（因使用管道，需 shell=True）
    shell=True,       # 启用 shell
    stdout=subprocess.PIPE,
    text=True
)

print("当前目录文件数：", result.stdout.strip())  # 输出统计结果

⚠️ 安全警告：shell=True 时，若 args 包含用户输入，可能导致shell 注入攻击（如用户输入 ; rm -rf /）。非必要不使用，必须使用时需严格验证输入。

5. 向子进程发送输入（`input` 参数）

通过 input 向进程的 stdin 传递数据（如给 grep 命令传递内容进行过滤）。

# 示例：向 grep 命令输入文本，过滤包含 "python" 的行
# 命令逻辑：echo "hello python\nhello world" | grep "python"
result = subprocess.run(
    ["grep", "python"],  # grep 命令：过滤包含 "python" 的行
    input="hello python\nhello world",  # 输入给 grep 的内容
    stdout=subprocess.PIPE,
    text=True  # input 为字符串（否则需是 bytes）
)

print("过滤结果：", result.stdout.strip())  # 输出 "hello python"

6. 设置超时（`timeout`）

防止子进程无限阻塞（如网络请求超时），超过 timeout 秒后强制终止并抛异常。

try:
    # 执行一个会阻塞的命令（如 sleep 10），设置超时 3 秒
    subprocess.run(
        ["sleep", "10"],  # Linux/macOS 的 sleep 命令（Windows 可用 "timeout", "/t", "10"）
        timeout=3  # 超时 3 秒
    )
except subprocess.TimeoutExpired as e:
    print(f"命令超时！已运行 {e.timeout} 秒")

7. 重定向输出到文件

将命令的输出保存到文件（替代终端打印）。

# 打开文件，将 ls 的结果写入 output.txt
with open("output.txt", "w") as f:
    subprocess.run(
        ["ls", "-l"],
        stdout=f  # 输出重定向到文件对象 f
    )
print("输出已写入 output.txt")

四、旧有函数（了解即可）

subprocess 模块在 run() 之前有几个常用函数，功能可被 run() 替代，了解即可：

旧函数	等价的 `run()` 用法	功能描述
`call(args)`	`run(args, check=False).returncode`	执行命令，返回退出码（不捕获输出）
`check_call(args)`	`run(args, check=True).returncode`	执行命令，成功返回 0，失败抛异常
`check_output(args)`	`run(args, check=True, stdout=PIPE).stdout`	执行命令，返回输出内容（失败抛异常）

五、最佳实践

优先使用 run()：功能全面，接口统一，替代所有旧函数。
避免 shell=True：除非需要 shell 特性（如管道、通配符），且确保输入安全（无用户可控内容）。
用列表传递 args：["ls", "-l"] 比字符串 "ls -l" 更安全（避免命令解析错误，尤其路径含空格时）。
显式处理输出/错误：根据需求选择 stdout=PIPE（捕获）、DEVNULL（忽略）或文件（保存），避免输出混乱。
设置超时：对可能阻塞的命令（如网络操作、长时间计算）设置 timeout，防止程序挂起。
错误处理：使用 check=True 配合 try-except 捕获 CalledProcessError，简化错误判断。

总结

subprocess 模块是 Python 调用外部命令的核心工具，通过 run() 函数可灵活控制进程的创建、输入输出和错误处理。掌握其参数（如 args、stdout、check、timeout）和返回值，能高效地与系统命令或外部程序交互，适用于自动化脚本、系统管理、跨程序协作等场景。

subprocess模块

subprocess是Python 2.4中新增的一个模块，它允许你生成新的进程，连接到它们的 input/output/error 管道，并获取它们的返回（状态）码。这个模块的目的在于替换几个旧的模块和方法，如：

os.system
os.spawn

1. subprocess模块中的常用函数

函数	描述
subprocess.run()	Python 3.5中新增的函数。执行指定的命令，等待命令执行完成后返回一个包含执行结果的CompletedProcess类的实例。
subprocess.call()	执行指定的命令，返回命令执行状态，其功能类似于os.system(cmd)。
subprocess.check_call()	Python 2.5中新增的函数。执行指定的命令，如果执行成功则返回状态码，否则抛出异常。其功能等价于subprocess.run(..., check=True)。
subprocess.check_output()	Python 2.7中新增的的函数。执行指定的命令，如果执行状态码为0则返回命令执行结果，否则抛出异常。
subprocess.getoutput(cmd)	接收字符串格式的命令，执行命令并返回执行结果，其功能类似于os.popen(cmd).read()和commands.getoutput(cmd)。
subprocess.getstatusoutput(cmd)	执行cmd命令，返回一个元组(命令执行状态, 命令执行结果输出)，其功能类似于commands.getstatusoutput()。

说明：

在Python 3.5之后的版本中，官方文档中提倡通过subprocess.run()函数替代其他函数来使用subproccess模块的功能；

在Python 3.5之前的版本中，我们可以通过subprocess.call()，subprocess.getoutput()等上面列出的其他函数来使用subprocess模块的功能；

subprocess.run()、subprocess.call()、subprocess.check_call()和subprocess.check_output()都是通过对subprocess.Popen的封装来实现的高级函数，因此如果我们需要更复杂功能时，可以通过subprocess.Popen来完成。

subprocess.getoutput()和subprocess.getstatusoutput()函数是来自Python 2.x的commands模块的两个遗留函数。它们隐式的调用系统shell，并且不保证其他函数所具有的安全性和异常处理的一致性。另外，它们从Python 3.3.4开始才支持Windows平台。

2. 上面各函数的定义及参数说明

函数参数列表：

subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, shell=False, timeout=None, check=False, universal_newlines=False)

subprocess.call(args, *, stdin=None, stdout=None, stderr=None, shell=False, timeout=None)

subprocess.check_call(args, *, stdin=None, stdout=None, stderr=None, shell=False, timeout=None)

subprocess.check_output(args, *, stdin=None, stderr=None, shell=False, universal_newlines=False, timeout=None)

subprocess.getstatusoutput(cmd)

subprocess.getoutput(cmd)

参数说明：

args： 要执行的shell命令，默认应该是一个字符串序列，如['df', '-Th']或('df', '-Th')，也可以是一个字符串，如'df -Th'，但是此时需要把shell参数的值置为True。
shell： 如果shell为True，那么指定的命令将通过shell执行。如果我们需要访问某些shell的特性，如管道、文件名通配符、环境变量扩展功能，这将是非常有用的。当然，python本身也提供了许多类似shell的特性的实现，如glob、fnmatch、os.walk()、os.path.expandvars()、os.expanduser()和shutil等。
check： 如果check参数的值是True，且执行命令的进程以非0状态码退出，则会抛出一个CalledProcessError的异常，且该异常对象会包含参数、退出状态码、以及stdout和stderr(如果它们有被捕获的话)。
stdout, stderr：
- run()函数默认不会捕获命令执行结果的正常输出和错误输出，如果我们向获取这些内容需要传递subprocess.PIPE，然后可以通过返回的CompletedProcess类实例的stdout和stderr属性或捕获相应的内容；
- call()和check_call()函数返回的是命令执行的状态码，而不是CompletedProcess类实例，所以对于它们而言，stdout和stderr不适合赋值为subprocess.PIPE；
- check_output()函数默认就会返回命令执行结果，所以不用设置stdout的值，如果我们希望在结果中捕获错误信息，可以执行stderr=subprocess.STDOUT。
input： 该参数是传递给Popen.communicate()，通常该参数的值必须是一个字节序列，如果universal_newlines=True，则其值应该是一个字符串。
universal_newlines： 该参数影响的是输入与输出的数据格式，比如它的值默认为False，此时stdout和stderr的输出是字节序列；当该参数的值设置为True时，stdout和stderr的输出是字符串。

3. subprocess.CompletedProcess类介绍

需要说明的是，subprocess.run()函数是Python3.5中新增的一个高级函数，其返回值是一个subprocess.CompletedPorcess类的实例，因此，subprocess.completedPorcess类也是Python 3.5中才存在的。它表示的是一个已结束进程的状态信息，它所包含的属性如下：

args： 用于加载该进程的参数，这可能是一个列表或一个字符串
returncode： 子进程的退出状态码。通常情况下，退出状态码为0则表示进程成功运行了；一个负值-N表示这个子进程被信号N终止了
stdout： 从子进程捕获的stdout。这通常是一个字节序列，如果run()函数被调用时指定universal_newlines=True，则该属性值是一个字符串。如果run()函数被调用时指定stderr=subprocess.STDOUT，那么stdout和stderr将会被整合到这一个属性中，且stderr将会为None
stderr： 从子进程捕获的stderr。它的值与stdout一样，是一个字节序列或一个字符串。如果stderr灭有被捕获的话，它的值就为None
check_returncode()： 如果returncode是一个非0值，则该方法会抛出一个CalledProcessError异常。

4. 实例

subprocess.run()

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

subprocess.call()

>>> subprocess.call(['ls',  '-l'])
总用量 160
drwxr-xr-x  2 wader wader   4096 12月  7  2015 公共的
drwxr-xr-x  2 wader wader   4096 12月  7  2015 模板
drwxr-xr-x  2 wader wader   4096 12月  7  2015 视频
drwxr-xr-x  2 wader wader   4096 12月  7  2015 图片
drwxr-xr-x  2 wader wader   4096 12月  7  2015 文档
drwxr-xr-x  2 wader wader   4096  4月 13  2016 下载
drwxr-xr-x  2 wader wader   4096 12月  7  2015 音乐
drwxr-xr-x  7 wader wader   4096  5月 26  2016 桌面
0
>>> subprocess.call('ls -l', shell=True)
总用量 160
drwxr-xr-x  2 wader wader   4096 12月  7  2015 公共的
drwxr-xr-x  2 wader wader   4096 12月  7  2015 模板
drwxr-xr-x  2 wader wader   4096 12月  7  2015 视频
drwxr-xr-x  2 wader wader   4096 12月  7  2015 图片
drwxr-xr-x  2 wader wader   4096 12月  7  2015 文档
drwxr-xr-x  2 wader wader   4096  4月 13  2016 下载
drwxr-xr-x  2 wader wader   4096 12月  7  2015 音乐
drwxr-xr-x  7 wader wader   4096  5月 26  2016 桌面
0
>>> subprocess.call(['ls',  '-l'], stdout=subprocess.DEVNULL)
0
>>> subprocess.call(['ls',  '-l', '/test'])
ls: 无法访问/test: 没有那个文件或目录
2

suprocess.check_call()

>>> subprocess.check_call(['ls',  '-l'])
总用量 160
drwxr-xr-x  2 wader wader   4096 12月  7  2015 公共的
drwxr-xr-x  2 wader wader   4096 12月  7  2015 模板
drwxr-xr-x  2 wader wader   4096 12月  7  2015 视频
drwxr-xr-x  2 wader wader   4096 12月  7  2015 图片
drwxr-xr-x  2 wader wader   4096 12月  7  2015 文档
drwxr-xr-x  2 wader wader   4096  4月 13  2016 下载
drwxr-xr-x  2 wader wader   4096 12月  7  2015 音乐
drwxr-xr-x  7 wader wader   4096  5月 26  2016 桌面
0
>>> subprocess.check_call('ls -l', shell=True)
总用量 160
drwxr-xr-x  2 wader wader   4096 12月  7  2015 公共的
drwxr-xr-x  2 wader wader   4096 12月  7  2015 模板
drwxr-xr-x  2 wader wader   4096 12月  7  2015 视频
drwxr-xr-x  2 wader wader   4096 12月  7  2015 图片
drwxr-xr-x  2 wader wader   4096 12月  7  2015 文档
drwxr-xr-x  2 wader wader   4096  4月 13  2016 下载
drwxr-xr-x  2 wader wader   4096 12月  7  2015 音乐
drwxr-xr-x  7 wader wader   4096  5月 26  2016 桌面
0
>>> subprocess.check_call('ls -l /test', shell=True)
ls: 无法访问/test: 没有那个文件或目录
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python3.4/subprocess.py", line 557, in check_call
    raise CalledProcessError(retcode, cmd)
subprocess.CalledProcessError: Command 'ls -l /test' returned non-zero exit status 2

sbuprocess.check_output()

>>> ret = subprocess.check_output(['ls',  '-l'])
>>> print(ret)
b' \xe5\x85\xac\xe5\x85\xb1\xe7\x9a\x84\ndrwxr-xr-x  2 wader wader   4096 12\xe6\x9c\x88  7  2015 \xe6\xa8\xa1\xe6\x9d\xbf\ndrwxr-xr-x  2 wader wader   4096 12\xe6\x9c\x88  7  2015 \xe8\xa7\x86\xe9\xa2\x91\ndrwxr-xr-x  2 wader wader   4096 12\xe6\x9c\x88  7  2015 \xe5\x9b\xbe\xe7\x89\x87\ndrwxr-xr-x  2 wader wader   4096 12\xe6\x9c\x88  7  2015 \xe6\x96\x87\xe6\xa1\xa3\ndrwxr-xr-x  2 wader wader   4096  4\xe6\x9c\x88 13  2016 \xe4\xb8\x8b\xe8\xbd\xbd\ndrwxr-xr-x  2 wader wader   4096 12\xe6\x9c\x88  7  2015 \xe9\x9f\xb3\xe4\xb9\x90\ndrwxr-xr-x  7 wader wader   4096  5\xe6\x9c\x88 26  2016 \xe6\xa1\x8c\xe9\x9d\xa2\n'
>>> ret = subprocess.check_output(['ls',  '-l'], universal_newlines=True)
>>> print(ret)
总用量 160
drwxr-xr-x  2 wader wader   4096 12月  7  2015 公共的
drwxr-xr-x  2 wader wader   4096 12月  7  2015 模板
drwxr-xr-x  2 wader wader   4096 12月  7  2015 视频
drwxr-xr-x  2 wader wader   4096 12月  7  2015 图片
drwxr-xr-x  2 wader wader   4096 12月  7  2015 文档
drwxr-xr-x  2 wader wader   4096  4月 13  2016 下载
drwxr-xr-x  2 wader wader   4096 12月  7  2015 音乐
drwxr-xr-x  7 wader wader   4096  5月 26  2016 桌面

subprocess.getoutput()与subprocess.getstatusoutput()

>>> ret = subprocess.getoutput('ls -l')
>>> print(ret)
总用量 160
drwxr-xr-x  2 wader wader   4096 12月  7  2015 公共的
drwxr-xr-x  2 wader wader   4096 12月  7  2015 模板
drwxr-xr-x  2 wader wader   4096 12月  7  2015 视频
drwxr-xr-x  2 wader wader   4096 12月  7  2015 图片
drwxr-xr-x  2 wader wader   4096 12月  7  2015 文档
drwxr-xr-x  2 wader wader   4096  4月 13  2016 下载
drwxr-xr-x  2 wader wader   4096 12月  7  2015 音乐
drwxr-xr-x  7 wader wader   4096  5月 26  2016 桌面
>>> retcode, output = subprocess.getstatusoutput('ls -l')
>>> print(retcode)
0
>>> print(output)
总用量 160
drwxr-xr-x  2 wader wader   4096 12月  7  2015 公共的
drwxr-xr-x  2 wader wader   4096 12月  7  2015 模板
drwxr-xr-x  2 wader wader   4096 12月  7  2015 视频
drwxr-xr-x  2 wader wader   4096 12月  7  2015 图片
drwxr-xr-x  2 wader wader   4096 12月  7  2015 文档
drwxr-xr-x  2 wader wader   4096  4月 13  2016 下载
drwxr-xr-x  2 wader wader   4096 12月  7  2015 音乐
drwxr-xr-x  7 wader wader   4096  5月 26  2016 桌面
>>> retcode, output = subprocess.getstatusoutput('ls -l /test')
>>> print(retcode)
2
>>> print(output)
ls: 无法访问/test: 没有那个文件或目录

三、subprocess.Popen介绍

该类用于在一个新的进程中执行一个子程序。前面我们提到过，上面介绍的这些函数都是基于subprocess.Popen类实现的，通过使用这些被封装后的高级函数可以很方面的完成一些常见的需求。由于subprocess模块底层的进程创建和管理是由Popen类来处理的，因此，当我们无法通过上面哪些高级函数来实现一些不太常见的功能时就可以通过subprocess.Popen类提供的灵活的api来完成。

1.subprocess.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=False,
    startup_info=None, creationflags=0, restore_signals=True, start_new_session=False, pass_fds=())

参数说明：

args： 要执行的shell命令，可以是字符串，也可以是命令各个参数组成的序列。当该参数的值是一个字符串时，该命令的解释过程是与平台相关的，因此通常建议将args参数作为一个序列传递。
bufsize： 指定缓存策略，0表示不缓冲，1表示行缓冲，其他大于1的数字表示缓冲区大小，负数表示使用系统默认缓冲策略。
stdin, stdout, stderr： 分别表示程序标准输入、输出、错误句柄。
preexec_fn： 用于指定一个将在子进程运行之前被调用的可执行对象，只在Unix平台下有效。
close_fds： 如果该参数的值为True，则除了0,1和2之外的所有文件描述符都将会在子进程执行之前被关闭。
shell： 该参数用于标识是否使用shell作为要执行的程序，如果shell值为True，则建议将args参数作为一个字符串传递而不要作为一个序列传递。
cwd： 如果该参数值不是None，则该函数将会在执行这个子进程之前改变当前工作目录。
env： 用于指定子进程的环境变量，如果env=None，那么子进程的环境变量将从父进程中继承。如果env!=None，它的值必须是一个映射对象。
universal_newlines： 如果该参数值为True，则该文件对象的stdin，stdout和stderr将会作为文本流被打开，否则他们将会被作为二进制流被打开。
startupinfo和creationflags： 这两个参数只在Windows下有效，它们将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如主窗口的外观，进程优先级等。

2. subprocess.Popen类的实例可调用的方法

方法	描述
Popen.poll()	用于检查子进程（命令）是否已经执行结束，没结束返回None，结束后返回状态码。
Popen.wait(timeout=None)	等待子进程结束，并返回状态码；如果在timeout指定的秒数之后进程还没有结束，将会抛出一个TimeoutExpired异常。
Popen.communicate(input=None, timeout=None)	该方法可用来与进程进行交互，比如发送数据到stdin，从stdout和stderr读取数据，直到到达文件末尾。
Popen.send_signal(signal)	发送指定的信号给这个子进程。
Popen.terminate()	停止该子进程。
Popen.kill()	杀死该子进程。

关于communicate()方法的说明：

该方法中的可选参数 input 应该是将被发送给子进程的数据，或者如没有数据发送给子进程，该参数应该是None。input参数的数据类型必须是字节串，如果universal_newlines参数值为True，则input参数的数据类型必须是字符串。
该方法返回一个元组(stdout_data, stderr_data)，这些数据将会是字节穿或字符串（如果universal_newlines的值为True）。
如果在timeout指定的秒数后该进程还没有结束，将会抛出一个TimeoutExpired异常。捕获这个异常，然后重新尝试通信不会丢失任何输出的数据。但是超时之后子进程并没有被杀死，为了合理的清除相应的内容，一个好的应用应该手动杀死这个子进程来结束通信。
需要注意的是，这里读取的数据是缓冲在内存中的，所以，如果数据大小非常大或者是无限的，就不应该使用这个方法。

3. subprocess.Popen使用实例

实例1：

>>> import subprocess
>>>
>>> p = subprocess.Popen('df -Th', stdout=subprocess.PIPE, shell=True)
>>> print(p.stdout.read())
Filesystem     Type      Size  Used Avail Use% Mounted on
/dev/vda1      ext4       40G   12G   26G  31% /
devtmpfs       devtmpfs  3.9G     0  3.9G   0% /dev
tmpfs          tmpfs     3.9G     0  3.9G   0% /dev/shm
tmpfs          tmpfs     3.9G  386M  3.5G  10% /run
tmpfs          tmpfs     3.9G     0  3.9G   0% /sys/fs/cgroup
tmpfs          tmpfs     783M     0  783M   0% /run/user/0
tmpfs          tmpfs     783M     0  783M   0% /run/user/1000

实例2：

>>> obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
>>> obj.stdin.write('print(1) \n')
>>> obj.stdin.write('print(2) \n')
>>> obj.stdin.write('print(3) \n')
>>> out,err = obj.communicate()
>>> print(out)
1
2
3

>>> print(err)

实例3：

>>> obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
>>> out,err = obj.communicate(input='print(1) \n')
>>> print(out)
1

>>> print(err)

实例4：

实现类似df -Th | grep data命令的功能，实际上就是实现shell中管道的共功能。

>>> 
>>> p1 = subprocess.Popen(['df', '-Th'], stdout=subprocess.PIPE)
>>> p2 = subprocess.Popen(['grep', 'data'], stdin=p1.stdout, stdout=subprocess.PIPE)
>>> out,err = p2.communicate()
>>> print(out)
/dev/vdb1      ext4      493G  4.8G  463G   2% /data
/dev/vdd1      ext4     1008G  420G  537G  44% /data1
/dev/vde1      ext4      985G  503G  432G  54% /data2

>>> print(err)
None

四、总结

那么我们到底该用哪个模块、哪个函数来执行命令与系统及系统进行交互呢？下面我们来做个总结：

首先应该知道的是，Python2.4版本引入了subprocess模块用来替换os.system()、os.popen()、os.spawn*()等函数以及commands模块；也就是说如果你使用的是Python 2.4及以上的版本就应该使用subprocess模块了。
如果你的应用使用的Python 2.4以上，但是是Python 3.5以下的版本，Python官方给出的建议是使用subprocess.call()函数。Python 2.5中新增了一个subprocess.check_call()函数，Python 2.7中新增了一个subprocess.check_output()函数，这两个函数也可以按照需求进行使用。
如果你的应用使用的是Python 3.5及以上的版本（目前应该还很少），Python官方给出的建议是尽量使用subprocess.run()函数。
当subprocess.call()、subprocess.check_call()、subprocess.check_output()和subprocess.run()这些高级函数无法满足需求时，我们可以使用subprocess.Popen类来实现我们需要的复杂功能。

一、核心功能与基本概念

二、核心函数：subprocess.run()（推荐）

函数签名

关键参数说明

返回值：CompletedProcess 对象

三、常用示例

1. 执行简单命令，不捕获输出（默认行为）

2. 捕获命令输出（stdout=PIPE）

3. 检查命令是否执行成功（check=True）

4. 使用 shell 特性（shell=True）

5. 向子进程发送输入（input 参数）

6. 设置超时（timeout）

7. 重定向输出到文件

四、旧有函数（了解即可）

五、最佳实践

总结

subprocess模块

1. subprocess模块中的常用函数

2. 上面各函数的定义及参数说明

函数参数列表：

参数说明：

3. subprocess.CompletedProcess类介绍

4. 实例

subprocess.run()

subprocess.call()

suprocess.check_call()

sbuprocess.check_output()

subprocess.getoutput()与subprocess.getstatusoutput()

三、subprocess.Popen介绍

1.subprocess.Popen的构造函数

2. subprocess.Popen类的实例可调用的方法

关于communicate()方法的说明：

3. subprocess.Popen使用实例

实例1：

实例2：

实例3：

实例4：

四、总结

二、核心函数：`subprocess.run()`（推荐）

返回值：`CompletedProcess` 对象

2. 捕获命令输出（`stdout=PIPE`）

3. 检查命令是否执行成功（`check=True`）

4. 使用 shell 特性（`shell=True`）

5. 向子进程发送输入（`input` 参数）

6. 设置超时（`timeout`）