第6章 6.2 自定义异常与异常链

上一章我们学会了用 try/except/finally 捕捉异常，就像学会了「如果出错了就这样补救」的套路。但你有没有遇到过这种情况：内置的那几种异常类型根本描述不清你的问题，比如「用户输入的密码太简单了」「商品库存不够了」——这些业务逻辑上的「错」，Python 内置异常根本没法准确表达。

这一章，我们来学怎么自己造错误，让程序不仅知道「出错了」，还知道「错在哪、为什么错、该怎么处理」。学完之后，你写的代码会变成一个有「自我解释能力」的系统。

🎯 开场 3 分钟：为什么要学这个？

痛点场景：你在写一个用户注册系统，内置的 ValueError 根本说不清是「邮箱格式不对」还是「密码太简单」。你写了几百行代码，出错了只知道「哦，报错了」，却不知道具体是哪个环节出了问题。

两个核心问题：
1. 内置异常不够用——你需要一个「能精准描述业务问题」的错误类型
2. 异常信息断层——当你 except 了一个异常再抛出去，原来的错误原因就丢了

学完本文能解决：
- 写出精准定位问题的自定义异常类
- 用异常链追踪「连环炸」问题的根源
- 设计一套自己的错误处理体系

🧱 基础 25 分钟：核心概念

什么是自定义异常？

类比：你去餐厅吃饭，内置异常就像「菜品有问题」「服务态度差」这种笼统差评。但如果你想写「宫保鸡丁太咸了，花椒放多了」这种具体问题，标准菜单就不够用了——你得自己造一个「投诉表单」。

为什么要用：想象你写一个计算器，除了除以零这种数学错误，你还想区分「溢出」「格式错误」「用户取消了」——每种情况处理方式不同，用内置的 ValueError 全都混在一起，根本分不清。

怎么用——只需记住三点：继承 Exception、起个好名字、记得 super().__init__()：

# 1. 继承 Exception 是必须的，这是 Python 的规矩
class PasswordTooShortError(Exception):
def __init__(self, password, min_length):
    # super().__init__() 让异常能打印出自定义消息
    super().__init__(f"密码长度 {len(password)} 不足 {min_length} 位")
    self.password = password
    self.min_length = min_length

# 2. 用 raise 抛出这个异常
password = "123"
if len(password) < 6:
raise PasswordTooShortError(password, 6)

运行结果：

Traceback (most recent call last):
File "demo.py", line 10, in <module>
raise PasswordTooShortError(password, 6)
__main__.PasswordTooShortError: 密码长度 3 不足 6 位

代码解释：当密码太短时，raise 抛出我们自定义的 PasswordTooShortError，Python 自动调用 __init__ 把错误信息组装好。这个错误和内置错误一样，可以被 try/except 捕捉。

自定义异常的「标准写法」

一个专业的自定义异常类，通常包含两个部分：

class ValidationError(Exception):
"""验证失败的异常，名字通常以 Error 结尾"""
def __init__(self, field, message):
    self.field = field  # 记录哪个字段出错了
    self.message = message  # 记录具体原因
    super().__init__(f"{field}: {message}")

# 抛出时指定详细信息
raise ValidationError("邮箱", "格式不符合规范")

输出：

Traceback (most recent call last):
File "demo.py", line 8, in <module>
raise ValidationError("邮箱", "格式不符合规范")
__main__.ValidationError: 邮箱: 格式不符合规范

异常链：追踪问题的根源

类比：想象多米诺骨牌倒塌，第一块是被你推倒的，但真正让你在意的是「为什么最后一块砸到了花瓶」——异常链就是帮你追踪「是谁触发了谁」的线索。

Python 里异常链有两种：

第一种：主动设置异常链 __cause__

try:
int("hello")  # 这里会报 ValueError
except ValueError as e:
# 主动抛出新异常，并说明"因为"什么
raise RuntimeError("字符串转整数失败了") from e

# 输出结果：
# Traceback (most recent call last):
#   File "demo.py", line 2, in <module>
#     int("hello")
# ValueError: invalid literal for int() with base 10: 'hello'
# 
# The above exception was the direct cause of the following exception:
# 
# RuntimeError: 字符串转整数失败了

注意看输出里的 "was the direct cause of"——这行字就是 from e 加上去的，告诉你「我是被他害的」。

第二种：自动记录的 __context__

def outer():
try:
    int("world")  # 第一层异常
except ValueError:
    raise RuntimeError("外层出错了")  # 抛出第二层异常

outer()

输出：

Traceback (most recent call last):
File "demo.py", line 5, in <module>
raise RuntimeError("外层出错了")
RuntimeError: 外层出错了

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
File "demo.py", line 3, in <module>
int("world")
ValueError: invalid literal for int() with base 10: 'world'
RuntimeError: 外层出错了
During handling of the above exception, another exception occurred:

这里 "During handling of the above exception, another exception occurred" 就是在说「处理一个异常的时候又出新的了」——Python 自动帮你保留了现场。

raise from None：静默异常链

有时候你不希望显示完整的异常链（比如安全敏感信息），用 raise from None：

try:
int("secret")  # 假设这是敏感操作
except ValueError:
raise RuntimeError("操作失败") from None

# 输出：
# Traceback (most recent call last):
#   File "demo.py", line 3, in <module>
#     raise RuntimeError("操作失败") from None
# RuntimeError: 操作失败

没有了「During handling」那段的详细堆栈——这样用户只看到最终错误，不暴露内部细节。

🔥 实战 35 分钟：3 个递进的小项目

项目 1（5 分钟）：密码强度验证器

目标：用自定义异常实现一个多层次密码验证

class PasswordError(Exception):
"""密码验证基类"""
def __init__(self, message):
    super().__init__(message)

class PasswordTooShortError(PasswordError):
"""密码太短"""
pass

class PasswordNoNumberError(PasswordError):
"""密码没有数字"""
pass

class PasswordNoUpperError(PasswordError):
"""密码没有大写字母"""
pass

def validate_password(password):
"""验证密码强度"""
if len(password) < 8:
    raise PasswordTooShortError("密码至少需要8位")
if not any(c.isdigit() for c in password):
    raise PasswordNoNumberError("密码必须包含数字")
if not any(c.isupper() for c in password):
    raise PasswordNoUpperError("密码必须包含大写字母")
return "密码验证通过！"

# 测试几个密码
test_passwords = ["abc", "abcdefgh", "abcdefghi", "ABCDEFGH"]

for pwd in test_passwords:
try:
    result = validate_password(pwd)
    print(f"'{pwd}': {result}")
except PasswordError as e:
    print(f"'{pwd}': ❌ {e}")

预期输出：

'abc': ❌ 密码至少需要8位
'abcdefgh': ❌ 密码必须包含数字
'abcdefghi': ❌ 密码必须包含大写字母
'ABCDEFGH': ❌ 密码必须包含数字

解释：你看，通过继承同一个基类 PasswordError，我们可以用一个 except 捕捉所有密码相关错误，同时又能区分具体类型做不同处理。

项目 2（15 分钟）：CSV 数据清洗工具 with 异常链

目标：读取一个 CSV 文件，跳过格式错误的行，记录错误原因

import csv
import io

class DataValidationError(Exception):
"""数据验证错误基类"""
def __init__(self, row_num, message):
    self.row_num = row_num
    super().__init__(f"第{row_num}行: {message}")

class MissingFieldError(DataValidationError):
"""缺少字段"""
pass

class InvalidFormatError(DataValidationError):
"""格式错误"""
pass

def parse_csv_with_validation(csv_data):
"""解析 CSV 并验证数据"""
results = []
errors = []
reader = csv.DictReader(io.StringIO(csv_data))

for row_num, row in enumerate(reader, start=2):  # 第2行开始，第1行是表头
    try:
        # 验证姓名
        if not row.get("姓名"):
            raise MissingFieldError(row_num, "缺少姓名")

        # 验证年龄
        age_str = row.get("年龄", "")
        if not age_str.isdigit():
            raise InvalidFormatError(row_num, f"年龄 '{age_str}' 不是有效数字")
        age = int(age_str)
        if age < 0 or age > 150:
            raise InvalidFormatError(row_num, f"年龄 {age} 不合理")

        results.append({"姓名": row["姓名"], "年龄": age})

    except DataValidationError as e:
        # 记录错误，但不中断整个处理
        errors.append(e)
        print(f"⚠️ 跳过: {e}")

return results, errors

# 测试数据
test_csv = """姓名,年龄,城市
张三,25,北京
李四,hello,上海
王五,,深圳
赵六,30,广州"""

results, errors = parse_csv_with_validation(test_csv)

print(f"\n✅ 成功解析 {len(results)} 条记录:")
for r in results:
print(f"  - {r['姓名']}, {r['年龄']}岁")
print(f"\n❌ 共跳过 {len(errors)} 条错误数据")

预期输出：

⚠️ 跳过: 第3行: 年龄 'hello' 不是有效数字
⚠️ 跳过: 第4行: 缺少姓名

✅ 成功解析 2 条记录:
- 张三, 25岁
- 赵六, 30岁

❌ 共跳过 2 条错误数据

解释：这个例子展示了怎么用异常链把「CSV 解析」和「数据验证」解耦。每行数据有问题时抛出一个带行号的自定义异常，主循环负责收集这些异常而不是被它中断。

项目 3（15 分钟）：一个带异常追踪的配置加载器

目标：从 JSON 文件加载配置，层层捕获异常，最后给用户一个清晰的报错

import json

class ConfigError(Exception):
"""配置错误基类"""
pass

class ConfigFileNotFoundError(ConfigError):
"""配置文件不存在"""
pass

class ConfigFormatError(ConfigError):
"""配置格式错误"""
pass

class ConfigKeyError(ConfigError):
"""缺少必要的配置项"""
pass

def load_config(filename):
"""加载配置文件，验证必填项"""
# 第1层：文件操作
try:
    with open(filename, "r", encoding="utf-8") as f:
        content = f.read()
except FileNotFoundError as e:
    raise ConfigFileNotFoundError(f"配置文件 '{filename}' 不存在") from e

# 第2层：JSON 解析
try:
    config = json.loads(content)
except json.JSONDecodeError as e:
    raise ConfigFormatError(f"JSON 格式错误: {e}") from e

# 第3层：验证必填项
required_keys = ["app_name", "port"]
for key in required_keys:
    if key not in config:
        raise ConfigKeyError(f"缺少必需的配置项: '{key}'")

return config

# 模拟场景测试
def test_scenario(scenario_name, filename):
print(f"\n{'='*50}")
print(f"场景: {scenario_name}")
print(f"{'='*50}")

# 创建临时测试文件
if filename == "missing.json":
    filename = "/tmp/test_config.json"
    import os
    if os.path.exists(filename):
        os.remove(filename)
else:
    # 创建包含错误内容的文件
    with open("/tmp/test_config.json", "w") as f:
        if filename == "bad_json":
            f.write('{"app_name": "myapp", port: 8080}')  # JSON 语法错误
        elif filename == "missing_key":
            f.write('{"app_name": "myapp"}')  # 缺少 port
        else:
            f.write('{"app_name": "myapp", "port": 8080}')
    filename = "/tmp/test_config.json"

try:
    config = load_config(filename)
    print(f"✅ 配置加载成功: {config}")
except ConfigError as e:
    print(f"❌ 配置错误: {e}")
    if e.__cause__:
        print(f"   原因: {e.__cause__}")

# 运行测试
test_scenario("正常配置", "valid")
test_scenario("JSON语法错误", "bad_json")
test_scenario("缺少必填项", "missing_key")
test_scenario("文件不存在", "missing.json")

预期输出：

==================================================
场景: 正常配置
==================================================
✅ 配置加载成功: {'app_name': 'myapp', 'port': 8080}

==================================================
场景: JSON语法错误
==================================================
❌ 配置错误: JSON 格式错误: Expecting property name enclosed in double quotes
因: invalid literal for int() with base 10: 'port'

==================================================
场景: 缺少必填项
==================================================
❌ 配置错误: 缺少必需的配置项: 'port'

==================================================
场景: 文件不存在
==================================================
❌ 配置错误: 配置文件 '/tmp/test_config.json' 不存在
因: [Errno 2] No such file or directory: '/tmp/test_config.json'

解释：这个项目的精髓在于异常链的层层传递。从文件找不到 → JSON 解析失败 → 配置项缺失，每一层都抛出一个自定义异常，同时保留原始错误原因。这样排查问题时，你能看到完整的「错误链路图」。

💪 进阶 20 分钟：常见坑 + 性能小贴士

坑 1：忘记 super().__init__()

# ❌ 错误写法
class MyError(Exception):
def __init__(self, msg):
    self.msg = msg  # 只保存了，没传给基类

try:
raise MyError("test")
except MyError as e:
print(str(e))  # 输出为空！

# ✅ 正确写法
class MyError(Exception):
def __init__(self, msg):
    self.msg = msg
    super().__init__(msg)  # 别忘了这行！

try:
raise MyError("test")
except MyError as e:
print(str(e))  # 输出: test

解释：Exception 的 __str__ 方法依赖 super().__init__() 传递的消息，不调用它就打印不出任何东西。

坑 2：异常类命名不规范

# ❌ 随意命名
class bad_error(Exception):
pass

# ✅ 规范命名：以 Error 结尾，驼峰式
class InvalidInputError(Exception):
pass

解释：Python 的风格指南 PEP8 要求异常名使用 CapWords 模式（即 PascalCase），并且通常以 Error 结尾（如果是用于正常的控制流，则用 Exception）。

坑 3：滥用异常替代 if 判断

# ❌ 把异常当 if 用
def get_element(lst, index):
try:
    return lst[index]
except IndexError:
    raise IndexError("索引超出范围")

# ✅ 该用 if 用 if
def get_element(lst, index):
if index >= len(lst):
    raise IndexError("索引超出范围")
return lst[index]

解释：异常是为了「真正异常的情况」准备的，如果边界条件是可预期的（比如用户输入），应该用 if 判断先检查，而不是用 try/except 捕异常。

坑 4：raise 不带 from 导致原因丢失

# ❌ 丢失异常链
try:
int("x")
except ValueError as e:
raise RuntimeError("失败了")  # 原来的 e 丢了

# ✅ 保留异常链
try:
int("x")
except ValueError as e:
raise RuntimeError("失败了") from e  # 用 from e 保留原因

解释：当你需要重新抛出异常时，用 from 显式指明因果关系，方便调试时看到完整的堆栈。

坑 5：在 __init__ 里做太多事

# ❌ 在异常类里写业务逻辑
class UserError(Exception):
def __init__(self, user_id):
    super().__init__(f"用户 {user_id} 有问题")
    self.user = load_user_from_db(user_id)  # 异常里查数据库？

# ✅ 异常只存数据
class UserError(Exception):
def __init__(self, user_id, message):
    super().__init__(message)
    self.user_id = user_id

解释：异常对象可能被序列化或跨进程传递，在异常里执行 IO 操作既危险又低效。

性能小贴士：异常创建有成本

# 低效：频繁创建异常
def process(data):
if not data:
    raise ValueError("空数据")  # 每次都新建对象
return data

# 高效：用预定义异常
EMPTY_DATA_ERROR = ValueError("空数据")  # 提前建好

def process(data):
if not data:
    raise EMPTY_DATA_ERROR  # 复用同一个对象

解释：在循环里大量抛出异常时，异常对象的创建有开销。如果你能预判到某种错误会频繁发生，可以考虑复用异常对象。

调试技巧：打印异常链

try:
risky_operation()
except Exception as e:
print("=== 异常详情 ===")
print(f"类型: {type(e).__name__}")
print(f"消息: {e}")
print(f"原因: {e.__cause__}")
print(f"上下文: {e.__context__}")
import traceback
print("完整堆栈:")
traceback.print_exc()

✏️ 练习题 + 作业题

练习题（5 道，10 分钟内完成）

练习 1（2 分钟）：继承一个异常
- 输入：下面代码，运行后预期抛出 AgeError
- 预期输出：AgeError: 年龄 -5 不合理
- 提示：继承 Exception，在 __init__ 里调用 super().__init__()

class AgeError(Exception):
# 在这里写代码

raise AgeError(-5)

练习 2（2 分钟）：添加异常链
- 输入：给定一个 divide(a, b) 函数，要求用 raise X from Y 补充异常链
- 预期输出：看到 "was the direct cause of" 字样
- 提示：用 ZeroDivisionError 作为原始异常

练习 3（2 分钟）：多异常捕获
- 输入：3 个自定义异常类，写一个 try/except 统一处理
- 预期输出：根据不同异常输出不同「错因」描述
- 提示：先写 3 个异常类，再写一个 try 块

练习 4（2 分钟）：CSV 异常处理
- 输入：一段有问题的 CSV 数据，用项目 2 的方法处理
- 预期输出：跳过错误行，成功解析有效行
- 提示：检查字段是否存在、值是否合法

练习 5（2 分钟）：分析异常链
- 输入：给一段报错代码截图（用户自己提供）
- 预期输出：说出「哪里出错了」「根本原因是什么」
- 提示：看 __cause__ 和 __context__ 的值

作业题（30 分钟 - 2 小时）

作业：做一个「数据验证工具箱」

需求描述：写一个工具，能验证用户输入的多种数据（姓名、邮箱、手机号、密码），每种验证失败都抛出一个自定义异常，所有异常继承同一个基类。

功能点：
1. 定义 4+ 个自定义异常（姓名空、邮箱格式、手机的码格式、密码强度等）
2. 写 4+ 个验证函数，返回 True 或抛出异常
3. 主程序循环读取用户输入，验证通过打印 ✅，失败打印 ❌ 并说明原因
4. 用 raise from 在适当地方建立异常链

加分项：
1. 把验证函数做成装饰器
2. 支持从 JSON 文件加载验证规则

验收标准：
- 能运行起来
- 输入无效数据时报错清晰
- 代码有注释
- 异常链能追溯到根本原因

提交方式：评论区贴代码或 GitHub 链接

📚 总结 + 资源

本文学到的 3 个核心点：
- 自定义异常就是继承 Exception，用 super().__init__() 传递消息
- 异常链 __cause__ 是主动设置的因果，__context__ 是自动传播的嵌套
- raise X from Y 能清晰表达「我是被他害的」，方便排查连环炸问题

延伸学习资源：
- Python 官方文档 - 自定义异常
- Python 官方文档 - 异常链
- 《Python 编程：从入门到实践》第 8 章「异常」

互动钩子：你在实际项目里有没有遇到过「异常信息太模糊，根本不知道错在哪」的情况？当时是怎么解决的？评论区聊聊老粉优先回复！

下一章我们要学「调试技巧：print/pdb/logging」——学会了这一章的自定义异常后，下一章你会发现调试时打的 print 不够用了，我们需要更强大的工具来追踪程序的「心跳」。