python如何执行一个外部命令并获取输出_python执行外部命令并捕获输出的技巧-Python教程-PHP中文网

使用subprocess.run()是Python执行外部命令并捕获输出的推荐方法，它通过capture_output=True获取stdout和stderr，text=True返回字符串结果，check=True在命令失败时抛出异常；对于长时间运行的命令，应使用subprocess.Popen()实现非阻塞执行，配合communicate(timeout=...)避免程序卡死；安全方面需避免shell=True防止注入攻击，改用参数列表传递命令，并可通过env和cwd控制子进程环境与工作目录。

python如何执行一个外部命令并获取输出_python执行外部命令并捕获输出的技巧

在Python里执行外部命令并捕获其输出，最直接也最推荐的方式是使用内置的

subprocess

登录后复制

模块。它提供了非常灵活和强大的功能来创建新的进程、连接到它们的输入/输出/错误管道，并获取它们的返回码。简单来说，如果你需要运行一个shell命令或者其他可执行程序，并且想拿到它打印到屏幕上的内容，

subprocess.run()

登录后复制

就是你的首选。它封装了许多细节，让这个过程变得既安全又方便。

解决方案

要执行一个外部命令并获取其输出，最核心的工具是Python的

subprocess.run()

登录后复制

函数。这个函数在Python 3.5+版本中被引入，旨在替代许多老旧的

subprocess

登录后复制

函数（比如

call

登录后复制

check_call

登录后复制

check_output

登录后复制

），提供了一个更统一、更现代的接口。

当你调用

subprocess.run()

登录后复制

时，你可以通过几个关键参数来控制其行为：

```
args
```
登录后复制
: 这是你想要执行的命令。通常，为了安全起见，我们建议将其作为一个列表传递，其中第一个元素是命令本身，后续元素是其参数。例如，
```
['ls', '-l', '/tmp']
```
登录后复制
。如果你设置为
```
shell=True
```
登录后复制
，也可以传递一个字符串，但那样会有安全隐患，我们稍后会提到。
```
capture_output=True
```
登录后复制
: 这个参数告诉Python捕获外部命令的标准输出（stdout）和标准错误（stderr）。如果没有它，命令的输出会直接打印到你的控制台。
```
text=True
```
登录后复制
(或
```
encoding='utf-8'
```
登录后复制
): 当
```
capture_output=True
```
登录后复制
时，默认捕获的输出是字节串（bytes）。如果你希望直接得到字符串，可以使用
```
text=True
```
登录后复制
（Python 3.7+）或者指定一个
```
encoding
```
登录后复制
，比如
```
encoding='utf-8'
```
登录后复制
。
```
check=True
```
登录后复制
: 如果外部命令以非零退出码结束（通常表示命令执行失败），这个参数会让
```
subprocess.run()
```
登录后复制
抛出一个
```
CalledProcessError
```
登录后复制
异常。这对于错误处理非常有用。

下面是一个基本示例：

立即学习“Python免费学习笔记（深入）”；

import subprocess

try:
    # 执行 'ls -l' 命令，捕获输出并以文本形式返回
    # check=True 会在命令执行失败时抛出异常
    result = subprocess.run(
        ['ls', '-l'],
        capture_output=True,
        text=True,
        check=True
    )

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

except subprocess.CalledProcessError as e:
    print(f"命令执行失败，退出码: {e.returncode}")
    print(f"错误输出: {e.stderr}")
    print(f"标准输出 (如果存在): {e.stdout}")
except FileNotFoundError:
    print("错误：命令未找到。请检查命令路径或环境变量。")
except Exception as e:
    print(f"发生未知错误: {e}")

# 另一个例子：执行一个不存在的命令，看看 check=True 的效果
print("\n--- 尝试执行一个不存在的命令 ---")
try:
    subprocess.run(
        ['nonexistent_command'],
        capture_output=True,
        text=True,
        check=True
    )
except subprocess.CalledProcessError as e:
    print(f"正如预期，命令执行失败，退出码: {e.returncode}")
    print(f"错误输出: {e.stderr.strip()}")
except FileNotFoundError:
    print("命令 'nonexistent_command' 未找到。这是预期的行为。")

登录后复制

subprocess.run()

登录后复制

会返回一个

CompletedProcess

登录后复制

对象，这个对象包含了命令执行的详细信息：

```
returncode
```
登录后复制
: 命令的退出码。0通常表示成功。
```
stdout
```
登录后复制
: 命令的标准输出（如果
```
capture_output=True
```
登录后复制
）。
```
stderr
```
登录后复制
: 命令的标准错误（如果
```
capture_output=True
```
登录后复制
）。

如何处理外部命令的错误输出和非零退出码？

处理外部命令的错误输出和非零退出码，是执行外部程序时一个不可避免，也是至关重要的环节。很多时候，我们不仅关心命令是否成功运行，更关心它失败的原因。

首先，

subprocess.run()

登录后复制

的

check=True

登录后复制

参数是处理非零退出码的利器。当外部命令以非零状态码退出时（比如一个

grep

登录后复制

命令没有找到匹配项，或者一个编译命令遇到了语法错误），

check=True

登录后复制

会立即抛出一个

subprocess.CalledProcessError

登录后复制

异常。这使得你可以在Python代码中集中处理这些“失败”的情况，而不是让程序默默地继续执行，可能带着不正确的结果。

捕获这个异常后，你可以访问异常对象

登录后复制

的属性：

```
e.returncode
```
登录后复制
: 外部命令的退出码。
```
e.stdout
```
登录后复制
: 命令的标准输出（即使失败，也可能有部分输出）。
```
e.stderr
```
登录后复制
: 命令的标准错误输出。

这让你能够详细诊断问题。比如，一个编译命令失败了，你就可以把

e.stderr

登录后复制

打印出来，看到具体的编译错误信息。

至于错误输出（

stderr

登录后复制

），

capture_output=True

登录后复制

参数默认会将

stdout

登录后复制

和

stderr

登录后复制

都捕获到

CompletedProcess

登录后复制

对象的

stdout

登录后复制

和

stderr

登录后复制

属性中。如果你只想捕获

stderr

登录后复制

而不关心

stdout

登录后复制

，或者想对它们进行不同的处理，你可以使用

stdout=subprocess.PIPE

登录后复制

和

stderr=subprocess.PIPE

登录后复制

来更精细地控制。不过，对于大多数情况，

capture_output=True

登录后复制

已经足够了，它会把它们分开存储。

有时候，非零退出码并不一定意味着“错误”。例如，

grep

登录后复制

命令在没有找到匹配项时会返回1，这在脚本逻辑中可能是预期的行为，而不是需要抛异常的错误。在这种情况下，你可以选择不设置

check=True

登录后复制

，而是手动检查

result.returncode

登录后复制

：

import subprocess

command = ['grep', 'nonexistent_pattern', 'nonexistent_file.txt'] # 肯定会失败的命令

print("--- 不使用 check=True，手动检查退出码 ---")
result = subprocess.run(
    command,
    capture_output=True,
    text=True,
    check=False # 不抛出异常
)

if result.returncode != 0:
    print(f"命令 '{' '.join(command)}' 执行失败，退出码: {result.returncode}")
    print(f"错误信息:\n{result.stderr.strip()}")
    # 这里你可以根据 returncode 的值做更细致的判断
    # 比如，如果是 grep 的 1，可能只是没找到，而不是真正的错误
else:
    print(f"命令 '{' '.join(command)}' 执行成功。")
    print(f"输出:\n{result.stdout.strip()}")

# 考虑一个 grep 找到内容和没找到内容的场景
print("\n--- grep 示例 ---")
with open("temp_file.txt", "w") as f:
    f.write("hello world\n")
    f.write("python is great\n")

# 找到匹配项
grep_command_found = ['grep', 'python', 'temp_file.txt']
result_found = subprocess.run(grep_command_found, capture_output=True, text=True, check=False)
print(f"grep 'python' (找到): returncode={result_found.returncode}, stdout='{result_found.stdout.strip()}'")

# 未找到匹配项
grep_command_not_found = ['grep', 'java', 'temp_file.txt']
result_not_found = subprocess.run(grep_command_not_found, capture_output=True, text=True, check=False)
print(f"grep 'java' (未找到): returncode={result_not_found.returncode}, stdout='{result_not_found.stdout.strip()}', stderr='{result_not_found.stderr.strip()}'")

# 清理临时文件
import os
os.remove("temp_file.txt")

登录后复制

这种手动检查的方式给了你更大的控制权，但同时也意味着你需要自己处理所有可能的错误路径，不像

check=True

登录后复制

那样能够快速失败并抛出异常。选择哪种方式，取决于你的具体需求和对外部命令行为的理解。

在执行长时间运行的外部命令时，如何避免程序阻塞？

subprocess.run()

登录后复制

虽然好用，但它有一个特点：它是阻塞的。这意味着Python程序会暂停执行，直到外部命令完成并返回结果。对于那些需要瞬间完成的命令（比如

ls

登录后复制

、

pwd

登录后复制

），这通常不是问题。但如果你的外部命令需要运行几秒、几分钟甚至更长时间（例如，一个大型编译任务、数据处理脚本或网络请求），你的Python程序会一直等待，直到命令结束，这会造成用户界面卡顿、服务器无响应等问题。

为了避免程序阻塞，你需要使用

subprocess.Popen()

登录后复制

。

Popen

登录后复制

是

subprocess

登录后复制

模块的“底层”接口，它允许你启动一个子进程，然后立即返回，让你的Python程序可以继续执行其他任务。你可以把

Popen

登录后复制

想象成一个“启动器”，它只负责把命令扔出去，然后就不管了，让命令在后台自己跑。

使用

Popen

登录后复制

的基本流程是：

创建

Popen

登录后复制

对象：这会启动子进程。

process = subprocess.Popen(
    ['long_running_script.sh'],
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
    text=True # 如果需要文本输出
)

登录后复制

注意，这里我们通常会明确指定

stdout=subprocess.PIPE

登录后复制

和

stderr=subprocess.PIPE

登录后复制

，以便稍后能够捕获它们的输出。

继续执行其他任务：你的Python程序可以做其他事情，例如更新UI、处理其他请求、或者启动另一个子进程。
等待和获取输出：当需要子进程的结果时，你可以使用
```
process.communicate()
```
登录后复制
方法。这个方法会阻塞，直到子进程结束，然后返回一个包含
```
stdout
```
登录后复制
和
```
stderr
```
登录后复制
的元组。

千图设计室AI海报
千图网旗下的智能海报在线设计平台

172

查看详情
```
stdout, stderr = process.communicate(timeout=60) # 可以设置超时
```
登录后复制
```
communicate()
```
登录后复制
的
```
timeout
```
登录后复制
参数非常有用，它能防止程序无限期地等待一个卡住的子进程。如果超时，它会抛出
```
subprocess.TimeoutExpired
```
登录后复制
异常。
检查退出码：
```
process.returncode
```
登录后复制
属性会告诉你子进程的退出码。在
```
communicate()
```
登录后复制
之后，这个属性会被设置。

这里有一个例子，模拟一个耗时命令：

import subprocess
import time
import os

# 创建一个模拟长时间运行的脚本
long_script_content = """
#!/bin/bash
echo "Starting long task..."
sleep 5
echo "Task finished."
exit 0
"""
with open("long_task.sh", "w") as f:
    f.write(long_script_content)
os.chmod("long_task.sh", 0o755) # 赋予执行权限

print("--- 使用 Popen 启动长时间任务 ---")
start_time = time.time()

try:
    # 启动子进程，不阻塞主程序
    process = subprocess.Popen(
        ['./long_task.sh'],
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        text=True
    )

    print(f"主程序：子进程已启动，PID: {process.pid}。我将继续做其他事情...")
    # 主程序可以在这里做一些其他工作
    for i in range(3):
        print(f"主程序：正在执行其他任务... ({i+1}秒)")
        time.sleep(1)

    print("主程序：现在等待子进程完成并获取输出...")
    # 等待子进程完成并获取输出，设置超时为 10 秒
    stdout, stderr = process.communicate(timeout=10)

    end_time = time.time()
    print(f"主程序：子进程已完成，耗时 {end_time - start_time:.2f} 秒。")
    print(f"子进程退出码: {process.returncode}")
    print(f"子进程标准输出:\n{stdout.strip()}")
    if stderr:
        print(f"子进程标准错误:\n{stderr.strip()}")

except subprocess.TimeoutExpired:
    process.kill() # 超时时杀死子进程
    stdout, stderr = process.communicate() # 再次communicate获取被杀死前的输出
    print("主程序：子进程执行超时，已被终止。")
    print(f"部分输出:\n{stdout.strip()}")
except Exception as e:
    print(f"主程序：发生错误: {e}")
finally:
    # 清理临时脚本
    if os.path.exists("long_task.sh"):
        os.remove("long_task.sh")

登录后复制

如果你需要更高级的非阻塞操作，例如在子进程运行时实时读取其输出，或者同时管理多个子进程，你可能需要结合

select

登录后复制

模块或者

asyncio

登录后复制

库来异步地读取管道，但这超出了基础

Popen

登录后复制

的范畴，属于更复杂的并发编程。对于大多数非阻塞需求，

Popen

登录后复制

配合

communicate()

登录后复制

（带

timeout

登录后复制

）已经足够。

Python执行外部命令时，有哪些安全性和环境配置的考量？

执行外部命令不仅仅是运行起来那么简单，它还涉及到安全性和环境配置，这些往往是决定一个脚本健壮性和可靠性的关键因素。

安全性：

shell=True

登录后复制

的陷阱

首先要提的是

shell=True

登录后复制

这个参数。如果你在

subprocess.run()

登录后复制

或

Popen()

登录后复制

中设置了

shell=True

登录后复制

，那么你的命令会通过系统的shell来执行（在Linux上通常是

/bin/sh

登录后复制

，在Windows上是

cmd.exe

登录后复制

）。这听起来很方便，因为你可以直接传递一个字符串，里面包含管道符（

登录后复制

）、重定向符（

登录后复制

）等shell特性，比如

subprocess.run("ls -l | grep .py", shell=True)

登录后复制

。

然而，

shell=True

登录后复制

是一个巨大的安全隐患，尤其当你的命令中包含任何来自用户或其他不可信源的数据时。这被称为“shell注入”攻击。如果用户输入被直接拼接到命令字符串中，恶意用户可以通过注入额外的shell命令来执行任意操作。

例如：假设你有一个命令是

cmd = f"cat {filename}"

登录后复制

，如果用户输入

filename

登录后复制

是

myfile.txt; rm -rf /

登录后复制

，那么你的命令就变成了

cat myfile.txt; rm -rf /

登录后复制

，这会导致灾难性的后果。

最佳实践是：尽可能避免使用

shell=True

登录后复制

。

相反，将命令和其参数作为列表传递给

subprocess

登录后复制

函数。当

shell=False

登录后复制

（这是默认值）时，Python会直接执行命令，而不是通过shell。这意味着它不会解析shell的特殊字符，从而避免了shell注入的风险。

# 安全的方式：使用列表传递参数
subprocess.run(['ls', '-l', '/tmp'])

# 不安全的方式：避免在用户输入中直接使用 shell=True
# user_input = "malicious_file.txt; rm -rf /"
# subprocess.run(f"cat {user_input}", shell=True) # 极度危险！

登录后复制

环境配置：

env

登录后复制

和
cwd
登录后复制

外部命令的执行环境对结果有很大影响。

subprocess

登录后复制

模块提供了

env

登录后复制

和

cwd

登录后复制

参数，让你能够精确控制子进程的环境。

env

登录后复制

参数：允许你为子进程设置特定的环境变量。默认情况下，子进程会继承父进程（你的Python脚本）的所有环境变量。但有时你可能需要修改或添加一些变量，例如设置

PATH

登录后复制

来确保命令能够被找到，或者设置特定的库路径。

env

登录后复制

参数接受一个字典，键值对就是环境变量名和值。

import os
my_env = os.environ.copy() # 复制当前环境是好习惯
my_env["MY_CUSTOM_VAR"] = "Hello From Python"
my_env["PATH"] = "/usr/local/bin:" + my_env["PATH"] # 添加一个路径

# 运行一个会打印环境变量的命令
# 在 Linux/macOS 上：
subprocess.run(['bash', '-c', 'echo $MY_CUSTOM_VAR && echo $PATH'], env=my_env, text=True)
# 在 Windows 上：
# subprocess.run(['cmd', '/c', 'echo %MY_CUSTOM_VAR% && echo %PATH%'], env=my_env, text=True)

登录后复制

cwd

登录后复制

参数：指定子进程的当前工作目录（Current Working Directory）。很多命令的行为都依赖于它们是在哪个目录下执行的。例如，

ls

登录后复制

命令默认会列出当前目录的内容。如果你需要在一个特定的目录中运行命令，而不是Python脚本所在的目录，就可以使用

cwd

登录后复制

。

import os
# 假设 /tmp/test_dir 存在且里面有文件
if not os.path.exists("/tmp/test_dir"):
    os.makedirs("/tmp/test_dir")
    with open("/tmp/test_dir/file1.txt", "w") as f:
        f.write("test")

print("--- 在不同工作目录执行 ls ---")
# 在 Python 脚本当前目录执行 ls
print("当前目录的 ls:")
subprocess.run(['ls'], text=True)

# 在 /tmp/test_dir 目录下执行 ls
print("\n/tmp/test_dir 目录的 ls:")
subprocess.run(['ls'], cwd="/tmp/test_dir", text=True)

# 清理
os.remove("/tmp/test_dir/file1.txt")
os.rmdir("/tmp/test_dir")

登录后复制

超时机制：

timeout

登录后复制

对于任何可能长时间运行的外部命令，设置一个超时机制是至关重要的。一个卡住的命令可能会导致你的Python程序永久阻塞，或者消耗大量系统资源。

subprocess.run()

登录后复制

提供了

timeout

登录后复制

参数，可以在指定时间后自动终止子进程。

import subprocess
import time

print("--- 带有超时机制的命令 ---")
try:
    # 尝试运行一个会持续 10 秒的命令，但只给它 3 秒时间
    subprocess.run(
        ['sleep', '10'],
        timeout=3,
        check=True
    )
    print("命令成功完成（这不应该发生）")
except subprocess.TimeoutExpired:
    print("命令因超时被终止。这是预期的。")
except subprocess.CalledProcessError as e:
    print(f"命令失败，退出码: {e.returncode}")
except Exception as e:
    print(f"发生未知错误: {e}")

登录后复制