python异常-异常篇

🐍 Python异常处理：从“崩溃”到优雅的艺术

引言：为什么你的代码会“发脾气”？

想象一下：你正在和一个Python程序愉快地对话，突然它“砰”地一声崩溃了，留下一堆红色的错误信息。这不是它在闹情绪，而是在用异常的方式告诉你：“嘿，这里有问题！”今天，我们就来学习如何与这些“小脾气”和谐相处。

第一章：认识Python的“异常家族”

Python内置了一个庞大的异常家族，每个成员都有独特的“性格”。认识它们是处理异常的第一步。

常见的异常类型（从常见到不常见）

# 让我们通过实例来认识它们
def meet_the_exceptions():
    # 1. ZeroDivisionError - 数学老师的噩梦
    # 1 / 0  # 取消注释会触发
    
    # 2. TypeError - 类型不匹配的尴尬
    # "2" + 2  # 字符串和数字不能直接相加
    
    # 3. ValueError - 值不对，但类型对
    # int("我不是数字")
    
    # 4. IndexError - 数组越界的悲剧
    # lst = [1, 2, 3]
    # print(lst[10])
    
    # 5. KeyError - 字典里找不到钥匙
    # d = {"name": "Python"}
    # print(d["age"])
    
    # 6. FileNotFoundError - 文件失踪案件
    # open("不存在的文件.txt")
    
    # 7. AttributeError - 对象没有这个属性
    # num = 42
    # num.say_hello()
    
    # 8. ImportError - 导入失败的悲伤
    # import 不存在的模块
    
    # 9. ModuleNotFoundError - Python 3.6+ 的ImportError亲戚
    # 同上
    
    # 10. KeyboardInterrupt - 用户按了Ctrl+C
    # 试试在运行程序时按Ctrl+C
    
    # 11. SyntaxError - 语法错误（无法捕获，因为发生在编译时）
    # print("忘了右引号)
    
    # 12. IndentationError - 缩进错误（SyntaxError的子类）
    # def wrong():
    # print("没缩进")
    
    # 13. NameError - 名字未定义
    # print(undefined_variable)
    
    # 14. AssertionError - assert语句失败
    # assert 1 == 2, "数学崩塌了"
    
    # 15. StopIteration - 迭代器没东西了
    # it = iter([1, 2])
    # next(it); next(it); next(it)
    
    # 16. RuntimeError - 运行时一般错误
    # 很多其他异常的基类
    
    # 17. NotImplementedError - 抽象方法没实现
    # class Base:
    #     def must_implement(self):
    #         raise NotImplementedError("子类必须实现我！")
    
    # 18. MemoryError - 内存不足
    # x = [0] * (10**10)  # 可能需要大量内存
    
    # 19. OverflowError - 数值溢出
    # import math
    # math.exp(1000)  # 在某些情况下
    
    # 20. UnicodeError - 编码相关错误的基类
    # "你好".encode('ascii')  # UnicodeEncodeError
    
    # 21. PermissionError - 没有权限（OSError的子类）
    # 尝试写入只读文件
    
    # 22. TimeoutError - 超时
    # 某些网络操作
    
    print("没有触发异常，一切正常！")

meet_the_exceptions()

第二章：异常处理的”防弹衣” - try-except结构

2.1 基础款防弹衣：单个异常捕获

def basic_armor():
    try:
        # 危险的代码区域
        result = 10 / 0
        print(f"结果是: {result}")
    except ZeroDivisionError:
        # 当捕获到ZeroDivisionError时执行
        print("捕获到除零错误！别担心，我来处理。")
        print("给结果一个安全值：inf")
        result = float('inf')
    return result

print(basic_armor())

2.2 多功能防弹衣：多个异常匹配

def multi_catch_armor():
    """一个except处理多个异常"""
    try:
        user_input = input("请输入一个数字: ")
        number = float(user_input)
        result = 100 / number
        print(f"100除以你的数字是: {result}")
    except (ValueError, ZeroDivisionError) as e:
        # 同时处理两种异常
        if isinstance(e, ValueError):
            print(f"'{user_input}'不是有效的数字！")
        else:
            print("不能除以零！")
        result = None
    return result

multi_catch_armor()

2.3 分层防弹衣：多层except

def layered_armor():
    """多个except，按顺序匹配"""
    try:
        data = {"name": "Python", "version": 3.9}
        
        # 第一层危险操作
        version = data["version"]
        
        # 第二层危险操作
        result = 100 / (version - 3.9)  # 这里会除零！
        
    except KeyError as e:
        print(f"键错误: 找不到键 {e}")
    except ZeroDivisionError:
        print("除零错误！")
        # 我们可以修复并继续
        result = float('inf')
    except Exception as e:
        # 捕获所有其他异常（谨慎使用！）
        print(f"发生了未知错误: {type(e).__name__}: {e}")
    else:
        # 如果没有异常发生
        print(f"计算成功，结果是: {result}")
    finally:
        # 无论是否发生异常都会执行
        print("清理工作完成！")
    
    return result

layered_armor()

2.4 豪华防弹衣：完整的try-except-else-finally

def luxury_armor(filename):
    """完整的异常处理流程"""
    file = None
    try:
        print("尝试打开文件...")
        file = open(filename, 'r')
        content = file.read()
        
    except FileNotFoundError:
        print(f"文件 {filename} 不存在！")
        content = "默认内容"
        
    except PermissionError:
        print("没有读取权限！")
        content = ""
        
    else:
        print("文件读取成功！")
        # 这里可以处理读取到的内容
        processed = content.upper()[:50]
        print(f"前50个字符（大写）: {processed}")
        
    finally:
        print("进入finally块...")
        if file:
            file.close()
            print("文件已关闭")
            
    return content

# 测试不同的场景
print("测试1: 文件存在")
# luxury_armor("existing_file.txt")  # 假设存在

print("\n测试2: 文件不存在")
luxury_armor("non_existent_file.txt")

第三章：主动出击 - raise和assert

3.1 raise：主动抛出异常

def proactive_raising():
    """有时候我们需要主动抛出异常"""
    
    def process_age(age):
        """处理年龄，有严格的规则"""
        if not isinstance(age, (int, float)):
            raise TypeError(f"年龄必须是数字，而不是 {type(age).__name__}")
        
        if age < 0:
            raise ValueError("年龄不能为负数！")
            
        if age > 150:
            raise ValueError("年龄不能超过150岁！")
            
        return f"年龄 {age} 验证通过！"
    
    # 测试各种情况
    test_cases = [25, -5, "二十五", 200, 0.5]
    
    for age in test_cases:
        try:
            result = process_age(age)
            print(f"✓ {age}: {result}")
        except (TypeError, ValueError) as e:
            print(f"✗ {age}: {e}")
    
    # 重新抛出异常
    def risky_operation():
        try:
            x = 1 / 0
        except ZeroDivisionError:
            print("捕获到错误，但决定不处理，继续抛出...")
            raise  # 重新抛出当前异常
    
    try:
        risky_operation()
    except ZeroDivisionError:
        print("外层捕获到了重新抛出的异常！")

proactive_raising()

3.2 assert：断言（程序的自信检查）

def confident_assertions():
    """assert是程序的自信检查"""
    
    def calculate_bmi(weight, height):
        """计算BMI指数"""
        # 前提条件检查
        assert weight > 0, "体重必须为正数"
        assert height > 0, "身高必须为正数"
        assert isinstance(weight, (int, float)), "体重必须是数字"
        assert isinstance(height, (int, float)), "身高必须是数字"
        
        bmi = weight / (height ** 2)
        
        # 后置条件检查
        assert bmi > 0, "BMI应该为正数"
        
        return bmi
    
    # 正常情况
    print(f"正常BMI: {calculate_bmi(70, 1.75):.2f}")
    
    # 异常情况
    try:
        calculate_bmi(-70, 1.75)
    except AssertionError as e:
        print(f"断言失败: {e}")
    
    # assert的等价写法
    def equivalent_assert(condition, message=None):
        """assert condition, message 的等价写法"""
        if not condition:
            raise AssertionError(message if message else "")
    
    # assert用于调试
    def process_data(data):
        """处理数据，使用assert进行调试"""
        # 只在开发时启用
        assert len(data) > 0, "数据不能为空"
        assert all(isinstance(x, (int, float)) for x in data), "数据必须为数字"
        
        # 实际处理逻辑
        return sum(data) / len(data)
    
    print(f"\n使用-O参数运行Python可以禁用assert：")
    print("python -O script.py  # assert语句会被忽略")

confident_assertions()

第四章：异常嵌套 - 俄罗斯套娃式错误处理

def russian_doll_exceptions():
    """异常也可以像俄罗斯套娃一样嵌套"""
    
    print("开始执行多层嵌套的异常处理...")
    
    try:  # 外层try
        print("进入外层try块")
        
        try:  # 中层try
            print("进入中层try块")
            
            try:  # 内层try
                print("进入内层try块")
                result = 10 / 0  # 这里会触发异常
                
            except ZeroDivisionError as e:
                print("内层捕获到除零错误")
                # 不处理，重新抛出
                print("内层决定重新抛出异常...")
                raise ValueError("内层转换了异常类型") from e
                
            finally:
                print("内层finally执行")
                
        except ValueError as e:
            print(f"中层捕获到值错误: {e}")
            print(f"异常链: {e.__cause__}")  # 查看原始异常
            
        finally:
            print("中层finally执行")
            
    except Exception as e:
        print(f"外层捕获到异常: {type(e).__name__}")
        
    finally:
        print("外层finally执行")
    
    print("\n异常链示例:")
    try:
        try:
            x = 1 / 0
        except ZeroDivisionError as e1:
            raise RuntimeError("处理除零错误时出错") from e1
    except RuntimeError as e2:
        print(f"当前异常: {e2}")
        print(f"原因异常: {e2.__cause__}")
        print(f"追溯原始异常: {e2.__cause__.__class__.__name__}")

russian_doll_exceptions()

第五章：实战应用 - 构建健壮的函数

def robust_calculator():
    """一个健壮的计算器函数"""
    
    def safe_calculate(operation, a, b):
        """
        安全的计算函数
        
        Args:
            operation: 操作类型 ('add', 'sub', 'mul', 'div')
            a, b: 操作数
            
        Returns:
            计算结果或错误信息
        """
        # 输入验证
        if operation not in ['add', 'sub', 'mul', 'div']:
            raise ValueError(f"不支持的操作: {operation}")
        
        if not all(isinstance(x, (int, float)) for x in [a, b]):
            raise TypeError("操作数必须是数字")
        
        # 执行计算
        try:
            if operation == 'add':
                result = a + b
            elif operation == 'sub':
                result = a - b
            elif operation == 'mul':
                result = a * b
            elif operation == 'div':
                if b == 0:
                    raise ZeroDivisionError("除数不能为零")
                result = a / b
                
            # 验证结果
            assert isinstance(result, (int, float)), "计算结果应该是数字"
            
        except ZeroDivisionError as e:
            return f"错误: {e}"
        except Exception as e:
            # 记录日志（这里用print模拟）
            print(f"[ERROR] 计算失败: {e}")
            raise  # 重新抛出给调用者
            
        else:
            # 计算成功，可以做一些后处理
            if isinstance(result, float):
                result = round(result, 10)  # 限制精度
                
        finally:
            # 清理资源（如果有的话）
            print(f"[INFO] 计算 {operation}({a}, {b}) 完成")
            
        return result
    
    # 测试各种情况
    test_cases = [
        ('add', 10, 5),
        ('div', 10, 2),
        ('div', 10, 0),
        ('mul', 3.14, 2),
        ('unknown', 1, 2),  # 会触发ValueError
        ('add', '10', 5),   # 会触发TypeError
    ]
    
    for op, a, b in test_cases:
        try:
            result = safe_calculate(op, a, b)
            print(f"{op}({a}, {b}) = {result}")
        except (ValueError, TypeError) as e:
            print(f"{op}({a}, {b}) 失败: {e}")
        print("-" * 40)

robust_calculator()

第六章：最佳实践和小贴士

def exception_best_practices():
    """异常处理的最佳实践"""
    
    print("""
    📚 Python异常处理最佳实践：
    
    1. ✅ 具体胜于笼统
       坏： except:  # 捕获所有异常，危险！
       好： except ValueError:  # 只捕获特定异常
       更好： except (ValueError, TypeError) as e:  # 捕获一组相关异常
    
    2. ✅ 不要静默忽略异常
       坏： except: pass  # 错误消失了？不，它只是躲起来了
       好： except Exception as e: logger.error(e)
    
    3. ✅ 使用finally清理资源
       坏： file = open(...)  # 如果出错，文件不会关闭
       好： 使用with语句或try-finally
    
    4. ✅ 异常用于异常情况，不要用于控制流
       坏： 用异常检查键是否存在（应该用in操作符）
       好： 异常用于处理不可预见的错误
    
    5. ✅ 提供有意义的错误信息
       坏： raise ValueError("错误")
       好： raise ValueError(f"年龄{age}无效，必须在0-120之间")
    
    6. ✅ 了解异常层次结构
       BaseException
       ├── KeyboardInterrupt
       ├── SystemExit
       └── Exception
           ├── ValueError
           ├── TypeError
           ├── RuntimeError
           └── ...等
    
    7. ✅ 自定义异常让代码更清晰
       class PaymentError(Exception):
           pass
       
       class InsufficientFundsError(PaymentError):
           pass
    
    8. ✅ 使用异常链（raise ... from ...）
       坏： 捕获异常后抛出新异常，丢失原始信息
       好： raise NewError("消息") from original_error
    """)

exception_best_practices()

结语：与异常成为朋友

异常不是敌人，而是忠实的哨兵。它们不会无缘无故地”发脾气”，只是在尽职地告诉你：”这里有问题需要关注！”

记住这些要点：

• 🔍 具体捕获：知道你在捕获什么
• 📝 清晰信息：提供有用的错误信息
• 🧹 及时清理：使用finally或with语句
• 🎯 合理使用：异常用于异常情况，不要滥用
• 🔗 保持链：使用异常链保留完整的错误历史

现在，当你的代码再次”发脾气”时，你可以微笑着说：”别担心，我知道怎么处理！”

---

# 最后的趣味测试
def exception_quiz():
    """测测你对异常的理解"""
    
    questions = [
        {
            "q": "1. 下面哪个异常处理方式最不推荐？",
            "a": "A. except ValueError:",
            "b": "B. except:",
            "c": "C. except (TypeError, ValueError):",
            "answer": "B",
            "explanation": "裸露的except:会捕获所有异常，包括KeyboardInterrupt，这通常不是我们想要的。"
        },
        {
            "q": "2. finally块什么时候执行？",
            "a": "A. 只在没有异常时",
            "b": "B. 只在有异常时",
            "c": "C. 无论是否有异常",
            "answer": "C",
            "explanation": "finally块总是执行，无论是否发生异常。"
        },
        {
            "q": "3. 下面的代码输出什么？\ntry:\n    raise ValueError('错误1')\nexcept ValueError:\n    raise TypeError('错误2')",
            "a": "A. ValueError: 错误1",
            "b": "B. TypeError: 错误2",
            "c": "C. 两种异常",
            "answer": "B",
            "explanation": "第一个异常被捕获，然后抛出了第二个异常。"
        }
    ]
    
    print("🧪 Python异常处理小测验\n")
    for i, q in enumerate(questions, 1):
        print(f"{q['q']}")
        print(f"  {q['a']}")
        print(f"  {q['b']}")
        print(f"  {q['c']}")
        print(f"\n正确答案: {q['answer']}")
        print(f"解释: {q['explanation']}")
        print("-" * 50 if i < len(questions) else "")

exception_quiz()