当前位置：首页 > news >正文

系统交互 | Python 中捕获命令输出 / Shell 脚本中捕获 Python 程序输出

news 2025/10/2 9:04:17

注：本文为 “系统交互 | Python 命令输出 / Shell 脚本捕获” 相关合辑。
英文引文，机翻未校。
中文引文，待校重排。
如有内容异常，请看原文或自校。

Capturing Command Output in Python: Simplifying System Interactions

在 Python 中捕获命令输出：简化系统交互

Aniroodh Prasad
阿尼鲁德·普拉萨德
Jul 24, 2023

Introduction:
1. 引言

In the world of Python programming, there are countless possibilities for solving real-world problems. One such common task is executing system commands or external programs and capturing their output to further process or display to the user. In this blog, we will explore a step-by-step guide on how to accomplish this using the subprocess module in Python.
在 Python 编程领域，解决实际问题的方法不计其数。其中一项常见任务是执行系统命令或外部程序，并捕获它们的输出，以便进一步处理或向用户展示。在本文中，我们将逐步介绍如何使用 Python 中的 subprocess 模块实现这一功能。

Step 1: Import the Required Module
2. 步骤 1：导入所需模块

The subprocess module is a powerful Python library that allows us to interact with the system and execute external commands. To begin, we import this module into our Python script.
subprocess 模块是一个功能强大的 Python 库，它支持我们与系统进行交互并执行外部命令。首先，我们需要在 Python 脚本中导入该模块。

import subprocess

Step 2: Define the Command
3. 步骤 2：定义命令

Before capturing the output, we need to define the command that we wish to execute. It can be any system command or an external program that we want to run.
在捕获输出之前，我们需要定义要执行的命令。该命令可以是任意系统命令，也可以是我们想要运行的外部程序。

command = "ls"  # Replace this with the command you want to run 将此命令替换为你想要运行的命令

Step 3: Run the Command and Capture the Output
4. 步骤 3：运行命令并捕获输出

With the command defined, we can now run it using the subprocess.run() function. By setting capture_output=True, we instruct Python to capture the output of the command. The output will be stored in a CompletedProcess object, which we can access through the stdout attribute.
命令定义完成后，我们可以使用 subprocess.run() 函数来运行它。通过设置 capture_output=True，我们告知 Python 捕获该命令的输出。输出将存储在 CompletedProcess 对象中，我们可以通过 stdout 属性访问该输出。

result = subprocess.run(command, capture_output=True, text=True)
output = result.stdout.strip()

Step 4: Process the Output (Optional)
5. 步骤 4：处理输出（可选）

Depending on the nature of the command output, you may choose to process it further to extract relevant information. For instance, you can split the output into lines or words using the splitlines() or split() method, respectively.
根据命令输出的性质，你可以选择对其进行进一步处理，以提取相关信息。例如，你可以分别使用 splitlines() 方法或 split() 方法将输出按行拆分或按单词拆分。

lines = output.splitlines()
words = output.split()

Step 5: Display or Use the Output
6. 步骤 5：显示或使用输出

At this point, the output is available in the output variable, and we can display it or use it for further processing within our Python script.
此时，输出已存储在 output 变量中，我们可以在 Python 脚本中显示该输出，或将其用于进一步处理。

print("Command Output:")
print(output)# Optionally, process the output further （可选）进一步处理输出
print("Number of lines:", len(lines))  # 输出的行数：lines 的长度

Here’s the complete example:
7. 完整示例如下

import subprocesscommand = "ls"  # Replace this with the command you want to run 将此命令替换为你想要运行的命令result = subprocess.run(command, capture_output=True, text=True)
output = result.stdout.strip()print("Command Output:")
print(output)# Optionally, process the output further （可选）进一步处理输出
lines = output.splitlines()
print("Number of lines:", len(lines))  # 输出的行数：lines 的长度

Conclusion:
8. 结论

Capturing the output of system commands or external programs using Python can greatly enhance the versatility of your scripts. With the subprocess module, you can effortlessly interact with the system and process the results efficiently.
使用 Python 捕获系统命令或外部程序的输出，能显著提升脚本的多功能性。借助 subprocess 模块，你可以轻松地与系统进行交互，并高效地处理执行结果。

Whether you’re automating tasks, extracting data from system utilities, or integrating with external programs, Python’s ability to run and capture command output makes it a go-to language for system administration and automation. Harness the power of subprocess and take your Python scripts to the next level!
无论你是在实现任务自动化、从系统工具中提取数据，还是与外部程序进行集成，Python 具备的运行并捕获命令输出的能力，使其成为系统管理和自动化领域的首选语言。充分利用 subprocess 模块的功能，让你的 Python 脚本更上一层楼！

Remember, when running system commands from Python, ensure that you validate and sanitize any user-provided inputs to prevent potential security risks.
请记住，当从 Python 中运行系统命令时，务必对所有用户提供的输入进行验证和清洗，以防范潜在的安全风险。

Note, I have done this task in my AWS EC2 instance using Linux. You can use any Os or use your base system.
注：我在自己的 AWS EC2 实例（使用 Linux 系统）中完成了此任务。你可以使用任意操作系统，也可以直接在自己的基础系统中操作。

在 Shell 脚本中捕获 Python 程序输出

在开发与系统管理场景中，Shell 脚本擅长流程控制与系统交互，而 Python 则在数据处理、复杂计算等领域具备优势。将二者结合，通过 Shell 脚本调用 Python 程序并捕获其输出，是实现任务自动化与功能互补的重要技术手段。

1 原理与整体流程

1.1 技术原理

Shell 脚本捕获外部程序输出的机制是命令替换（Command Substitution），其标准语法为 $(command)（推荐使用，兼容性更强且支持嵌套；旧式语法 `command` 不推荐）。

当 Shell 执行 $(python3 script.py) 时，会完成以下三步：

启动子进程，执行内部的 python3 script.py 命令；
捕获该命令的标准输出（stdout） 内容（默认忽略标准错误 stderr）；
将捕获的内容作为字符串返回，可直接赋值给变量或用于后续逻辑。

Python 程序的 print() 函数默认将内容输出到 stdout，这与 Shell 的命令替换机制天然兼容。若需排除警告、日志等无关信息，可通过重定向 Python 的 标准错误（stderr） 实现分离（详见 3.1 节）。

1.2 整体流程

Shell 捕获 Python 输出的完整流程分为 3 个步骤，各步骤职责明确、衔接紧密，具体如下表所示：

步骤	任务	输出物
1	编写标准化 Python 程序：确保参数可解析、结果输出到 stdout、错误输出到 stderr	可执行的 Python 脚本（如 `calculator.py`）
2	编写Shell 调用脚本：通过命令替换捕获输出、校验执行状态、解析结果	可执行的 Shell 脚本（如 `run_calc.sh`）
3	验证与扩展：运行脚本验证结果，或结合流程控制（循环、判断）实现复杂任务	最终计算结果或自动化执行报告

1.3 交互序列图

Shell 与 Python 程序的交互过程：

2 详细实现步骤

2.1 步骤 1：编写标准化的 Python 程序

Python 程序需满足参数可配置、输出明确、错误可捕获三个要求，避免无关信息污染输出。以下以“计算整数的两倍”为例，编写通用 Python 脚本：

2.1.1 Python 脚本代码（`demo.py`）

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
功能：计算输入整数的两倍
参数：sys.argv[1]：输入的整数（必填）
输出：stdout：计算结果（纯数字，无多余字符）stderr：参数错误/类型错误提示
退出码：0：执行成功1：参数数量错误2：参数类型错误（非整数）
"""
import sysdef double_number(num: int) -> int:"""计算整数的两倍"""return num * 2if __name__ == "__main__":# 1. 校验参数数量if len(sys.argv) != 2:print("错误：参数数量错误！正确用法：python3 demo.py <整数>", file=sys.stderr)sys.exit(1)  # 非 0 退出码标识异常# 2. 校验参数类型（是否为整数）input_str = sys.argv[1]if not input_str.isdigit():print(f"错误：输入 '{input_str}' 不是有效整数！", file=sys.stderr)sys.exit(2)# 3. 执行计算并输出结果（仅输出纯结果，无多余信息）num = int(input_str)result = double_number(num)print(result)  # 结果输出到 stdout，供 Shell 捕获

2.1.2 脚本关键规范说明

Shebang 头：#!/usr/bin/env python3 明确指定 Python 3 解释器，确保脚本可直接执行（需授予执行权限 chmod +x demo.py）。
错误分离：通过 file=sys.stderr 将错误信息输出到 stderr，与 stdout（结果）完全分离，避免 Shell 捕获无效内容。
退出码设计：不同错误场景返回不同非 0 退出码（如参数数量错误返回 1，类型错误返回 2），便于 Shell 精准判断错误类型。

2.2 步骤 2：编写 Shell 脚本并捕获输出

Shell 脚本需实现“参数传递、输出捕获、状态校验、结果处理”四大功能，确保交互的稳定性。以下为完整代码：

2.2.1 Shell 脚本代码（`run_demo.sh`）

#!/bin/bash
# -*- coding: utf-8 -*-
"""
功能：调用 demo.py 计算整数的两倍，处理异常并格式化输出
"""# 1. 交互式获取用户输入（或通过脚本参数传递，如 $1）
read -p "请输入一个整数：" input_number# 2. 调用 Python 程序，捕获 stdout，忽略 stderr（避免错误信息干扰结果）
# 语法说明：$(command 2>/dev/null) 中，2>/dev/null 表示将 stderr 重定向到空设备
python_output=$(python3 demo.py "$input_number" 2>/dev/null)# 3. 校验 Python 程序执行状态（$? 为上一条命令的退出码）
exit_code=$?  # 保存退出码（后续可能被其他命令覆盖，需及时保存）
if [ $exit_code -ne 0 ]; thenecho -e "\n执行失败！"# 根据 Python 退出码提示具体错误case $exit_code in1) echo "原因：参数数量错误（内部逻辑异常，需检查 Shell 传参）" ;;2) echo "原因：输入不是有效整数，请重新输入" ;;*) echo "原因：未知错误（退出码：$exit_code）" ;;esacexit 1  # Shell 脚本异常退出
fi# 4. 处理捕获的结果（格式化输出或进一步计算）
echo -e "\n====================================="
echo "输入整数：$input_number"
echo "计算结果：$input_number × 2 = $python_output"
echo "====================================="

2.2.2 脚本关键语法说明

参数安全传递：python3 demo.py "$input_number" 中，input_number 加双引号可避免输入含空格（如 "10 20"）时被解析为多个参数。
退出码保存：exit_code=$? 需在捕获输出后立即执行，因为后续任何命令（如 echo）都会覆盖 $? 的值。
条件判断优化：通过 case 语句根据 Python 退出码区分错误类型，比单纯提示“执行失败”更具实用性。

2.3 步骤 3：运行与验证

2.3.1 准备工作

将 demo.py 与 run_demo.sh 保存在同一目录；
授予两个脚本执行权限：
```
chmod +x demo.py run_demo.sh
```

2.3.2 验证正常场景

执行 Shell 脚本并输入有效整数（如 5）：

./run_demo.sh

输出结果如下，说明捕获与处理成功：

请输入一个整数：5=====================================
输入整数：5
计算结果：5 × 2 = 10
=====================================

2.3.3 验证异常场景

输入非整数（如 abc），脚本会精准提示错误：

请输入一个整数：abc执行失败！
原因：输入不是有效整数，请重新输入

3 捕获方法扩展：从基础到高级

除了 $(...) 命令替换，Shell 还提供多种捕获方法，适用于不同场景（如多行输出、大体积结果、实时交互）。

3.1 方法 1：管道（`|`）结合 `read` 命令（单行输出）

通过管道将 Python 输出传递给 read 命令，直接读取结果到变量，适合单行短输出场景。

基础用法（注意子 Shell 问题）

# 错误示例：管道会创建子 Shell，变量 output 作用域限于子 Shell
python3 demo.py 5 | read output
echo "结果：$output"  # 输出为空（父 Shell 无法访问子 Shell 变量）

解决方法：进程替换（`<(...)`）

使用进程替换避免子 Shell 问题，确保父 Shell 可访问变量：

# 正确用法：<(command) 将命令输出作为“虚拟文件”，供 read 读取
read output < <(python3 demo.py 5)
echo "结果：$output"  # 输出：结果：10（父 Shell 可访问）

3.2 方法 2：临时文件存储（多行/大体积输出）

当 Python 输出为多行内容（如批量日志）或大体积数据（如 GB 级报表）时，变量存储可能导致内存不足，此时需用临时文件中转。

完整示例

#!/bin/bash
# 1. 执行 Python 程序，将 stdout 写入临时文件，stderr 写入错误日志
python3 batch_demo.py > temp_result.txt 2> error.log# 2. 校验执行状态
if [ $? -ne 0 ]; thenecho "执行失败！错误日志：$(cat error.log)" >&2rm -f temp_result.txt error.log  # 清理临时文件exit 1
fi# 3. 逐行读取临时文件内容并处理（如过滤关键字）
echo "批量处理结果："
while read -r line; do# 仅输出包含“成功”的行if echo "$line" | grep -q "成功"; thenecho "✅ $line"fi
done < temp_result.txt# 4. 清理临时文件（避免残留）
rm -f temp_result.txt error.log

优势说明

支持无限长度输出，无内存限制；
可事后复盘（如查看 error.log 定位问题），适合生产环境。

3.3 方法 3：进程替换（`<(...)`）（虚拟文件输入）

通过 <(command) 语法将 Python 输出作为“虚拟文件”，直接供需要文件输入的命令（如 diff、grep、sort）使用，无需创建真实文件。

典型场景：比较 Python 输出与参考文件

# 场景：验证 Python 生成的数据与参考文件是否一致
# 语法：diff <(python3 generate_data.py) reference.txt
diff <(python3 generate_data.py) reference.txt# 若输出为空，说明两者一致；否则显示差异内容
if [ $? -eq 0 ]; thenecho "数据验证通过：Python 输出与参考文件一致"
elseecho "数据验证失败：存在差异" >&2
fi

其他应用：结合 `grep` 过滤输出

# 实时过滤 Python 输出中的错误信息，无需临时文件
grep --line-buffered "ERROR" <(python3 long_running.py)

4 常见问题与解决方案

在实际应用中，捕获过程可能因输出格式、环境配置等问题导致异常。以下是 8 类高频问题及标准化解决方案：

问题 1：输出内容不纯净（含日志/警告）

现象：Shell 捕获的结果包含 Python 的 print("调试信息") 或第三方库警告（如 DeprecationWarning）。
原因：Python 程序将无关信息输出到了 stdout，污染了有效结果。

解决方案：

Python 端：仅将有效结果输出到 stdout，调试信息通过 logging 模块定向到文件或 stderr：

import logging
# 配置日志输出到文件（而非 stdout）
logging.basicConfig(filename="debug.log", level=logging.DEBUG)
logging.debug("调试信息：开始计算")  # 写入文件，不影响 stdout
print(result)  # 仅结果输出到 stdout

Shell 端：若无法修改 Python 代码，可通过 grep 过滤有效结果（需已知结果格式，如纯数字）：
```
# 仅捕获纯数字结果，过滤其他内容
result=$(python3 messy_script.py | grep -E '^[0-9]+$')
```

问题 2：特殊字符导致解析错误

现象：Python 输出含空格、引号、通配符（*、?）时，Shell 误解析（如空格被拆分为多个参数）。
示例：Python 输出 Hello World，Shell 执行 echo $result 时显示 Hello World（看似正常），但执行 echo $result | wc -w 时返回 2（被拆分为两个单词）。

解决方案：

变量引用时始终加双引号，确保内容作为整体解析：

result=$(python3 output_with_space.py)
echo "$result"  # 正确输出：Hello World（保留空格）

复杂结构（如嵌套引号）：使用 JSON 格式标准化输出，通过 jq 工具解析（需安装 jq：sudo apt install jq）：

# Python 端输出 JSON 字符串
import json
data = {"name": "Alice", "message": 'Hello "World"'}
print(json.dumps(data))  # 输出：{"name":"Alice","message":"Hello \"World\""}

# Shell 端用 jq 解析 JSON，避免特殊字符问题
result=$(python3 output_json.py)
name=$(echo "$result" | jq -r '.name')
message=$(echo "$result" | jq -r '.message')
echo "姓名：$name，消息：$message"  # 正确输出：姓名：Alice，消息：Hello "World"

问题 3：Python 输出缓冲导致实时捕获延迟

现象：Python 程序持续输出（如实时日志），但 Shell 需等待程序结束后才能捕获到所有内容，无法实时显示。
原因：Python 默认启用输出缓冲（stdout 为管道/文件时缓冲，为终端时无缓冲），导致内容暂存于内存，未实时刷新到 stdout。

解决方案：

执行 Python 时加 -u 参数，禁用缓冲：

# 实时捕获 Python 日志输出
python3 -u realtime_log.py | while read line; doecho "[$(date +'%H:%M:%S')] $line"  # 实时添加时间戳
done

Python 代码中显式刷新缓冲区：

import time
for i in range(5):print(f"实时日志：第 {i} 秒")flush=True  # 强制刷新缓冲区，确保实时输出time.sleep(1)

问题 4：环境不一致导致 Python 版本冲突

现象：在交互式 Shell 中执行 python3 demo.py 正常，但在脚本中执行失败，提示 ModuleNotFoundError 或语法错误。
原因：脚本执行环境的 PATH 变量与交互式 Shell 不同，可能指向 Python 2（如 python 命令），或虚拟环境未激活。

解决方案：

脚本中明确指定 Python 3 路径（避免使用 python）：

# 方法 1：使用绝对路径（通过 which python3 查看）
result=$(/usr/bin/python3 demo.py 5)
# 方法 2：使用 env 确保找到系统默认 Python 3
result=$(env python3 demo.py 5)

若使用虚拟环境，在脚本中显式激活：

# 激活虚拟环境（假设虚拟环境路径为 ./venv）
source ./venv/bin/activate
# 执行 Python 程序（此时使用虚拟环境中的 Python 版本）
result=$(python3 demo.py 5)
# （可选）退出虚拟环境
deactivate

校验 Python 版本兼容性（避免因版本过低导致语法错误）：

# 检查 Python 版本是否 ≥ 3.8
if ! python3 -c "import sys; assert sys.version_info >= (3,8)" 2>/dev/null; thenecho "错误：需 Python 3.8 及以上版本，当前版本：$(python3 --version)" >&2exit 1
fi

问题 5：程序超时无响应导致 Shell 挂起

现象：Python 程序因死循环、资源耗尽等原因卡住，Shell 脚本无限等待，无法继续执行。

解决方案：使用 timeout 命令设置最大运行时间（单位支持 s/秒、m/分、h/时），超时后强制终止 Python 进程。

# 限制 Python 程序最多运行 10 秒，超时则返回退出码 124
if ! result=$(timeout 10s python3 long_running.py); thenexit_code=$?if [ $exit_code -eq 124 ]; thenecho "错误：Python 程序超时（超过 10 秒）" >&2elseecho "错误：Python 程序异常退出（退出码：$exit_code）" >&2fiexit 1
fi

问题 6：多行输出解析混乱

现象：Python 输出多行内容（如 line1\nline2\nline3），直接存储到变量后，换行符被保留，遍历或分割时出现异常。

解决方案：使用 while read 循环逐行处理，或通过 IFS（内部字段分隔符）指定换行符为分隔符。

# 方法 1：通过管道逐行处理（适合实时输出）
python3 multi_line.py | while read -r line; do# 对每一行执行处理（如过滤、格式化）echo "处理行：$line"
done# 方法 2：先捕获到变量，再通过 Here 字符串逐行处理（适合离线输出）
multi_output=$(python3 multi_line.py)
while IFS= read -r line; do  # IFS= 保留行首/行尾空格echo "处理行：$line"
done <<< "$multi_output"  # <<< 表示将变量内容作为输入传递给循环

问题 7：权限不足导致执行失败

现象：执行 Python 脚本时提示 Permission denied，或无法读取/写入输出文件。

解决方案：

为 Python 脚本添加执行权限：
```
chmod +x demo.py  # 授予执行权限
```

显式指定 Python 解释器（避免依赖脚本的执行权限）：

# 无需脚本执行权限，直接通过 Python 解释器运行
result=$(python3 /full/path/to/demo.py 5)

检查输出文件/目录的写入权限（若使用临时文件）：

# 确保当前目录可写，或指定可写目录（如 /tmp）
temp_file="/tmp/temp_result.txt"
python3 batch_demo.py > "$temp_file"

问题 8：输出为空但程序执行成功

现象：Python 程序退出码为 0（执行成功），但 Shell 捕获的结果为空，导致后续逻辑出错。
原因：Python 程序因条件判断未触发 print()（如 if num > 10: print(result)，但输入 num=5），或结果被误定向到 stderr。

解决方案：在 Shell 中添加空值校验，提前拦截异常：

result=$(python3 demo.py 5)
# 校验结果是否为空（-z 表示“字符串长度为 0”）
if [ -z "$result" ]; thenecho "警告：Python 程序执行成功，但未输出任何结果" >&2# 可选：根据业务需求决定是否退出脚本# exit 1
fi

5 实时监控 Python 程序输出的进阶方案

在日志分析、进度跟踪等场景中，需实时获取并处理 Python 输出（而非等待程序结束）。以下是 4 种常用的实时监控方法：

方法 1：管道 + `tee` 命令（实时显示并记录）

tee 命令可同时将输入内容输出到终端（实时显示）和文件（持久化记录），适合需要“实时查看 + 事后复盘”的场景。

# 实时显示 Python 输出，同时写入日志文件（-u 禁用 Python 缓冲）
python3 -u long_running.py | tee -a app.log
# 说明：
# -u：确保 Python 实时输出，无缓冲延迟
# -a：tee 追加写入文件（避免覆盖原有内容）
# app.log：存储输出的日志文件

扩展：结合 `grep` 过滤关键信息

若只需关注特定内容（如错误日志），可在管道中添加 grep（需加 --line-buffered 确保实时过滤）：

# 实时过滤并显示包含“ERROR”的行，同时写入错误日志
python3 -u long_running.py | grep --line-buffered "ERROR" | tee -a error.log

方法 2：`while read` 循环（实时自定义处理）

通过 while read 循环逐行读取 Python 输出，可添加自定义逻辑（如时间戳、告警触发），灵活性最高。

#!/bin/bash
# 实时处理 Python 输出，添加时间戳并触发错误告警
python3 -u long_running.py | while read -r line; do# 1. 为每一行添加时间戳（格式：HH:MM:SS）timestamp=$(date +'%H:%M:%S')processed_line="[$timestamp] $line"# 2. 实时显示处理后的内容echo "$processed_line"# 3. 自定义逻辑：若包含“CRITICAL”，触发告警（如发送邮件）if echo "$line" | grep -q "CRITICAL"; thenecho "紧急告警：$(date) 检测到 critical 日志" | mail -s "系统告警" admin@example.comfi
done

方法 3：后台运行 + `tail -f`（分离监控与主程序）

若需让 Python 程序在后台运行（不阻塞终端），同时实时监控输出，可将输出重定向到文件，再用 tail -f 监控文件变化。

#!/bin/bash
# 1. 启动 Python 程序（后台运行，输出重定向到日志文件）
python3 -u long_running.py > app.log 2>&1 &
# 说明：
# > app.log：stdout 写入 app.log
# 2>&1：stderr 重定向到 stdout，统一写入日志
# &：让程序在后台运行，不占用当前终端# 2. 记录 Python 进程 ID（用于后续停止程序）
python_pid=$!
echo "Python 程序已启动，进程 ID：$python_pid，日志文件：app.log"# 3. 实时监控日志文件（-f 表示“跟踪文件变化”）
tail -f app.log# 4. （可选）按 Ctrl+C 停止监控后，终止 Python 程序
echo -e "\n正在停止 Python 程序（PID：$python_pid）..."
kill $python_pid

方法 4：命名管道（FIFO）（双向实时交互）

若需同时向 Python 发送输入、实时获取输出（如交互式程序），可使用命名管道（FIFO）实现双向通信。

完整示例

创建命名管道：

mkfifo python_pipe  # 创建名为 python_pipe 的管道文件

编写交互式 Python 程序（interactive.py）：

# 从标准输入读取命令，实时输出结果
import sysprint("请输入命令（支持 'add <a> <b>' 或 'exit'）：", flush=True)
for line in sys.stdin:line = line.strip()if line == "exit":print("程序退出", flush=True)breakelif line.startswith("add"):# 解析命令：add 10 20 → 计算 10+20parts = line.split()if len(parts) != 3:print("错误：命令格式错误，应为 'add <a> <b>'", flush=True)continuea, b = int(parts[1]), int(parts[2])print(f"结果：{a} + {b} = {a+b}", flush=True)else:print(f"错误：未知命令 '{line}'", flush=True)

编写 Shell 监控脚本：

#!/bin/bash
# 通过命名管道与 Python 程序双向交互
mkfifo python_pipe# 后台启动 Python 程序：从管道读取输入，输出到终端
python3 -u interactive.py < python_pipe &
python_pid=$!# 前台交互：用户输入命令，发送到管道
while read -p "输入命令：" cmd; do# 将用户命令写入管道（传递给 Python 程序）echo "$cmd" > python_pipe# 若输入 exit，退出循环并终止 Python 程序if [ "$cmd" = "exit" ]; thenbreakfi
done# 清理资源
wait $python_pid
rm -f python_pipe

运行效果

输入命令：add 10 20
结果：10 + 20 = 30
输入命令：add 5 3
结果：5 + 3 = 8
输入命令：exit
程序退出

6 总结与最佳实践

6.1 总结

Shell 脚本捕获 Python 程序输出的本质是利用输入输出重定向机制，结合 Python 程序的标准化设计（stdout 输出结果、stderr 输出错误、明确退出码），实现两者的高效协作。关键要点如下：

首选方法：简单场景用 $(...) 命令替换，多行/大体积输出用临时文件，实时交互用命名管道；
避坑重点：禁用 Python 缓冲（-u）、变量引用加双引号、校验退出码与空值；
扩展能力：实时监控用 while read 或 tee，复杂结构解析用 jq。

6.2 实践清单

Python 程序设计规范：
- 仅将有效结果输出到 stdout，错误/日志输出到 stderr；
- 定义明确的退出码（0=成功，1=参数错误，2=运行时错误等）；
- 复杂结果用 JSON 格式输出（便于 Shell 解析）。
Shell 脚本编写规范：
- 明确指定 Python 版本（如 python3），避免版本冲突；
- 捕获输出后立即保存退出码（exit_code=$?），避免被覆盖；
- 变量引用加双引号（"$result"），处理特殊字符；
- 大体积/多行输出用临时文件（优先 /tmp 目录，避免权限问题）。
性能与稳定性优化：
- 频繁调用 Python 时，改为“批量处理”（减少解释器启动开销）；
- 长时间运行的程序用 timeout 限制执行时间，避免挂起；
- 实时监控时禁用 Python 缓冲（-u）和 grep 缓冲（--line-buffered）。

通过遵循上述规范，可构建健壮、可维护的 Shell-Python 协作脚本，适配自动化部署、系统监控、数据处理等各类场景需求。

via:

Capturing Command Output in Python: Simplifying System Interactions
https://medium.com/@prasadaniroodh/capturing-command-output-in-python-simplifying-system-interactions-b490c0a7139f
shell 脚本中捕获 python 程序的输出结果_mob64ca12f31496 的技术博客_51CTO 博客
https://blog.51cto.com/u_16213442/11668327

查看全文

http://www.dtcms.com/a/431538.html