Python中如何跟踪异常直至程序结束并统一输出结果？

问题描述 #

我正在做一个大学项目，老师要求修改Python代码，使其无论是否发生异常都能执行到最后并输出结果。已编写一个包含8-9个类的Python应用，由main.py调用处理数据并输出结果，每个类提供一个或多个功能（例如：xml_manager.download_from(url)、xml_manager.parse(xml_file)等），所有功能的结果都必须在最后展示。这些功能关联紧密，之前用多个try-except捕获错误并终止程序，现在需要调整逻辑。

原示例代码：

# main.py
# start program

obj_a = class_a()
result_a = foo_a(some_input)    # may throw exceptions

obj_b = class_b()
result_b = foo_b(result_a)      # may throw exceptions

obj_c = class_c()
result_c = foo_b(result_b)      # may throw exceptions

print(f"Results: {result_a}, {result_b}, {result_c}")

我的思路是让函数返回结果和状态信息，修改后的代码如下：

# main.py
# start program

obj_a = class_a()
result_a, status_msg = foo_a(some_input)    # 无异常时status_msg为空，否则是错误信息
if status_msg != "":
    result_a = status_msg

obj_b = class_b()
result_b, status_msg = foo_b(result_a)      # may throw exceptions
if status_msg != "":
    result_b = status_msg

obj_c = class_c()
result_c, status_msg = foo_b(result_b)      # may throw exceptions
if status_msg != "":
    result_c = status_msg

print(f"Results: {result_a}, {result_b}, {result_c}")

想知道有没有更好的实现方式？创建一个名为Output的类并作为参数传递给每个函数是否符合Python最佳实践？（我在Java中做过类似操作，但不确定Python中是否合适）

可行的实现方案 #

1. 优化返回值模式（基于你的思路改进） #

将返回值改为(结果, 错误信息)的形式，用None表示无错误（比空字符串更符合Python习惯），同时封装一个工具函数减少重复的异常处理代码：

def safe_execute(func, *args, **kwargs):
    try:
        result = func(*args, **kwargs)
        return result, None
    except Exception as e:
        # 建议捕获特定异常而非所有Exception，避免掩盖未知问题
        return None, f"Error: {str(e)}"

# main.py
obj_a = class_a()
result_a, error_a = safe_execute(foo_a, some_input)
result_a = result_a if error_a is None else error_a

obj_b = class_b()
# 修正原代码笔误：此处应为foo_b而非重复调用foo_b（假设是foo_c）
result_b, error_b = safe_execute(foo_b, result_a)
result_b = result_b if error_b is None else error_b

obj_c = class_c()
result_c, error_c = safe_execute(foo_c, result_b)
result_c = result_c if error_c is None else error_c

print(f"Results: {result_a}, {result_b}, {result_c}")

这种方式既保留了你“返回状态”的思路，又通过工具函数消除了重复代码，逻辑更简洁。

2. 异常捕获+字典收集结果 #

如果不想修改原有函数的返回值，直接在main.py中用try-except捕获每个步骤的异常，用字典统一收集结果：

# main.py
results = {}

# 处理class_a与foo_a
try:
    obj_a = class_a()
    results['a'] = foo_a(some_input)
except Exception as e:
    results['a'] = f"foo_a执行失败: {str(e)}"

# 处理class_b与foo_b
try:
    obj_b = class_b()
    results['b'] = foo_b(results['a'])
except Exception as e:
    results['b'] = f"foo_b执行失败: {str(e)}"

# 处理class_c与foo_c
try:
    obj_c = class_c()
    results['c'] = foo_c(results['b'])
except Exception as e:
    results['c'] = f"foo_c执行失败: {str(e)}"

print(f"Results: {results['a']}, {results['b']}, {results['c']}")

该方案无需改动原有函数逻辑，直接在入口层处理异常，每个步骤的错误信息更明确，可读性强。

3. Output类方案的适用性 #

在Python中创建Output类传递给函数是可行的，但不属于最Pythonic的做法。Python更倾向于显式返回值或使用轻量结构（如字典）收集结果，而不是通过传递可变对象来共享状态（这种方式更贴近Java的设计习惯）。

如果你的项目需要统一管理更多执行状态（比如日志、执行时长、错误码等），可以使用这类封装类：

class OutputTracker:
    def __init__(self):
        self.results = {}
        self.error_details = {}
    
    def record_success(self, key, value):
        self.results[key] = value
        self.error_details[key] = None
    
    def record_error(self, key, error_msg):
        self.results[key] = error_msg
        self.error_details[key] = error_msg

# main.py
tracker = OutputTracker()

try:
    obj_a = class_a()
    tracker.record_success('a', foo_a(some_input))
except Exception as e:
    tracker.record_error('a', f"foo_a执行失败: {str(e)}")

try:
    obj_b = class_b()
    tracker.record_success('b', foo_b(tracker.results['a']))
except Exception as e:
    tracker.record_error('b', f"foo_b执行失败: {str(e)}")

try:
    obj_c = class_c()
    tracker.record_success('c', foo_c(tracker.results['b']))
except Exception as e:
    tracker.record_error('c', f"foo_c执行失败: {str(e)}")

print(f"Results: {tracker.results['a']}, {tracker.results['b']}, {tracker.results['c']}")

这种方案适合复杂场景的状态管理，但如果只是简单收集结果，前两种轻量方案更合适。

总结建议 #

• 若允许修改原函数，优先选择优化后的返回值模式，简洁且符合Python习惯；
• 若无法修改原函数，用异常捕获+字典收集的方式最直接；
• Output类可行但偏重量级，仅当需要统一管理多维度状态时推荐使用。

内容的提问来源于stack exchange，提问作者Bog Alt