Python 异常处理与调试技术详解

本章重点内容：

• 异常处理机制：掌握 try-except-else-finally 结构及自定义异常的使用
• 调试方法实践：运用 print 调试、断点调试和日志模块（logging）快速排查问题

在 Python 编程过程中，运行时错误（即异常）和逻辑缺陷难以完全避免。有效的异常处理策略能够使程序在遭遇错误时不会直接崩溃，而是进行优雅降级；而合理的调试手段则有助于迅速定位并修复代码中的潜在问题。

一、异常处理机制

异常指的是程序执行期间出现的非预期状况，例如除以零、文件不存在、类型不匹配等情形。Python 提供了完整的语法结构用于捕获和响应这些异常，并支持开发者根据业务需求定义专属的异常类型。

try-except

1.1 异常处理的基本结构

Python 中标准的异常处理流程由四个关键字构成：try、except、else 和 finally。它们协同工作，形成一个闭环的错误管理机制。其执行顺序如下：

1. 尝试执行核心代码
2. 若发生异常，则捕获对应类型的异常并处理
3. 若未发生异常，则执行 else 块中的正常后续操作
4. 无论是否发生异常，finally 块总会被执行

try-except-else-finally

基础语法结构示例

try:
    # 可能引发异常的核心业务代码
    risky_operation()
except 异常类型1 as e:
    # 处理特定异常类型
    handle_error1(e)
except (异常类型2, 异常类型3) as e:
    # 同时捕获多个异常类型，统一处理
    handle_errors2_3(e)
except Exception as e:
    # 捕获所有未明确列出的异常（作为兜底）
    handle_all_other_errors(e)
else:
    # 仅当 try 块中无任何异常时才执行
    normal_operation()
finally:
    # 不论是否有异常，最终都会执行此部分
    release_resource()

各组件功能说明与应用场景

try 块：精准包裹高风险代码

作用：将可能发生异常的操作（如文件读写、网络请求、数据转换、数学运算等）放入 try 块中，但应避免将无关逻辑一并纳入，以免干扰异常定位。

推荐做法示例：仅对“打开文件 + 读取”过程进行保护

def read_file(file_path):
    try:
        with open(file_path, "r", encoding="utf-8") as f:
            return f.read()
    except FileNotFoundError:
        print(f"文件 {file_path} 不存在")

except 块：按类型精确捕获异常

设计原则：不应盲目使用宽泛的异常捕获方式，而应依据具体的异常类型分别处理。以下是常见内置异常及其典型触发场景：

异常类型	含义	典型触发场景
TypeError	数据类型不兼容	1 + "2"（整数与字符串相加）
ValueError	值不符合要求	int("abc")（无法解析的字符串转整型）
ZeroDivisionError	除数为零	10 / 0
FileNotFoundError	文件或路径不存在	open("nonexistent.txt")
KeyError	字典键不存在	{"a":1}["b"]
IndexError	索引超出序列范围	[1,2,3][10]

实际应用示例：根据不同异常类型分别响应

try:
    num = int(input("请输入数字："))
    res = 10 / num
except ValueError:
    print("输入的不是有效数字")
except ZeroDivisionError:
    print("不能输入0作为除数")

except Exception:

else 块：分离正常流程与异常处理

用途：当 try 块中没有抛出异常时，执行后续的正常业务逻辑，比如数据验证通过后写入数据库、格式化输出结果等。这有助于解耦正常流程与错误处理逻辑，提高代码可读性。

示例代码：

try:
    num = int(input("请输入数字："))
except ValueError:
    print("输入非数字")
else:
    # 仅在无异常时执行
    print(f"输入的数字是：{num}，平方值为：{num**2}")

finally 块：确保资源释放

核心功能：用于执行必须完成的清理任务，如关闭文件句柄、断开数据库连接、释放锁或终止网络会话等。

关键特性：无论前面是否出现异常，也无论是否遇到 return、break 或 continue 等控制语句，finally 块始终会被执行，从而防止资源泄漏。

实例演示：

conn = None
try:
    conn = get_db_connection()  # 获取数据库连接
    conn.execute("INSERT INTO t_user VALUES (1, 'test')")
except DatabaseError:
    print("数据库操作失败")
finally:
    if conn:
        conn.close()  # 确保连接被关闭

return

break

在进行文件读写操作时，可能会遇到诸如“文件不存在”、“权限不足”或“编码错误”等多种异常情况。为了保证程序的稳定性并正确释放系统资源，应当采用完整的异常处理机制。

以下是一个具备全面异常捕获能力的文件读取函数示例：

def read_file(file_path):
    file = None  # 初始化文件句柄
    try:
        # 尝试打开并读取文件（核心逻辑）
        file = open(file_path, "r", encoding="utf-8")
        content = file.read()
    except FileNotFoundError as e:
        # 处理文件未找到的情况
        print(f"错误：文件 {file_path} 不存在 → {e}")
        return None
    except PermissionError as e:
        # 处理无访问权限的问题
        print(f"错误：无法读取该文件，权限不足 → {e}")
        return None
    except UnicodeDecodeError as e:
        # 处理非 UTF-8 编码导致的解析失败
        print(f"错误：文件编码格式不支持 → {e}")
        return None
    else:
        # 若无异常发生，则执行此分支
        print(f"文件 {file_path} 读取成功，内容长度为：{len(content)} 字节")
        return content
    finally:
        # 不论是否出现异常，最终都会关闭文件句柄
        if file:
            file.close()
            print("文件句柄已释放")

测试用例：

• 调用 read_file("test.txt") 以读取一个存在的文件；
• 调用 read_file("nonexistent.txt") 来验证对缺失文件的处理能力。

with

优化建议：Python 提供了上下文管理器（即 with 语句），可自动完成资源的申请与释放，避免手动管理带来的遗漏风险。使用该机制后，上述代码可以被简化为更安全且简洁的形式。

with open(...) as file: content = file.read()

1.2 自定义异常

虽然 Python 内置了多种标准异常类型，但在实际业务开发中，往往需要更具描述性的错误信息来区分特定场景下的问题，例如“用户余额不足”、“订单状态非法”等。通过自定义异常类，能够实现更清晰的错误分类和精准反馈。

自定义异常的设计规范

• 应继承自内置的 Exception 类，而非 BaseException —— 后者包含如 KeyboardInterrupt 等系统级中断信号，不应被普通业务逻辑捕获；
• 可通过重写 __init__ 方法添加额外属性（如错误码、上下文数据）；
• 利用 raise 关键字主动抛出异常实例。

Exception

BaseException

__init__

raise

实战案例：电商订单系统的自定义异常设计

针对电商平台中的订单流程，定义三类典型业务异常：余额不足、订单不存在、订单状态异常。通过分层结构提升代码可维护性。

# 1. 定义基础异常类
class OrderError(Exception):
    """所有订单相关异常的基类"""
    def __init__(self, error_code, message):
        self.error_code = error_code      # 错误编号，便于前端识别处理
        self.message = message            # 可读性错误说明
        super().__init__(f"[{error_code}] {message}")

class InsufficientBalanceError(OrderError):
    """当账户余额不足以支付订单时触发"""
    def __init__(self, balance, need):
        super().__init__(1001, f"余额不足，当前余额：{balance}，所需金额：{need}")

class OrderNotFoundError(OrderError):
    """订单 ID 不存在时抛出"""
    def __init__(self, order_id):
        super().__init__(1002, f"订单 {order_id} 不存在")

class OrderStatusError(OrderError):
    """订单处于不允许操作的状态（如已取消仍尝试支付）"""
    def __init__(self, order_id, current_status):
        super().__init__(1003, f"订单 {order_id} 状态异常，当前状态：{current_status}")

接下来是具体的业务函数实现，在其中根据条件主动抛出自定义异常：

# 2. 模拟创建订单的业务逻辑
def create_order(user_id, order_id, amount):
    """创建订单前检查用户余额及订单状态"""
    user_balance = 500  # 模拟用户当前余额

existing_orders = {"OD12345": "已支付"}  # 已存在的订单

# 检查订单是否已存在
if order_id in existing_orders:
    raise OrderStatusError(order_id, existing_orders[order_id])

# 验证用户余额是否足够支付
if user_balance < amount:
    raise InsufficientBalanceError(user_balance, amount)

# 若无异常，则成功创建订单
print(f"订单 {order_id} 创建成功，用户 {user_id} 支付金额：{amount}")

3. 调用业务函数并捕获自定义异常

try:
    create_order(user_id=1001, order_id="OD12345", amount=600)
except InsufficientBalanceError as e:
    print(f"创建订单失败（余额问题）：{e.message}，错误码：{e.error_code}")
except OrderNotFoundError as e:
    print(f"创建订单失败（订单不存在）：{e.message}，错误码：{e.error_code}")
except OrderStatusError as e:
    print(f"创建订单失败（状态问题）：{e.message}，错误码：{e.error_code}")
except OrderError as e:
    # 基类异常兜底处理所有未明确捕获的订单相关错误
    print(f"创建订单失败：{e.message}，错误码：{e.error_code}")

创建订单失败（状态问题）：订单 OD12345 状态异常，当前状态：已支付，错误码：1003

二、调试技巧详解

在开发过程中，调试是定位和修复代码逻辑错误与异常根源的关键步骤。Python 提供了三种主要的调试方式：打印调试、断点调试和日志记录调试。它们分别适用于不同阶段——开发初期快速验证、复杂嵌套逻辑分析以及生产环境问题追踪。

2.1 打印调试法

通过插入 print() 语句输出变量状态或执行流程，适合用于小型脚本或简单逻辑的即时排查。其优势在于实现简单、无需额外工具；但缺点是调试完成后需手动清理打印语句，容易遗漏，影响代码整洁性。

关键使用技巧：

• 输出变量类型与值：利用 print(type(var)) 和 print(var) 结合查看数据形态，帮助识别类型不匹配问题；
• 标记程序执行路径：在条件分支或循环结构中加入如 print("进入 if 分支") 的提示信息，确认控制流走向；
• 输出中间计算结果：在多步运算中插入打印，例如 print(f"第 {i} 步结果: {result}")，便于发现偏差发生的具体位置。

实战案例：使用打印调试发现冒泡排序中的逻辑缺陷

def bubble_sort(nums):
    """冒泡排序函数（含逻辑错误）"""
    n = len(nums)
    for i in range(n):
        # 输出当前轮次及数组状态
        print(f"第 {i+1} 轮开始，数组：{nums}")
        for j in range(n - i):  # 错误点：应为 range(n - i - 1)
            # 显示当前比较的两个元素
            print(f"  比较 j={j} ({nums[j]}) 和 j+1={j+1} ({nums[j+1]})")
            if nums[j] > nums[j+1]:
                # 交换后立即输出新状态
                nums[j], nums[j+1] = nums[j+1], nums[j]
                print(f"  交换后数组：{nums}")
    return nums

# 测试用例
test_nums = [3, 1, 4, 1, 5]
sorted_nums = bubble_sort(test_nums)
print("最终排序结果：", sorted_nums)

通过观察打印日志可发现：在最后一轮循环中仍对已完成排序的末尾元素进行无效比较，甚至可能引发索引越界问题。由此可判断内层循环边界设置有误，正确写法应为 range(n - i - 1)。

index out of range

range(n - i - 1)

2.2 断点调试技术

断点调试依赖于集成开发环境（IDE），如 PyCharm 或 VS Code，允许开发者在指定代码行设置暂停点，从而逐行执行程序、实时查看变量值、跟踪函数调用栈。该方法特别适用于处理深层嵌套、复杂条件判断或多层函数调用的场景。

操作流程（以 VS Code 为例）：

1. 设置断点：点击代码行号左侧区域，出现红色圆点表示断点已设定，通常放置于疑似出错行或关键逻辑入口处；
2. 启动调试模式：点击 IDE 左侧“运行和调试”图标，选择“Python 文件”配置并运行，程序将在首个断点处暂停；
3. 控制执行流程：
   • 单步跳过（F10）：执行当前行，不深入函数内部；
   • 单步进入（F11）：若当前行为函数调用，则进入其内部逐行执行；
   • 继续执行（F5）：从当前断点继续运行至下一个断点；
   • 跳出函数（Shift+F11）：结束当前函数内部执行，返回上一层调用。
4. 查看运行时状态：调试面板提供“变量”窗口（显示局部/全局变量值）、“调用栈”视图（展示函数调用层级关系）以及“断点列表”管理功能。

实战应用：通过断点调试定位阶乘函数返回值异常

假设某阶乘函数返回结果不符合预期，可通过设置断点逐步检查每次递归调用中的参数变化与返回值传递过程，快速锁定错误发生的精确位置。

print

print(f"变量名: {var}, 类型: {type(var)}")

print("进入 if 分支")

print(f"步骤1结果: {res1}")

def factorial(n):
    """计算 n 的阶乘（存在逻辑错误）"""
    result = 1
    if n < 0:
        return "输入不能为负数"
    while n > 0:
        result *= n
        n += 1  # 错误：应为 n -= 1
    return result

# 测试阶乘
print(factorial(5))  # 预期输出 120，实际进入死循环

该函数旨在实现阶乘的计算功能，但其中包含一个关键性逻辑缺陷。当传入一个正整数时，程序本应逐步将 n 递减至 0 以结束循环，然而在循环体内却执行了 n += 1 操作，导致变量 n 不断增大，始终满足循环条件 n > 0，从而引发无限循环。

正确的处理方式应当是在每次迭代中将 n 减 1，即修改为 n -= 1，这样才能确保循环在有限步骤后终止，并正确完成阶乘运算。例如，factorial(5) 应依次计算 5 × 4 × 3 × 2 × 1，最终返回结果 120。

此外，函数对负数输入进行了合理判断并返回提示信息，这部分逻辑是正确的，无需修改。整体结构清晰，仅需修正递减操作即可恢复正常功能。