投稿获客
  1. 创想鸟首页
  2. 用户投稿

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

程序猿 • • 用户投稿 • 阅读 0

使用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 3.5+版本中被引入，旨在替代许多老旧的

subprocess

函数（比如

call

, 

check_call

, 

check_output

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

当你调用

subprocess.run()

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

: 这是你想要执行的命令。通常，为了安全起见，我们建议将其作为一个列表传递，其中第一个元素是命令本身，后续元素是其参数。例如，

['ls', '-l', '/tmp']

。如果你设置为

shell=True

，也可以传递一个字符串，但那样会有安全隐患，我们稍后会提到。

: 这个参数告诉Python捕获外部命令的标准输出（stdout）和标准错误（stderr）。如果没有它，命令的输出会直接打印到你的控制台。

(或 

encoding='utf-8'

): 当

capture_output=True

时，默认捕获的输出是字节串（bytes）。如果你希望直接得到字符串，可以使用

text=True

（Python 3.7+）或者指定一个

encoding

，比如

encoding='utf-8'

。

: 如果外部命令以非零退出码结束（通常表示命令执行失败），这个参数会让

subprocess.run()

抛出一个

CalledProcessError

异常。这对于错误处理非常有用。

下面是一个基本示例：

subprocess.run()

会返回一个

CompletedProcess

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

: 命令的退出码。0通常表示成功。

: 命令的标准输出（如果

capture_output=True

）。

: 命令的标准错误（如果

capture_output=True

）。

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

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

首先，

subprocess.run()

的

check=True

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

grep

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

check=True

会立即抛出一个

subprocess.CalledProcessError

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

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

e

的属性：

: 外部命令的退出码。

: 命令的标准输出（即使失败，也可能有部分输出）。

: 命令的标准错误输出。

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

e.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 subprocesscommand = ['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 worldn")    f.write("python is greatn")# 找到匹配项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 osos.remove("temp_file.txt")

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

check=True

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

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

subprocess.run()

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

ls

、

pwd

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

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

subprocess.Popen()

。

Popen

是

subprocess

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

Popen

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

使用

Popen

的基本流程是：

对象：这会启动子进程。

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

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

stdout=subprocess.PIPE

和

stderr=subprocess.PIPE

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

方法。这个方法会阻塞，直到子进程结束，然后返回一个包含

stdout

和

stderr

的元组。

communicate()

的

timeout

参数非常有用，它能防止程序无限期地等待一个卡住的子进程。如果超时，它会抛出

subprocess.TimeoutExpired

异常。

属性会告诉你子进程的退出码。在

communicate()

之后，这个属性会被设置。

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

import subprocessimport timeimport os# 创建一个模拟长时间运行的脚本long_script_content = """#!/bin/bashecho "Starting long task..."sleep 5echo "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

的范畴，属于更复杂的

配合

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

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

import osmy_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)

参数：指定子进程的当前工作目录（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 脚本当前目录执行 lsprint("当前目录的 ls:")subprocess.run(['ls'], text=True)# 在 /tmp/test_dir 目录下执行 lsprint("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 subprocessimport timeprint("--- 带有超时机制的命令 ---")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}")
timeout

参数在

subprocess.Popen().communicate()

方法中也可用，用法类似。这大大提高了程序的鲁棒性，防止外部命令的意外行为影响到整个Python应用。

综合来看，理解并恰当使用

subprocess

模块的这些参数，不仅能让你高效地执行外部命令，更能确保你的代码安全、稳定且易于维护。

以上就是python如何执行一个外部命令并获取输出_python执行外部命令并捕获输出的技巧的详细内容，更多请关注创想鸟其它相关文章！

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1372162.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
0 0

关于作者

程序猿的头像

程序猿签约作者

414.1K 文章
0 评论
2 粉丝
这个人很懒，什么都没有留下～
python如何读取和写入csv文件_python CSV文件读写操作指南
上一篇 2025年12月14日 12:05:38
python matplotlib如何显示中文_matplotlib绘图显示中文乱码的解决方案
下一篇 2025年12月14日 12:05:53

相关推荐

发表回复

登录后才能评论
关注微信