Python从入门到精通 Python 2025-08-15 190 阅读

第8章 异常处理

异常处理是Python编程中的重要概念，它让我们能够优雅地处理程序运行时可能出现的错误情况。掌握异常处理不仅能让程序更加健壮，还能提供更好的用户体验。本章将深入探讨Python中的异常处理机制，从基本概念到高级应用，帮助读者全面掌握这一重要技能。

本系列文章所使用到的示例源码：Python从入门到精通示例代码

8.1 异常的概念与分类

异常的定义

异常（Exception）是程序在运行时遇到的错误情况。与语法错误不同，异常发生在程序语法正确但执行过程中出现问题的时候。

异常 vs 语法错误
- 语法错误：代码不符合Python语法规则，程序无法启动
- 异常：程序运行时遇到的错误，可以被捕获和处理

# 语法错误示例（程序无法运行）
# print("Hello World"  # 缺少右括号

# 异常示例（程序可以运行，但会在执行时出错）
print(1 / 0)  # ZeroDivisionError异常

异常的传播机制

当异常发生时，Python会沿着调用栈向上传播，直到找到合适的异常处理器或程序终止。

Python中的异常层次结构

Python中的所有异常都继承自BaseException类，形成了一个层次结构：

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- ArithmeticError
      |    +-- ZeroDivisionError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- ValueError
      +-- TypeError
      +-- OSError
      |    +-- FileNotFoundError
      +-- AttributeError
      +-- ImportError

让我们通过代码来验证这个层次结构：

# 查看异常的继承关系
exceptions = [
    ZeroDivisionError(),
    ValueError(),
    TypeError(),
    IndexError(),
    KeyError(),
    FileNotFoundError(),
    AttributeError(),
    ImportError()
]

for exc in exceptions:
    print(f"{type(exc).__name__} -> {type(exc).__bases__[0].__name__}")

输出结果：

ZeroDivisionError -> ArithmeticError
ValueError -> Exception
TypeError -> Exception
IndexError -> LookupError
KeyError -> LookupError
FileNotFoundError -> OSError
AttributeError -> Exception
ImportError -> Exception

常见的内置异常类型

以下是Python中最常见的内置异常类型：

  • ZeroDivisionError：除零错误
  • ValueError：值错误，参数类型正确但值不合适
  • TypeError：类型错误，参数类型不正确
  • IndexError：索引错误，序列索引超出范围
  • KeyError：键错误，字典中不存在指定键
  • FileNotFoundError：文件未找到错误
  • AttributeError：属性错误，对象没有指定属性
  • ImportError：导入错误，无法导入模块
  • NameError：名称错误，使用了未定义的变量

8.2 try-except语句

try-except的基本语法

try-except语句是Python中处理异常的基本结构：

try:
    # 可能出现异常的代码
    pass
except ExceptionType:
    # 异常处理代码
    pass

让我们看一个基本的异常捕获示例：

def test_basic_exception():
    print("基本异常捕获示例")
    try:
        x = 1 / 0
    except ZeroDivisionError as e:
        print(f"捕获到除零异常: {e}")

test_basic_exception()

输出结果：

基本异常捕获示例
捕获到除零异常: division by zero

捕获特定异常

指定异常类型

通过指定具体的异常类型，我们可以针对不同的错误情况进行不同的处理：

def test_specific_exceptions():
    # 测试不同类型的异常
    test_cases = [
        lambda: [1, 2, 3][10],  # IndexError
        lambda: int("abc"),     # ValueError
        lambda: "string" + 5    # TypeError
    ]

    for i, test_case in enumerate(test_cases):
        try:
            test_case()
        except IndexError:
            print(f"测试{i+1}: 捕获到索引错误")
        except ValueError:
            print(f"测试{i+1}: 捕获到值错误")
        except TypeError:
            print(f"测试{i+1}: 捕获到类型错误")

捕获多种异常

多个except块

def test_multiple_exceptions():
    try:
        # 尝试访问不存在的列表索引
        my_list = [1, 2, 3]
        print(my_list[10])
    except IndexError as e:
        print(f"索引错误: {e}")
    except TypeError as e:
        print(f"类型错误: {e}")

    # 使用元组形式捕获多种异常
    try:
        int("abc")
    except (ValueError, TypeError) as e:
        print(f"值错误或类型错误: {e}")

输出结果：

索引错误: list index out of range
值错误或类型错误: invalid literal for int() with base 10: 'abc'

捕获所有异常

使用Exception

def test_catch_all():
    try:
        # 尝试执行一些可能出错的代码
        x = undefined_variable  # 未定义的变量
    except Exception as e:
        print(f"捕获到异常: {type(e).__name__}: {e}")

输出结果：

捕获到异常: NameError: name 'undefined_variable' is not defined

注意：虽然可以使用裸except:来捕获所有异常，但这是不推荐的做法，因为它会捕获包括SystemExit和KeyboardInterrupt在内的所有异常，可能导致程序无法正常退出。

8.3 finally子句

finally子句的作用

finally子句中的代码无论是否发生异常都会执行，通常用于资源清理：

def test_finally():
    try:
        print("尝试打开一个不存在的文件")
        with open("不存在的文件.txt", "r") as f:
            content = f.read()
    except FileNotFoundError as e:
        print(f"文件未找到: {e}")
    finally:
        print("无论是否发生异常，finally块都会执行")

输出结果：

尝试打开一个不存在的文件
文件未找到: [Errno 2] No such file or directory: '不存在的文件.txt'
无论是否发生异常，finally块都会执行

finally vs else子句

else子句只在没有异常时执行：

def test_else():
    try:
        x = 10
        y = 2
        result = x / y
    except ZeroDivisionError:
        print("除数不能为零!")
    else:
        print(f"计算结果: {result}")
    finally:
        print("finally块总是执行")

输出结果：

计算结果: 5.0
finally块总是执行

try-except-finally的完整结构

def complete_exception_handling():
    try:
        # 可能出现异常的代码
        result = 10 / 2
        print(f"计算结果: {result}")
    except ZeroDivisionError:
        # 异常处理代码
        print("不能除以零")
    else:
        # 没有异常时执行
        print("计算成功完成")
    finally:
        # 总是执行的清理代码
        print("清理资源")

8.4 raise语句

主动抛出异常

使用raise语句可以主动抛出异常：

def test_raise():
    try:
        x = -5
        if x < 0:
            raise ValueError("不能使用负数")
    except ValueError as e:
        print(f"捕获到值错误: {e}")

输出结果：

捕获到值错误: 不能使用负数

重新抛出异常

在except块中使用raise可以重新抛出当前异常：

def process_data(data):
    try:
        return 1 / data
    except ZeroDivisionError:
        print("记录错误日志")
        raise  # 重新抛出异常

def main():
    try:
        result = process_data(0)
    except ZeroDivisionError:
        print("在主函数中处理异常")

异常链

使用raise ... from ...可以创建异常链，保留原始异常信息：

def test_exception_chaining():
    try:
        try:
            1 / 0
        except ZeroDivisionError as e:
            # 引发新异常，保留原始异常信息
            raise ValueError("计算过程中出现错误") from e
    except ValueError as e:
        print(f"捕获到值错误: {e}")
        # 打印异常链信息
        if e.__cause__:
            print(f"原始异常: {e.__cause__}")

输出结果：

捕获到值错误: 计算过程中出现错误
原始异常: division by zero

8.5 自定义异常

自定义异常类的创建

创建自定义异常类需要继承Exception类：

class MyCustomError(Exception):
    """自定义异常类"""
    def __init__(self, message, error_code=None):
        self.message = message
        self.error_code = error_code
        super().__init__(self.message)

    def __str__(self):
        if self.error_code:
            return f"{self.message} (错误代码: {self.error_code})"
        return self.message

def test_custom_exception():
    try:
        raise MyCustomError("这是一个自定义异常", 1001)
    except MyCustomError as e:
        print(f"捕获到自定义异常: {e}")
        print(f"错误代码: {e.error_code}")

输出结果：

捕获到自定义异常: 这是一个自定义异常 (错误代码: 1001)
错误代码: 1001

异常类的层次设计

对于复杂的应用，建议设计异常类的层次结构：

# 基础异常类
class ApplicationError(Exception):
    """应用程序基础异常"""
    pass

# 具体异常类
class ValidationError(ApplicationError):
    """数据验证异常"""
    pass

class DatabaseError(ApplicationError):
    """数据库操作异常"""
    pass

class NetworkError(ApplicationError):
    """网络连接异常"""
    pass

# 使用示例
def validate_user_input(data):
    if not data:
        raise ValidationError("输入数据不能为空")
    if len(data) < 3:
        raise ValidationError("输入数据长度不能少于3个字符")

8.6 异常处理最佳实践

异常处理的原则

  1. 具体异常优于通用异常
  2. 早发现，早处理
  3. 不要忽略异常
  4. 异常信息要有意义

异常处理的模式

EAFP vs LBYL

Python推崇EAFP（Easier to Ask for Forgiveness than Permission）模式，而不是LBYL（Look Before You Leap）模式。

# LBYL方式：先检查再执行
def lbyl_example(my_dict, key):
    if key in my_dict:
        return my_dict[key]
    else:
        return None

# EAFP方式：直接尝试，出错再处理
def eafp_example(my_dict, key):
    try:
        return my_dict[key]
    except KeyError:
        return None

性能考虑

让我们通过实际测试来比较两种方式的性能：

import time

def performance_test():
    data = {str(i): i for i in range(1000)}
    existing_keys = [str(i) for i in range(500)]
    missing_keys = [str(i+1000) for i in range(500)]

    # 测试存在键的情况
    start = time.time()
    for _ in range(1000):
        for key in existing_keys:
            if key in data:  # LBYL
                value = data[key]
    lbyl_time = time.time() - start

    start = time.time()
    for _ in range(1000):
        for key in existing_keys:
            try:  # EAFP
                value = data[key]
            except KeyError:
                pass
    eafp_time = time.time() - start

    print(f"键存在时 - LBYL: {lbyl_time:.6f}秒, EAFP: {eafp_time:.6f}秒")

根据我们的测试结果：

场景1: 所有键都存在
LBYL方式耗时: 0.036063秒
EAFP方式耗时: 0.027617秒
LBYL/EAFP比率: 1.31

场景2: 所有键都不存在
LBYL方式耗时: 0.016593秒
EAFP方式耗时: 0.084059秒
LBYL/EAFP比率: 0.20

场景3: 混合情况(一半键存在，一半不存在)
LBYL方式耗时: 0.024595秒
EAFP方式耗时: 0.062052秒
LBYL/EAFP比率: 0.40

从测试结果可以看出：
- 当异常很少发生时，EAFP方式性能更好
- 当异常频繁发生时，LBYL方式性能更好
- 在实际应用中，通常异常是少数情况，所以EAFP是更好的选择

日志记录

在异常处理中记录日志是很重要的实践：

import logging

# 配置日志
logging.basicConfig(level=logging.INFO, 
                   format='%(asctime)s - %(levelname)s - %(message)s')

def process_file(filename):
    try:
        with open(filename, 'r') as f:
            content = f.read()
            return content
    except FileNotFoundError:
        logging.error(f"文件未找到: {filename}")
        raise
    except PermissionError:
        logging.error(f"没有权限访问文件: {filename}")
        raise
    except Exception as e:
        logging.error(f"处理文件时发生未知错误: {filename}, 错误: {e}")
        raise

异常处理的反模式

避免以下不良实践：

  1. 空的except块
# 错误做法
try:
    risky_operation()
except:
    pass  # 忽略所有异常
  1. 过于宽泛的异常捕获
# 错误做法
try:
    specific_operation()
except Exception:  # 捕获所有异常
    print("出错了")
  1. 异常作为控制流
# 错误做法
try:
    while True:
        item = get_next_item()
        process(item)
except StopIteration:
    pass  # 用异常来结束循环

文件操作中的异常处理实例

让我们通过一个完整的文件操作示例来展示异常处理的最佳实践：

def safe_file_operations():
    """安全的文件操作示例"""
    filename = "test_file.txt"

    # 写入文件
    try:
        with open(filename, 'w', encoding='utf-8') as f:
            f.write("这是测试文件的内容\n")
            f.write("第二行内容")
        print("文件写入成功")
    except PermissionError:
        print(f"没有权限写入文件: {filename}")
        return
    except OSError as e:
        print(f"写入文件时发生系统错误: {e}")
        return

    # 读取文件
    try:
        with open(filename, 'r', encoding='utf-8') as f:
            content = f.read()
            print(f"文件内容:\n{content}")
    except FileNotFoundError:
        print(f"文件不存在: {filename}")
    except PermissionError:
        print(f"没有权限读取文件: {filename}")
    except UnicodeDecodeError:
        print(f"文件编码错误: {filename}")
    except Exception as e:
        print(f"读取文件时发生未知错误: {e}")
    finally:
        # 清理工作（如果需要）
        print("文件操作完成")

safe_file_operations()

总结

异常处理是Python编程中不可或缺的技能。通过本章的学习，我们了解了：

  1. 异常的基本概念：异常是程序运行时的错误，可以被捕获和处理
  2. 异常层次结构：Python中的异常形成了清晰的继承层次
  3. try-except语句：异常处理的基本语法和各种用法
  4. finally和else子句：用于资源清理和条件执行
  5. raise语句：主动抛出异常和异常链
  6. 自定义异常：创建符合应用需求的异常类
  7. 最佳实践：EAFP模式、日志记录、避免反模式

掌握这些知识点，能够帮助我们编写更加健壮和用户友好的Python程序。记住，好的异常处理不仅能让程序在出错时优雅地处理问题，还能为调试和维护提供有价值的信息。

在实际开发中，建议遵循以下原则：
- 捕获具体的异常类型，而不是使用通用的Exception
- 在异常处理中提供有意义的错误信息
- 使用日志记录异常信息，便于调试
- 在适当的时候重新抛出异常，让上层调用者处理
- 使用finally子句进行资源清理

通过合理使用异常处理机制，我们可以构建出既稳定又易于维护的Python应用程序。

相关文章

Python2实现简单的爬虫 2018-04-10 双目摄像头测量距离 2020-05-14 Python实现常见的排序算法 2020-05-16 基于Pytorch实现的声音分类 2021-08-20 给语音识别文本加上标点符号 2022-01-13
小夜