Python的异常处理：如何设计和实现自定义异常，并进行合理的异常捕获。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Python 异常处理：设计、实现与合理捕获

各位同学，大家好！今天我们来聊聊 Python 中的异常处理。异常处理是编写健壮、可靠代码的关键组成部分。一个精心设计的异常处理机制，能够帮助我们优雅地处理程序运行时可能出现的错误，避免程序崩溃，并提供有用的调试信息。

1. 什么是异常？

在程序执行过程中，如果遇到无法正常处理的情况，就会抛出一个异常 (Exception)。例如，尝试访问不存在的文件、除以零、类型不匹配等等。如果不处理这些异常，程序通常会终止并显示错误信息。

Python 提供了一种机制来捕获和处理这些异常，这就是异常处理。

2. Python 内置异常

Python 提供了许多内置异常类，它们都继承自 BaseException。一些常见的内置异常包括：

Exception: 所有非退出相关的异常的基类。
TypeError: 类型错误，例如将字符串和整数相加。
ValueError: 值错误，例如将字符串转换为整数时，字符串的内容不是数字。
IOError: 输入/输出错误，例如尝试打开不存在的文件。
IndexError: 索引错误，例如访问超出列表范围的索引。
KeyError: 键错误，例如访问字典中不存在的键。
ZeroDivisionError: 除零错误，例如尝试将一个数除以零。
FileNotFoundError: 文件未找到错误，Python 3.6 引入，继承自 OSError
ImportError: 导入错误，例如尝试导入不存在的模块。
AttributeError: 属性错误，例如访问对象不存在的属性。
OSError: 操作系统错误，例如文件权限不足。

这些内置异常类覆盖了大部分常见的错误情况。然而，在某些情况下，我们需要创建自定义异常来更好地表达特定领域的错误。

3. 自定义异常的设计与实现

3.1 为什么需要自定义异常？

更清晰的错误表达: 内置异常可能不足以精确地描述特定领域的错误。自定义异常可以提供更具描述性的错误信息，方便调试和维护。
更好的代码组织: 通过自定义异常，可以将相关的错误归类到一起，提高代码的可读性和可维护性。
更灵活的异常处理: 可以针对不同的自定义异常采取不同的处理策略。

3.2 如何创建自定义异常？

自定义异常类必须继承自 Exception 类或其子类。通常，我们会继承自 Exception 类。

class CustomError(Exception):
    """自定义异常的基类"""
    pass

class ValidationError(CustomError):
    """数据验证错误"""
    def __init__(self, message, field=None):
        self.message = message
        self.field = field

    def __str__(self):
        if self.field:
            return f"ValidationError: {self.message} (Field: {self.field})"
        else:
            return f"ValidationError: {self.message}"

class DatabaseError(CustomError):
    """数据库操作错误"""
    def __init__(self, message, query=None):
        self.message = message
        self.query = query

    def __str__(self):
        if self.query:
            return f"DatabaseError: {self.message} (Query: {self.query})"
        else:
            return f"DatabaseError: {self.message}"

在上面的例子中，我们创建了 CustomError 作为所有自定义异常的基类。然后，我们创建了 ValidationError 和 DatabaseError 两个子类，分别表示数据验证错误和数据库操作错误。每个异常类都有自己的 __init__ 方法，用于初始化异常的属性，以及 __str__ 方法，用于自定义异常的字符串表示。

3.3 如何抛出自定义异常？

使用 raise 语句可以抛出异常。

def validate_age(age):
    if not isinstance(age, int):
        raise TypeError("Age must be an integer")
    if age < 0:
        raise ValidationError("Age cannot be negative", field="age")
    if age > 150:
        raise ValidationError("Age is too large", field="age")
    return age

def insert_data(data):
    try:
        # 模拟数据库操作
        if not isinstance(data, dict):
            raise TypeError("Data must be a dictionary")
        if 'id' not in data:
            raise ValueError("Data must contain an 'id' field")
        if data['id'] < 0:
            raise DatabaseError("ID cannot be negative", query="INSERT INTO table VALUES ...")
        print(f"Inserting data: {data}")
    except Exception as e:
        raise DatabaseError(f"Insert failed: {e}") from e

在上面的例子中，validate_age 函数在年龄不合法时抛出 TypeError 或 ValidationError 异常。insert_data 函数在数据插入失败时抛出 DatabaseError 异常。from e 会将原始的异常信息链接到新的异常中，方便调试。

4. 异常的捕获与处理

4.1 `try...except` 语句

try...except 语句用于捕获和处理异常。

try:
    # 可能引发异常的代码
    age = validate_age(input("Enter your age: "))
    print(f"Your age is: {age}")
except ValidationError as e:
    print(f"Validation Error: {e}")
except TypeError as e:
    print(f"Type Error: {e}")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

在上面的例子中，try 块包含可能引发异常的代码。except 块用于捕获特定类型的异常，并执行相应的处理代码。可以有多个 except 块来处理不同类型的异常。如果没有任何 except 块匹配抛出的异常，异常将传递给上一层调用者处理，直到被捕获或者程序终止。

4.2 `else` 子句

else 子句在 try 块没有引发任何异常时执行。

try:
    age = validate_age(int(input("Enter your age: ")))
except ValidationError as e:
    print(f"Validation Error: {e}")
except TypeError as e:
    print(f"Type Error: {e}")
except ValueError as e:
    print(f"Value Error: Please enter a valid integer. ({e})")
else:
    print(f"Your age is: {age}")

在上面的例子中，如果 validate_age 函数没有抛出任何异常，else 块将执行，打印用户的年龄。

4.3 `finally` 子句

finally 子句无论 try 块是否引发异常都会执行。它通常用于执行清理操作，例如关闭文件或释放资源。

file = None
try:
    file = open("data.txt", "r")
    data = file.read()
    print(data)
except FileNotFoundError as e:
    print(f"File not found: {e}")
except IOError as e:
    print(f"IO Error: {e}")
finally:
    if file:
        file.close()
        print("File closed.")

在上面的例子中，无论是否成功打开和读取文件，finally 块都会执行，确保文件被关闭。

4.4 异常链 (Chaining Exceptions)

Python 3 允许链接异常，即在抛出新异常时保留原始异常的信息。这可以通过 raise ... from ... 语句实现。这在封装异常或者将异常从一个模块传递到另一个模块时非常有用。

def process_data(data):
    try:
        insert_data(data)
    except DatabaseError as e:
        print(f"Original Database Error: {e.__cause__}") # 打印原始异常
        raise  # 重新抛出异常

4.5 裸`except`

使用except:（不指定异常类型）可以捕获所有类型的异常，包括 SystemExit 和 KeyboardInterrupt。但是，强烈不建议这样做，因为它会隐藏难以预料的错误，使得程序难以调试。应该尽可能地指定需要捕获的异常类型。如果确实需要捕获所有异常，可以捕获 Exception 类，它是所有内置非退出异常的基类。

try:
    # 一些代码
    result = 10 / int(input("Enter a number: "))
    print(f"Result: {result}")

except ValueError:
    print("Invalid input. Please enter an integer.")
except ZeroDivisionError:
    print("Cannot divide by zero.")
except Exception as e:  # 捕获所有其他异常
    print(f"An unexpected error occurred: {e}")

4.6 `contextlib.suppress`

从 Python 3.4 开始，可以使用 contextlib.suppress 上下文管理器来忽略指定的异常。这在某些情况下可以简化代码。

import contextlib

with contextlib.suppress(FileNotFoundError):
    with open("missing_file.txt", "r") as f:
        print(f.read())

print("继续执行...")

如果 "missing_file.txt" 文件不存在，FileNotFoundError 异常将被忽略，程序将继续执行。

5. 异常处理的最佳实践

只捕获你知道如何处理的异常: 不要捕获所有异常，只捕获你能够合理处理的异常。
避免过度使用异常: 异常处理的代价比较高，不应该用于正常的程序流程控制。
使用具体的异常类型: 尽量使用具体的异常类型，而不是笼统的 Exception。
提供有用的错误信息: 在异常处理代码中，提供有用的错误信息，方便调试。
清理资源: 确保在 finally 块中清理资源，例如关闭文件或释放锁。
记录异常: 使用日志记录异常信息，方便排查问题。
避免在循环中抛出异常: 尽量在循环外部处理异常，避免频繁地抛出和捕获异常，影响性能。
重新引发异常: 如果捕获异常后无法完全处理，应该重新引发异常，让上一层调用者处理。
使用 contextlib: 在适当的情况下，可以使用 contextlib 模块提供的工具，例如 contextlib.suppress 和 contextlib.closing，来简化异常处理代码。

6. 异常处理示例

下面是一个综合的异常处理示例，演示了如何使用自定义异常、try...except...else...finally 语句和日志记录。

import logging

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

class InsufficientFundsError(Exception):
    """余额不足异常"""
    pass

def withdraw(account, amount):
    """从账户中取款"""
    try:
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive")
        if account['balance'] < amount:
            raise InsufficientFundsError("Insufficient funds")

        account['balance'] -= amount
        print(f"Withdrew {amount} from account. New balance: {account['balance']}")
        return True
    except ValueError as e:
        logging.error(f"Invalid withdrawal amount: {e}")
        return False
    except InsufficientFundsError as e:
        logging.error(f"Withdrawal failed: {e}")
        return False
    except Exception as e:
        logging.exception("An unexpected error occurred during withdrawal")
        return False
    else:
        print("Withdrawal successful")
        return True
    finally:
        print("Withdrawal attempt finished.") # 无论成功与否，都会执行

# 示例
account = {'balance': 1000}
withdraw(account, 500)  # 正常取款
withdraw(account, -100) # 无效金额
withdraw(account, 2000) # 余额不足

在这个例子中，withdraw 函数尝试从账户中取款。它会抛出 ValueError 或 InsufficientFundsError 异常。try...except...else...finally 语句用于捕获和处理这些异常。日志记录用于记录异常信息，方便排查问题。

7. 测试与异常处理

编写单元测试时，需要测试代码在各种异常情况下的行为。可以使用 pytest.raises 上下文管理器来测试代码是否会抛出预期的异常。

import pytest
from your_module import validate_age, ValidationError, InsufficientFundsError, withdraw

def test_validate_age_valid():
    assert validate_age(25) == 25

def test_validate_age_invalid_age():
    with pytest.raises(ValidationError):
        validate_age(-5)

def test_withdraw_insufficient_funds():
    account = {'balance': 100}
    with pytest.raises(InsufficientFundsError):
        withdraw(account, 200)

def test_withdraw_invalid_amount():
    account = {'balance': 100}
    assert withdraw(account, -50) == False #返回False

这些测试用例覆盖了 validate_age 和 withdraw 函数在各种异常情况下的行为。

8. 一些总结

理解和正确使用 Python 的异常处理机制对于编写健壮、可靠的代码至关重要。通过合理地设计和实现自定义异常，并结合 try...except...else...finally 语句，我们可以优雅地处理程序运行时可能出现的错误，避免程序崩溃，并提供有用的调试信息。同时，利用异常链和contextlib 等工具，可以进一步提升代码的可读性和可维护性。记住，良好的异常处理是优秀代码的基石。