Python 调用外部命令并获取输出结果 – wiki基地

作者： /

Python 与外部世界的桥梁：深入探索如何调用外部命令并捕获输出

在 Python 的强大生态系统中，我们经常需要与操作系统层面或其他外部程序进行交互。无论是执行一个系统命令来管理文件、调用一个命令行工具（如 Git、Docker、FFmpeg）进行特定操作，还是运行一个自定义的脚本，Python 都提供了完善的机制来充当这座桥梁。本文将深入探讨在 Python 中如何安全、灵活、高效地调用外部命令，特别是如何捕获和处理这些命令的输出结果。

我们将从 Python 标准库提供的不同工具入手，详细解析它们的用法、特点、适用场景以及潜在的陷阱。重点将放在现代、推荐的方式上，但也会简要回顾一下历史方法及其局限性，以便读者能全面理解这一领域的发展。

为什么需要调用外部命令？

在开始技术细节之前，让我们思考一下为什么在 Python 程序中会需要执行外部命令：

  1. 系统管理任务： 执行文件系统操作（除了 Python 内置的功能外，有时需要更复杂的 shell 命令）、用户管理、服务启停等。
  2. 利用现有命令行工具： 许多强大的工具只提供命令行接口，例如版本控制系统（Git）、容器技术（Docker）、媒体处理（FFmpeg）、网络工具（curl, ping）、数据处理（grep, sed, awk）等。通过 Python 调用它们，可以将这些功能集成到更复杂的自动化脚本或应用程序中。
  3. 运行其他语言编写的程序： 如果你有用 C++, Java, Go 或 shell 脚本编写的工具，可以通过 Python 调用它们并利用其结果。
  4. 进程间通信（IPC）的简单形式： 通过标准输入、标准输出和标准错误流进行简单的信息交换。

了解了这些需求，我们就更容易理解 Python 为何提供了多种方式来满足它们。

历史回顾：那些年我们用过的函数

在 subprocess 模块出现之前，Python 主要使用 os 模块中的一些函数来调用外部命令。了解它们有助于理解 subprocess 为什么是更好的选择。

1. os.system(command)

这是最古老、最简单的方式。它接收一个字符串形式的命令，在子 shell 中执行它，并阻塞当前 Python 进程，直到命令完成。

特点：

  • 简单易用： 直接传入完整的命令字符串即可。
  • 阻塞： Python 程序会暂停执行，直到外部命令结束。
  • 无法捕获输出： os.system() 的返回值是命令的退出状态码（在 Unix 上），它会将外部命令的输出直接打印到控制台，无法在 Python 程序内部获取。
  • 安全性差： 如果命令字符串是动态构建的，特别是包含用户输入时，极易遭受 shell 注入攻击。
  • 错误处理有限： 只能通过退出状态码判断命令是否成功，无法区分标准输出和标准错误。

示例：

“`python
import os

在 Unix/Linux/macOS 上执行

status = os.system(“ls -l”)

在 Windows 上执行

status = os.system(“dir”)

print(f”命令退出状态码: {status}”)

实际输出会直接显示在控制台上

“`

结论： os.system() 功能非常有限，不推荐用于需要捕获输出或需要更好控制和安全性的场景。

2. os.popen(command, mode='r', buffering=-1)

os.popen() 提供了一种稍微好一点的方式，它可以将命令的输出当作一个文件对象来读取。

特点：

  • 可以捕获标准输出： 可以通过返回的文件对象读取命令的标准输出。
  • 阻塞： 仍然会阻塞直到命令完成（或者读取到文件末尾）。
  • 无法捕获标准错误： 标准错误仍然会直接输出到控制台。
  • 安全性问题： 同样存在 shell 注入的风险。
  • 返回值： 返回一个文件对象，不是命令的退出状态码（需要通过文件对象的 close() 方法来获取，但这不太直观且容易忽略）。

示例：

“`python
import os

在 Unix/Linux/macOS 上执行

try:

with os.popen(“ls -l”) as f:

output = f.read()

print(“命令输出：”)

print(output)

# 要获取退出状态码比较麻烦，且依赖于具体实现，不推荐这种方式获取

except Exception as e:

print(f”执行命令出错: {e}”)

在 Windows 上执行

try:

with os.popen(“dir”) as f:

output = f.read()

print(“命令输出：”)

print(output)

except Exception as e:

print(f”执行命令出错: {e}”)

“`

结论： os.popen() 比 os.system() 有进步，可以捕获标准输出，但仍然有很多缺点，尤其是无法捕获标准错误和不方便获取退出状态码。同样不推荐在新代码中使用。

现代标准：subprocess 模块

subprocess 模块是 Python 调用外部命令的首选方式。它设计用来替代 os.system、os.popen、os.spawn* 等函数，提供了更强大、更灵活、更安全的方式来创建和管理子进程。

subprocess 模块的核心在于 Popen 类，它允许你创建子进程并与之交互（发送输入、接收输出、等待结束等）。然而，对于大多数常见的用例——运行一个命令并等待它完成，同时可能捕获其输出——subprocess 模块提供了一系列便利函数，其中最推荐的是 subprocess.run()。

1. 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, ...)

subprocess.run() 是 Python 3.5 引入的，旨在成为执行子进程并等待其完成的首选方式。它返回一个 CompletedProcess 对象，该对象包含了子进程的执行结果（退出状态码、标准输出、标准错误等）。

核心参数解析：

  • args (必需): 要执行的命令及其参数。强烈推荐使用一个列表来传递命令和参数，例如 ['ls', '-l', '/path/to/dir']。这样可以避免 shell 解析带来的安全问题和复杂性。如果 shell=True，则可以将整个命令作为单个字符串传递。
  • capture_output (布尔值, Python 3.7+): 如果设置为 True，则标准输出和标准错误将被捕获。捕获的数据将在 CompletedProcess 对象的 stdout 和 stderr 属性中返回。默认是 False，此时子进程的输出会直接流向父进程的控制台。注意： 这个参数替代了旧的 stdout=subprocess.PIPE 和 stderr=subprocess.PIPE 组合，使用更简洁。
  • text (布尔值, Python 3.7+): 如果设置为 True，或者设置了 encoding 或 errors 或 universal_newlines=True，那么 stdout 和 stderr 将被解码为文本，而不是返回字节序列。推荐设置为 True 来方便处理文本输出。默认是 False，返回字节序列。
  • encoding, errors: 当 text=True 时，用于解码 stdout 和 stderr 的编码和错误处理方式。
  • shell (布尔值): 如果设置为 True，命令将在 shell 中执行。这意味着可以利用 shell 的特性，如管道 (|)、重定向 (>)、文件名通配符 (*) 等。然而，除非绝对必要，否则应避免使用 shell=True，因为它会引入安全风险（特别是当命令或参数来自不可信的输入时）并使命令的构造更加复杂。 默认是 False。
  • cwd (字符串): 设置子进程的当前工作目录。
  • timeout (数值): 如果子进程运行时间超过这个秒数，将抛出 TimeoutExpired 异常。
  • check (布尔值): 如果设置为 True，并且命令返回非零退出状态码，将抛出 CalledProcessError 异常。这是一种方便的方式来自动检查命令是否成功。默认是 False，此时需要手动检查返回码。
  • env (字典): 如果提供了，这将是一个字典，定义了子进程的环境变量。如果为 None，子进程将继承父进程的环境变量。

捕获输出的基本用法 (Python 3.7+ 推荐):

“`python
import subprocess

try:
# 使用列表形式传递命令和参数，更安全
result = subprocess.run(
[‘ls’, ‘-l’],
capture_output=True, # 捕获标准输出和标准错误
text=True, # 将输出解码为文本
check=True # 如果命令失败（非零退出码），抛出异常
)

print("命令执行成功！")
print("退出状态码:", result.returncode)
print("标准输出:")
print(result.stdout)
print("标准错误:")
print(result.stderr)

except FileNotFoundError:
print(“错误: 命令找不到。请检查命令名称和 PATH 环境变量。”)
except subprocess.CalledProcessError as e:
print(f”错误: 命令执行失败，退出状态码 {e.returncode}”)
print(“标准输出:”)
print(e.stdout) # 注意：如果 check=True 且发生错误，stdout/stderr 仍然在异常对象中
print(“标准错误:”)
print(e.stderr)
except subprocess.TimeoutExpired as e:
print(f”错误: 命令执行超时 ({e.timeout} 秒)。”)
print(“标准输出 (部分):”) # 超时时，输出可能不完整
print(e.stdout)
print(“标准错误 (部分):”)
print(e.stderr)
except Exception as e:
print(f”发生未知错误: {e}”)

“`
代码详解：

  • subprocess.run(['ls', '-l'], ...): 执行 ls -l 命令。注意 ['ls', '-l'] 是一个列表，ls 是命令，-l 是参数。这是推荐的传递命令和参数的方式。
  • capture_output=True: 告诉 Python 捕获子进程的标准输出 (stdout) 和标准错误 (stderr)，而不是让它们直接打印到控制台。
  • text=True: 告诉 Python 将捕获到的字节序列解码成字符串。在大多数情况下，这是你想要的，因为它使得处理输出文本更加方便。默认情况下，输出是 bytes 类型，你需要手动解码（例如 .decode('utf-8')）。
  • check=True: 如果 ls -l 命令执行失败（例如，文件或目录不存在，虽然 ls -l 本身很少失败，但换成 grep non_existent_pattern file 就可能失败），subprocess.run 会自动抛出一个 CalledProcessError 异常。这比手动检查 result.returncode 更简洁。
  • try...except: 这是一个标准的错误处理结构，用于捕获可能发生的各种异常。
    • FileNotFoundError: 如果 Python 找不到要执行的命令（例如，命令名拼写错误，或者命令不在系统的 PATH 环境变量中），会抛出此异常。
    • subprocess.CalledProcessError: 当 check=True 且子进程返回非零退出状态码时抛出。异常对象 e 包含 returncode, cmd, stdout, stderr 等属性，方便你获取失败原因和输出。
    • subprocess.TimeoutExpired: 当设置了 timeout 参数且子进程执行时间超过指定时间时抛出。异常对象 e 包含 cmd, timeout, stdout, stderr 等属性。

手动检查返回码和输出 (如果 check=False):

如果你不使用 check=True，你需要自己检查 CompletedProcess 对象的 returncode 属性。

“`python
import subprocess

try:
result = subprocess.run(
[‘ls’, ‘-l’, ‘/non_existent_path’], # 这是一个会失败的命令
capture_output=True,
text=True,
check=False # 不自动抛出异常
)

print("命令执行完成。")
print("退出状态码:", result.returncode)
print("标准输出:")
print(result.stdout)
print("标准错误:")
print(result.stderr)

if result.returncode != 0:
    print("命令执行失败，根据退出状态码判断。")
    # 可以在这里根据 stderr 或 returncode 进行进一步处理/报告错误

except FileNotFoundError:
print(“错误: 命令找不到。请检查命令名称和 PATH 环境变量。”)
except subprocess.TimeoutExpired as e:
print(f”错误: 命令执行超时 ({e.timeout} 秒)。”)
print(“标准输出 (部分):”)
print(e.stdout)
print(“标准错误 (部分):”)
print(e.stderr)
except Exception as e:
print(f”发生未知错误: {e}”)
“`

传递标准输入：

你可以通过 input 参数向子进程的标准输入发送数据。这对于需要交互或从 stdin 读取数据的命令很有用。

“`python
import subprocess

try:
# 模拟一个需要输入的命令，例如 grep 从 stdin 读取
# 在 Unix/Linux/macOS 上
command = [‘grep’, ‘hello’]
# 在 Windows 上可以使用 findstr
# command = [‘findstr’, ‘hello’]

input_data = "hello world\nthis is a test\nanother hello line\n"

result = subprocess.run(
    command,
    input=input_data, # 将 input_data 作为标准输入发送给子进程
    capture_output=True,
    text=True,
    check=True
)

print("命令执行成功！")
print("标准输出:")
print(result.stdout)
print("标准错误:")
print(result.stderr)

except FileNotFoundError:
print(“错误: 命令找不到。请检查命令名称和 PATH 环境变量。”)
except subprocess.CalledProcessError as e:
print(f”错误: 命令执行失败，退出状态码 {e.returncode}”)
print(“标准输出:”)
print(e.stdout)
print(“标准错误:”)
print(e.stderr)
except Exception as e:
print(f”发生未知错误: {e}”)
``
**注意：** 当使用input参数时，subprocess.run会负责管理子进程的标准输入流。如果同时设置了stdin=subprocess.PIPE或stdin=some_file_object，并且也设置了input参数，会引发ValueError。通常，如果你只是想发送一些数据给子进程，使用input` 参数是最简单的。

使用 shell=True (带警告):

虽然不推荐，但在某些特定场景下，使用 shell=True 可能更方便（例如，需要执行复杂的 shell 管道或使用 shell 内置命令）。务必注意安全风险！

“`python
import subprocess
import shlex # shlex 用于安全地分割 shell 命令字符串 (但在这里我们是整体传递)

示例：使用 shell 特性，如管道

command_string = “ls -l | grep ‘.py'” # 在 Unix/Linux/macOS

command_string = “dir | findstr \”.py\”” # 在 Windows

try:
# !!! WARNING !!!: 如果 command_string 包含用户输入或其他不可信的数据，
# 使用 shell=True 会有严重的安全风险 (shell 注入)。
result = subprocess.run(
command_string,
shell=True, # 在 shell 中执行
capture_output=True,
text=True,
check=True
)

print("命令执行成功！")
print("退出状态码:", result.returncode)
print("标准输出:")
print(result.stdout)
print("标准错误:")
print(result.stderr)

except subprocess.CalledProcessError as e:
print(f”错误: 命令执行失败，退出状态码 {e.returncode}”)
print(“标准输出:”)
print(e.stdout)
print(“标准错误:”)
print(e.stderr)
except Exception as e:
print(f”发生未知错误: {e}”)
“`
安全警告的详细解释：

当 shell=True 时，Python 不是直接执行你提供的程序，而是启动一个 shell 进程（如 /bin/sh 或 cmd.exe），然后让这个 shell 去解析并执行你提供的命令字符串。这意味着如果你的命令字符串是基于用户输入或其他不可信来源构建的，恶意用户可以注入额外的 shell 命令。

例如，假设你构建命令的方式是 command = "grep '{}' file.txt".format(user_input)，如果 shell=True 且用户输入是 ; rm -rf /，那么实际执行的命令字符串就变成了 grep ''; rm -rf /' file.txt。shell 会将其解析为两个命令：grep '' file.txt 后跟 rm -rf /，导致灾难性后果。

使用列表形式 ['grep', user_input, 'file.txt'] 则安全得多，因为 user_input 会被当作一个整体的参数传递给 grep 命令，shell 不会对其进行二次解析。

总结 subprocess.run() 的优点：

  • 功能全面： 支持设置工作目录、环境变量、超时、输入等。
  • 易于捕获输出和错误： capture_output=True 和 text=True 让获取 stdout/stderr 变得简单直观。
  • 方便的错误检查： check=True 可以自动检查命令是否成功。
  • 推荐的方式： 适用于绝大多数“运行命令并等待完成”的场景。
  • 返回 CompletedProcess 对象： 结果集中在一个对象中，清晰易读。

2. 其他 subprocess 便利函数 (基于 Popen 的简化)

在 subprocess.run() 出现之前，人们常用一些基于 Popen 的更简单的函数。虽然 run 已经覆盖了它们的大部分功能且更灵活，但在一些老代码中仍然可以看到它们。

  • subprocess.call(args, *, shell=False, cwd=None, env=None, timeout=None, ...):

    • 执行命令并等待其完成。
    • 返回命令的退出状态码。
    • 不捕获标准输出和标准错误（它们会直接打印到控制台）。
    • 类似于 os.system，但提供了更多参数控制 (cwd, env, timeout等)，且推荐使用列表形式的 args 更安全。
    • 用途：只需要知道命令是否成功（通过退出码判断），不需要捕获输出时使用（但 run 也能做到并返回更多信息）。

    “`python

    import subprocess

    # 返回退出状态码

    return_code = subprocess.call([‘ls’, ‘-l’])

    print(f”命令退出状态码: {return_code}”)

    return_code = subprocess.call(‘dir’, shell=True) # Windows

    print(f”命令退出状态码: {return_code}”)

    “`

  • subprocess.check_call(args, *, shell=False, cwd=None, env=None, timeout=None, ...):

    • 类似于 subprocess.call，但如果命令返回非零退出状态码，会抛出 CalledProcessError 异常。
    • 用途：只需要确保命令成功执行，失败时立即抛出异常，不需要捕获输出。相当于 subprocess.run(args, check=True).returncode。

    “`python

    import subprocess

    try:

    # 如果 ls /non_existent_path 失败，会抛出异常

    subprocess.check_call([‘ls’, ‘/non_existent_path’])

    print(“命令执行成功 (不会打印，因为上面会失败)”)

    except subprocess.CalledProcessError as e:

    print(f”命令执行失败，退出状态码 {e.returncode}”)

    # 注意：check_call 默认不会捕获 stdout/stderr，它们会直接打印出来

    “`

  • subprocess.check_output(args, *, shell=False, cwd=None, env=None, universal_newlines=False, timeout=None, encoding=None, errors=None):

    • 执行命令并等待其完成。
    • 捕获标准输出并将其作为字节序列返回。
    • 如果命令返回非零退出状态码，会抛出 CalledProcessError 异常（异常对象会包含 stderr）。
    • 相当于 subprocess.run(args, capture_output=True, check=True).stdout。
    • universal_newlines, encoding, errors 参数用于将输出解码为文本。在 Python 3.7+ 中，推荐使用 run 函数的 text=True 和 capture_output=True 组合来达到同样目的。

    “`python

    import subprocess

    try:

    # 捕获标准输出为 bytes

    output_bytes = subprocess.check_output([‘ls’, ‘-l’])

    print(“命令输出 (bytes):”)

    print(output_bytes)

    print(“解码后输出:”)

    print(output_bytes.decode(‘utf-8’))

    # 捕获标准输出为 text (使用 encoding 或 universal_newlines=True)

    output_text = subprocess.check_output([‘ls’, ‘-l’], text=True) # Python 3.7+

    # 或者 output_text = subprocess.check_output([‘ls’, ‘-l’], encoding=’utf-8′) # 老版本

    # 或者 output_text = subprocess.check_output([‘ls’, ‘-l’], universal_newlines=True) # 老版本

    print(“解码后输出 (text):”)

    print(output_text)

    except subprocess.CalledProcessError as e:

    print(f”命令执行失败，退出状态码 {e.returncode}”)

    print(“标准输出 (bytes):”, e.stdout) # 注意异常中的 stdout/stderr 仍然是 bytes

    print(“标准错误 (bytes):”, e.stderr)

    except Exception as e:

    print(f”发生未知错误: {e}”)

    “`

为什么 subprocess.run() 是首选？

因为它将所有结果（退出码、stdout、stderr）和控制选项（输入、cwd、env、timeout、check、capture_output、text 等）都集中到一个函数调用和返回对象中。这使得代码更清晰，更不容易出错，因为你总是能方便地访问所有结果，并能以一致的方式处理成功和失败的情况。其他便利函数只返回部分信息或执行部分操作，需要你组合它们或额外处理。

3. subprocess.Popen 类：处理更复杂的场景

对于需要更细粒度控制子进程的场景，例如：

  • 运行一个长时间运行的进程而不阻塞父进程。
  • 与子进程进行复杂的交互（多次发送输入/读取输出）。
  • 构建复杂的管道 (process1 | process2 | process3)。
  • 处理非常大的输出，避免一次性加载到内存。

这时就需要直接使用 subprocess.Popen 类。

Popen 类创建一个子进程，但不会等待其完成。它会立即返回一个 Popen 对象，你可以通过这个对象来控制子进程并与之通信。

基本用法：

“`python
import subprocess
import time

创建一个 Popen 对象，不阻塞

在 Unix/Linux/macOS 上执行一个长时间运行的命令，例如 ping

process = subprocess.Popen([‘ping’, ‘-c’, ‘5’, ‘baidu.com’], stdout=subprocess.PIPE, text=True)

在 Windows 上执行

process = subprocess.Popen([‘ping’, ‘-n’, ‘5’, ‘baidu.com’], stdout=subprocess.PIPE, text=True)

print(f”子进程已启动，PID: {process.pid}”)

父进程可以继续做其他事情…

print(“父进程正在做其他事情…”)
time.sleep(1)
print(“父进程继续…”)

等待子进程完成并获取输出

communicate() 方法用于发送数据到 stdin (可选) 并从 stdout 和 stderr 读取数据，直到 EOF

stdout, stderr = process.communicate()

print(“子进程已完成。”)
print(“退出状态码:”, process.returncode) # communicate() 完成后，returncode 会被设置
print(“标准输出:”)
print(stdout)
print(“标准错误:”)
print(stderr)

process.wait() 也可以等待子进程完成，但不处理输入输出

return_code = process.wait()

print(“子进程通过 wait() 完成，退出状态码:”, return_code)

``
**Popen` 对象的常用方法和属性：**

  • process = subprocess.Popen(...): 创建并启动子进程。参数与 run 类似，但 capture_output, check, input, timeout, text 等参数是 run 的特有便捷参数，在 Popen 中需要通过其他方式实现。例如，要捕获输出，你需要显式指定 stdout=subprocess.PIPE 和/或 stderr=subprocess.PIPE。要发送输入，指定 stdin=subprocess.PIPE。
  • process.communicate(input=None, timeout=None):
    • 这是与子进程交互的主要方式，尤其适用于需要同时发送输入和读取输出的场景。
    • 它会向子进程的 stdin 发送 input 数据（如果指定了），然后读取子进程的 stdout 和 stderr，直到子进程结束或达到文件末尾。
    • 返回一个元组 (stdout_data, stderr_data)。
    • 这个方法会阻塞，直到子进程结束或超时。
    • 执行完毕后，process.returncode 会被设置为子进程的退出状态码。
    • 注意： 如果子进程产生大量输出，communicate() 会将所有输出加载到内存中，可能导致内存问题。
  • process.wait(timeout=None):
    • 等待子进程终止。
    • 返回子进程的退出状态码。
    • 不会读取或处理子进程的 stdout 或 stderr。
    • 可以设置超时时间。
  • process.poll():
    • 检查子进程是否已经终止。
    • 如果已经终止，返回退出状态码。
    • 如果尚未终止，返回 None。
    • 这是一个非阻塞的方法，可以在循环中用于检查子进程状态。
  • process.pid: 子进程的进程 ID。
  • process.returncode: 子进程的退出状态码。只有在子进程终止后（通过 wait(), poll() 返回非 None，或 communicate() 返回）才会被设置。
  • process.stdin, process.stdout, process.stderr: 如果在创建 Popen 对象时，将这些参数设置为 subprocess.PIPE 或文件对象，那么它们将是可用于与子进程标准流交互的文件对象。
    • process.stdin.write(data): 向子进程写入数据。
    • process.stdout.read(), process.stdout.readline(), process.stdout.readlines(): 从子进程读取数据。
    • process.stderr.read(), process.stderr.readline(), process.stderr.readlines(): 从子进程读取错误输出。
    • 重要： 在读写这些管道时要小心死锁。如果子进程的标准输出或标准错误缓冲区满了，它会阻塞写入，如果父进程此时正阻塞在向子进程的标准输入写入，而没有其他线程或进程来读取子进程的输出，就会发生死锁。communicate() 方法内部处理了这种死锁问题，所以对于简单的输入/输出交互，communicate() 是更安全的选择。对于复杂的、大数据的、需要实时处理流的场景，可能需要使用独立的线程或非阻塞 I/O 来分别处理 stdout 和 stderr。
  • process.terminate(): 向子进程发送 SIGTERM 信号（在 Windows 上是类似的终止信号）。请求子进程优雅地退出。
  • process.kill(): 向子进程发送 SIGKILL 信号（在 Windows 上是类似的强制终止）。强制杀死子进程，不给它清理的机会。

使用 Popen 实时处理输出 (示例概念，非完整可运行代码):

“`python
import subprocess
import sys
import threading

def read_output(pipe, stream_name):
“””在一个单独的线程中读取子进程的输出流”””
try:
# 逐行读取并处理
for line in iter(pipe.readline, b”): # 注意，如果是 text=False，这里是 bytes
print(f”[{stream_name}] {line.strip()}”)
pipe.close()
except Exception as e:
print(f”Error reading {stream_name}: {e}”, file=sys.stderr)

创建一个 Popen 对象，将 stdout 和 stderr 重定向到管道

在 Unix/Linux/macOS:

proc = subprocess.Popen(

[‘your_long_running_script.sh’],

stdout=subprocess.PIPE,

stderr=subprocess.PIPE,

text=True # 如果希望readline返回字符串而不是bytes

)

在 Windows:

proc = subprocess.Popen(

[‘your_long_running_script.bat’],

stdout=subprocess.PIPE,

stderr=subprocess.PIPE,

text=True # 如果希望readline返回字符串而不是bytes

)

print(f”子进程已启动 (PID: {proc.pid})，正在实时读取输出…”)

# 创建线程分别读取 stdout 和 stderr，避免死锁

stdout_thread = threading.Thread(target=read_output, args=(proc.stdout, ‘STDOUT’))

stderr_thread = threading.Thread(target=read_output, args=(proc.stderr, ‘STDERR’))

stdout_thread.start()

stderr_thread.start()

# 等待子进程完成

return_code = proc.wait()

# 等待读取线程完成（确保所有输出都已处理）

stdout_thread.join()

stderr_thread.join()

print(f”子进程已完成，退出状态码: {return_code}”)

``
这个示例展示了使用Popen和多线程来实时处理子进程输出的基本思想。通过将 stdout 和 stderr 分别在独立的线程中读取，可以避免父进程在写入 stdin 或等待子进程完成时，子进程因输出缓冲区满而阻塞，从而导致的死锁。对于大多数简单捕获输出的需求，subprocess.run(…, capture_output=True)` 已经足够且更方便。

最佳实践与注意事项

  1. 优先使用 subprocess.run(): 对于执行命令并等待其完成的常见场景，subprocess.run() 是最推荐的方式。
  2. 使用列表形式传递命令和参数: 始终优先使用 ['command', 'arg1', 'arg2'] 这种列表形式，而不是单个字符串 command arg1 arg2 并结合 shell=True。这更安全，可以避免 shell 注入，并且命令的解析由 Python 负责，行为更可预测。
  3. 谨慎使用 shell=True: 只有在必须利用 shell 特性（如管道、重定向、环境变量展开、文件名通配符）且你能完全控制命令字符串的来源，确保其不包含来自不可信用户的输入时，才考虑使用 shell=True。
  4. 始终检查命令的退出状态码: 非零退出状态码通常表示命令执行失败。使用 subprocess.run(..., check=True) 可以让 Python 自动帮你检查并抛出异常。如果不使用 check=True，记得手动检查 result.returncode 或 process.returncode。
  5. 同时捕获标准输出和标准错误: 有时，命令的错误信息会输出到标准错误流而不是标准输出。为了获取完整的执行结果和诊断信息，建议同时捕获 stdout 和 stderr (capture_output=True)。
  6. 处理字节 vs 文本输出: 默认情况下，subprocess 捕获的输出是字节序列 (bytes)。如果确定输出是文本，使用 text=True (或 encoding/universal_newlines=True) 将其解码为字符串 (str) 更方便处理。务必了解子进程输出的编码方式，以免出现乱码。UTF-8 是一个常用的选择。
  7. 设置超时: 对于可能长时间运行甚至挂起的命令，设置 timeout 参数可以防止你的 Python 程序无限期等待。
  8. 处理 FileNotFoundError: 如果执行的命令本身不存在或不在系统的 PATH 环境变量中，会抛出 FileNotFoundError。应该捕获这个异常并给出用户友好的提示。
  9. 注意平台差异: 命令名称（例如 ls vs dir）、命令参数的格式、路径分隔符 (/ vs \)、甚至某些命令的行为在不同的操作系统上可能不同。编写跨平台代码时需要特别注意这些差异，可能需要使用 sys.platform 或 os.name 来判断当前操作系统并调整命令。
  10. 处理大量输出： 如果预期子进程会产生非常大的输出，subprocess.run(..., capture_output=True) 和 process.communicate() 会将所有输出加载到内存，可能导致内存耗尽。在这种情况下，考虑使用 Popen 并通过管道 (stdout=subprocess.PIPE) 实时读取输出（可能需要多线程），或者将输出重定向到文件 (stdout=some_file_object)。
  11. 环境变量和工作目录： 使用 cwd 和 env 参数可以控制子进程的执行环境，这对于依赖特定目录或环境变量的命令非常重要。

总结与对比

特性/函数 os.system() os.popen() subprocess.call() subprocess.check_call() subprocess.check_output() subprocess.run() (推荐) subprocess.Popen (灵活)
调用方式 字符串 字符串 列表或字符串 列表或字符串 列表或字符串 列表或字符串 列表或字符串
默认是否阻塞 是 是 是 是 是 是 否
捕获标准输出 否 是 (通过文件对象) 否 否 是 (bytes) 是 (bytes 或 str) 是 (通过 PIPE/communicate/读文件对象)
捕获标准错误 否 否 否 否 (异常中包含) 否 (异常中包含) 是 (bytes 或 str) 是 (通过 PIPE/communicate/读文件对象)
获取退出状态码 是 (返回值) 困难 (需调用 close) 是 (返回值) 失败时抛异常 失败时抛异常 是 (.returncode) 是 (.returncode/wait/poll)
自动检查错误 否 否 否 是 (抛 CalledProcessError) 是 (抛 CalledProcessError) 是 (check=True 抛 CalledProcessError) 否 (需手动检查)
传递标准输入 否 否 否 否 否 是 (input 参数) 是 (.stdin/communicate)
设置工作目录 否 否 是 (cwd) 是 (cwd) 是 (cwd) 是 (cwd) 是 (cwd)
设置环境变量 否 否 是 (env) 是 (env) 是 (env) 是 (env) 是 (env)
设置超时 否 否 是 (timeout) 是 (timeout) 是 (timeout) 是 (timeout 抛 TimeoutExpired) 是 (timeout 在 wait/communicate 中)
安全性 (防注入) 差 (用字符串时) 差 (用字符串时) 好 (用列表时) 好 (用列表时) 好 (用列表时) 好 (用列表时) 好 (用列表时)
推荐度 不推荐 不推荐 低 中 中 高 高 (复杂场景)

结论

Python 的 subprocess 模块是处理外部命令和子进程的强大而灵活的工具。对于绝大多数运行命令、等待其完成并捕获输出的需求，subprocess.run() 是现代 Python 中最简洁、最安全、功能最全面的选择。它将命令执行的所有方面集中在一个函数调用中，并通过返回的 CompletedProcess 对象提供了丰富的执行结果信息。

当需要更高级的控制，例如运行非阻塞进程、复杂的管道操作、或与子进程进行精细的交互时，直接使用 subprocess.Popen 类是必要的。但使用 Popen 需要更仔细地管理进程的生命周期和标准流，以避免潜在的问题如死锁。

理解并正确使用 subprocess 模块，尤其是优先使用 subprocess.run() 和列表形式的命令参数，是编写健壮、安全、可维护的 Python 脚本和应用程序与外部世界交互的关键。通过掌握这些技术，你可以轻松地将 Python 与系统命令、命令行工具以及其他各种外部程序无缝集成，极大地扩展 Python 的应用范围。

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部