Python 错误和异常处理

Python 错误和异常处理

目录

• 错误与异常概述
• 语法错误
• 异常类型
• 异常处理基础
• [try-except 详解](#try-except 详解 "#try-except-%E8%AF%A6%E8%A7%A3")
• [finally 子句](#finally 子句 "#finally-%E5%AD%90%E5%8F%A5")
• [else 子句](#else 子句 "#else-%E5%AD%90%E5%8F%A5")
• 抛出异常
• 自定义异常
• 异常链
• 上下文管理器
• 日志记录
• 最佳实践
• 综合实战

---

错误与异常概述

什么是错误？

程序运行时出现的问题分为两类：

1. 语法错误（Syntax Errors）：代码不符合 Python 语法规则
2. 异常（Exceptions）：运行时错误，语法正确但执行出错

# ❌ 语法错误 - 程序无法运行
print("Hello"  # 缺少右括号

# ✅ 异常 - 程序可以运行，但会出错
print(1 / 0)  # ZeroDivisionError

为什么需要异常处理？

# ❌ 没有异常处理 - 程序崩溃
def divide(a, b):
    return a / b

result = divide(10, 0)  # 程序崩溃！
print("这行不会执行")

# ✅ 有异常处理 - 优雅处理错误
def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        print("除数不能为零")
        return None

result = safe_divide(10, 0)
print("程序继续运行")  # 这行会执行

---

语法错误

常见语法错误

# 1. 缺少冒号
# if True  # SyntaxError
#     print("Hello")

# 2. 缩进错误
# def hello():
# print("Hello")  # IndentationError

# 3. 括号不匹配
# print((1 + 2)  # SyntaxError

# 4. 引号不匹配
# text = "Hello'  # SyntaxError

# 5. 关键字拼写错误
# fro i in range(10):  # SyntaxError
#     print(i)

解读语法错误信息

# 运行以下代码会产生错误信息
# print("Hello"

"""
错误信息示例：
  File "example.py", line 1
    print("Hello"
                ^
SyntaxError: unexpected EOF while parsing

解读：
- File "example.py", line 1: 错误发生在 example.py 第 1 行
- SyntaxError: 错误类型是语法错误
- unexpected EOF while parsing: 具体错误描述
- ^ 符号指向出错位置
"""

---

异常类型

Python 内置异常层次结构

BaseException
 ├── SystemExit
 ├── KeyboardInterrupt
 ├── GeneratorExit
 └── Exception
      ├── ArithmeticError
      │    ├── FloatingPointError
      │    ├── OverflowError
      │    └── ZeroDivisionError
      ├── AssertionError
      ├── AttributeError
      ├── BufferError
      ├── EOFError
      ├── ImportError
      ├── LookupError
      │    ├── IndexError
      │    └── KeyError
      ├── MemoryError
      ├── NameError
      ├── OSError
      │    ├── FileNotFoundError
      │    ├── PermissionError
      │    └── TimeoutError
      ├── RuntimeError
      ├── StopIteration
      ├── SyntaxError
      ├── TypeError
      ├── ValueError
      └── ...

常见异常类型

# 1. ZeroDivisionError - 除以零
# result = 1 / 0

# 2. TypeError - 类型错误
# result = "hello" + 5

# 3. ValueError - 值错误
# number = int("abc")

# 4. IndexError - 索引超出范围
# my_list = [1, 2, 3]
# print(my_list[10])

# 5. KeyError - 字典键不存在
# my_dict = {"a": 1}
# print(my_dict["b"])

# 6. AttributeError - 属性不存在
# my_list = [1, 2, 3]
# my_list.appendx(4)

# 7. FileNotFoundError - 文件不存在
# file = open("nonexistent.txt")

# 8. ImportError - 导入错误
# import nonexistent_module

# 9. NameError - 变量未定义
# print(undefined_variable)

# 10. AssertionError - 断言失败
# assert False, "断言失败"

查看异常信息

try:
    result = 1 / 0
except ZeroDivisionError as e:
    print(f"异常类型: {type(e).__name__}")
    print(f"异常信息: {e}")
    print(f"异常详情: {repr(e)}")

# 输出：
# 异常类型: ZeroDivisionError
# 异常信息: division by zero
# 异常详情: ZeroDivisionError('division by zero')

---

异常处理基础

try-except 基本语法

try:
    # 可能抛出异常的代码
    result = 10 / 0
except ZeroDivisionError:
    # 处理特定异常
    print("捕获到除零错误")

print("程序继续执行")

捕获多个异常

# 方法1：多个 except 块
try:
    number = int(input("请输入数字: "))
    result = 10 / number
except ValueError:
    print("输入的不是有效数字")
except ZeroDivisionError:
    print("不能除以零")

# 方法2：一个 except 捕获多个异常类型
try:
    number = int(input("请输入数字: "))
    result = 10 / number
except (ValueError, ZeroDivisionError) as e:
    print(f"发生错误: {e}")

捕获所有异常

# ⚠️ 不推荐：捕获所有异常会隐藏问题
try:
    # 一些操作
    pass
except Exception as e:
    print(f"发生未知错误: {e}")

# ✅ 推荐：只捕获预期的异常
try:
    result = 10 / int(user_input)
except (ValueError, ZeroDivisionError) as e:
    print(f"输入错误: {e}")

---

try-except 详解

完整的 try 语句结构

try:
    # 可能抛出异常的代码
    print("尝试执行")
except ValueError as e:
    # 处理特定异常
    print(f"值错误: {e}")
except TypeError as e:
    # 处理另一种异常
    print(f"类型错误: {e}")
else:
    # 没有异常时执行
    print("成功执行")
finally:
    # 无论是否异常都执行
    print("清理工作")

异常处理流程

def demonstrate_flow(divisor):
    """演示异常处理流程"""
    try:
        print("1. 进入 try 块")
        result = 10 / divisor
        print(f"2. 计算结果: {result}")
    except ZeroDivisionError:
        print("3. 捕获到 ZeroDivisionError")
        result = None
    except Exception as e:
        print(f"3. 捕获到其他异常: {e}")
        result = None
    else:
        print("4. 没有异常，执行 else")
    finally:
        print("5. 执行 finally（总是执行）")

    print(f"6. 函数结束，result = {result}\n")
    return result

demonstrate_flow(2)   # 正常情况
demonstrate_flow(0)   # 异常情况

嵌套异常处理

try:
    print("外层 try")
    try:
        print("内层 try")
        result = 1 / 0
    except ZeroDivisionError:
        print("内层 except: 捕获除零错误")
        raise  # 重新抛出异常
except ZeroDivisionError:
    print("外层 except: 再次捕获除零错误")
finally:
    print("外层 finally")

# 输出：
# 外层 try
# 内层 try
# 内层 except: 捕获除零错误
# 外层 except: 再次捕获除零错误
# 外层 finally

---

finally 子句

finally 的作用

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

# 文件操作示例
file = None
try:
    file = open("test.txt", "w")
    file.write("Hello, World!")
except IOError as e:
    print(f"文件操作错误: {e}")
finally:
    # 确保文件被关闭
    if file:
        file.close()
        print("文件已关闭")

数据库连接示例

import sqlite3

def query_database(sql):
    conn = None
    cursor = None
    try:
        conn = sqlite3.connect("example.db")
        cursor = conn.cursor()
        cursor.execute(sql)
        results = cursor.fetchall()
        return results
    except sqlite3.Error as e:
        print(f"数据库错误: {e}")
        return []
    finally:
        # 确保资源被释放
        if cursor:
            cursor.close()
        if conn:
            conn.close()
        print("数据库连接已关闭")

finally 中的 return

def test_finally_return():
    try:
        print("try 块")
        return "from try"
    except:
        print("except 块")
        return "from except"
    finally:
        print("finally 块")
        # ⚠️ finally 中的 return 会覆盖其他的 return
        # return "from finally"

result = test_finally_return()
print(f"返回值: {result}")

# 输出：
# try 块
# finally 块
# 返回值: from try

---

else 子句

else 的作用

else 块在没有异常发生时执行，用于区分正常流程和异常处理。

def read_config(filename):
    try:
        with open(filename, 'r') as f:
            config = f.read()
    except FileNotFoundError:
        print(f"配置文件 {filename} 不存在")
        return {}
    else:
        # 只有在文件成功读取时才执行
        print("配置文件读取成功")
        return parse_config(config)

def parse_config(content):
    """解析配置内容"""
    # 模拟解析
    return {"key": "value"}

else vs 直接在 try 中

# ❌ 不推荐：异常处理范围过大
try:
    file = open("data.txt")
    data = file.read()
    result = process_data(data)  # 如果这里出错，会被误认为是文件错误
    file.close()
except IOError:
    print("IO 错误")

# ✅ 推荐：使用 else 缩小异常处理范围
try:
    file = open("data.txt")
except IOError:
    print("文件打开失败")
else:
    try:
        data = file.read()
        result = process_data(data)
    finally:
        file.close()

---

抛出异常

raise 语句

# 1. 抛出内置异常
def set_age(age):
    if age < 0 or age > 150:
        raise ValueError(f"无效的年龄: {age}")
    return age

try:
    set_age(-5)
except ValueError as e:
    print(e)  # 无效的年龄: -5

带消息的异常

# 2. 抛出自定义消息
def withdraw(balance, amount):
    if amount <= 0:
        raise ValueError("取款金额必须大于零")
    if amount > balance:
        raise ValueError(f"余额不足: 余额 {balance}, 请求 {amount}")
    return balance - amount

try:
    withdraw(100, 150)
except ValueError as e:
    print(f"错误: {e}")

重新抛出异常

def process_data(data):
    try:
        result = int(data)
    except ValueError as e:
        print(f"转换失败: {e}")
        raise  # 重新抛出原始异常

try:
    process_data("abc")
except ValueError:
    print("捕获到重新抛出的异常")

异常转换

def read_config_file(filename):
    try:
        with open(filename, 'r') as f:
            return f.read()
    except FileNotFoundError as e:
        # 转换为更具体的业务异常
        raise ConfigError(f"配置文件 {filename} 不存在") from e

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

---

自定义异常

创建自定义异常类

# 1. 基本自定义异常
class MyError(Exception):
    """我的自定义异常"""
    pass

raise MyError("出错了")

带属性的自定义异常

class ValidationError(Exception):
    """验证错误"""

    def __init__(self, field, message, value=None):
        self.field = field
        self.message = message
        self.value = value
        super().__init__(f"{field}: {message} (值: {value})")

# 使用
try:
    raise ValidationError("email", "邮箱格式不正确", "invalid@email")
except ValidationError as e:
    print(f"字段: {e.field}")
    print(f"消息: {e.message}")
    print(f"值: {e.value}")
    print(f"完整信息: {e}")

异常层次结构

# 创建异常层次结构
class AppError(Exception):
    """应用基础异常"""
    pass

class DatabaseError(AppError):
    """数据库错误"""
    pass

class ConnectionError(DatabaseError):
    """连接错误"""
    pass

class QueryError(DatabaseError):
    """查询错误"""
    pass

class BusinessError(AppError):
    """业务逻辑错误"""
    pass

class InsufficientFundsError(BusinessError):
    """余额不足"""
    pass

# 使用：可以捕获特定异常或父类异常
try:
    raise InsufficientFundsError("余额不足")
except BusinessError as e:
    print(f"业务错误: {e}")
except AppError as e:
    print(f"应用错误: {e}")

实际示例：用户注册验证

class RegistrationError(Exception):
    """注册错误基类"""
    pass

class UsernameError(RegistrationError):
    """用户名错误"""
    pass

class EmailError(RegistrationError):
    """邮箱错误"""
    pass

class PasswordError(RegistrationError):
    """密码错误"""
    pass

def validate_username(username):
    if not username:
        raise UsernameError("用户名不能为空", username)
    if len(username) < 3:
        raise UsernameError("用户名至少3个字符", username)
    if not username.isalnum():
        raise UsernameError("用户名只能包含字母和数字", username)
    return True

def validate_email(email):
    if not email:
        raise EmailError("邮箱不能为空", email)
    if "@" not in email or "." not in email:
        raise EmailError("邮箱格式不正确", email)
    return True

def validate_password(password):
    if not password:
        raise PasswordError("密码不能为空", password)
    if len(password) < 8:
        raise PasswordError("密码至少8个字符", password)
    if not any(c.isdigit() for c in password):
        raise PasswordError("密码必须包含数字", password)
    if not any(c.isalpha() for c in password):
        raise PasswordError("密码必须包含字母", password)
    return True

def register_user(username, email, password):
    """注册用户"""
    try:
        validate_username(username)
        validate_email(email)
        validate_password(password)
        print(f"✓ 用户 {username} 注册成功")
        return True
    except RegistrationError as e:
        print(f"✗ 注册失败: {e}")
        return False

# 测试
register_user("ab", "test@example.com", "password123")  # 用户名太短
register_user("john", "invalid", "password123")         # 邮箱格式错误
register_user("john", "john@example.com", "12345678")   # 密码无字母
register_user("john", "john@example.com", "Password1")  # 成功

---

异常链

from 关键字

# 异常链：保留原始异常信息
def process_file(filename):
    try:
        with open(filename, 'r') as f:
            data = f.read()
        return int(data)
    except FileNotFoundError as e:
        raise ValueError(f"无法处理文件 {filename}") from e
    except ValueError as e:
        raise ValueError(f"文件内容无效: {filename}") from e

try:
    process_file("nonexistent.txt")
except ValueError as e:
    print(f"错误: {e}")
    print(f"原因: {e.__cause__}")

# 输出：
# 错误: 无法处理文件 nonexistent.txt
# 原因: [Errno 2] No such file or directory: 'nonexistent.txt'

抑制异常链

# 使用 from None 抑制异常链
def convert_to_int(value):
    try:
        return int(value)
    except ValueError as e:
        raise TypeError("必须是数字字符串") from None

try:
    convert_to_int("abc")
except TypeError as e:
    print(e)  # 必须是数字字符串（不显示原始异常）

---

上下文管理器

with 语句

with 语句自动管理资源的获取和释放，即使发生异常也能正确清理。

# 文件操作
with open("test.txt", "w") as f:
    f.write("Hello, World!")
# 文件自动关闭，即使发生异常

# 多个上下文管理器
with open("input.txt", "r") as infile, open("output.txt", "w") as outfile:
    data = infile.read()
    outfile.write(data.upper())

创建自定义上下文管理器

方法1：类实现

class ManagedResource:
    """自定义上下文管理器"""

    def __init__(self, name):
        self.name = name

    def __enter__(self):
        """进入上下文时调用"""
        print(f"打开资源: {self.name}")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        """退出上下文时调用"""
        print(f"关闭资源: {self.name}")

        # 如果返回 True，异常会被抑制
        # 如果返回 False 或 None，异常会继续传播
        if exc_type is not None:
            print(f"发生异常: {exc_type.__name__}: {exc_val}")

        return False  # 不抑制异常

# 使用
with ManagedResource("数据库连接") as resource:
    print("使用资源")
    # raise ValueError("测试异常")

# 输出：
# 打开资源: 数据库连接
# 使用资源
# 关闭资源: 数据库连接

方法2：生成器实现

from contextlib import contextmanager

@contextmanager
def managed_resource(name):
    """使用生成器创建上下文管理器"""
    print(f"打开资源: {name}")
    try:
        yield name
    finally:
        print(f"关闭资源: {name}")

# 使用
with managed_resource("网络连接") as resource:
    print(f"使用资源: {resource}")

实际应用：计时器

import time
from contextlib import contextmanager

@contextmanager
def timer(description="操作"):
    """计时代码执行时间"""
    start = time.time()
    try:
        yield
    finally:
        end = time.time()
        elapsed = end - start
        print(f"{description} 耗时: {elapsed:.4f} 秒")

# 使用
with timer("数据处理"):
    time.sleep(1)  # 模拟耗时操作
    result = sum(range(1000000))

with timer("文件读取"):
    with open("/etc/hosts", "r") as f:
        content = f.read()

实际应用：临时目录

import os
import shutil
import tempfile
from contextlib import contextmanager

@contextmanager
def temporary_directory():
    """创建临时目录，使用后自动删除"""
    temp_dir = tempfile.mkdtemp()
    try:
        yield temp_dir
    finally:
        shutil.rmtree(temp_dir)
        print(f"临时目录 {temp_dir} 已删除")

# 使用
with temporary_directory() as temp_dir:
    temp_file = os.path.join(temp_dir, "test.txt")
    with open(temp_file, "w") as f:
        f.write("临时数据")
    print(f"临时文件: {temp_file}")
    print(f"文件存在: {os.path.exists(temp_file)}")

print(f"退出后文件存在: {os.path.exists(temp_file)}")  # False

---

日志记录

基本日志记录

import logging

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

logger = logging.getLogger(__name__)

def process_data(data):
    logger.info(f"开始处理数据: {data}")
    try:
        result = int(data) * 2
        logger.debug(f"处理结果: {result}")
        return result
    except ValueError as e:
        logger.error(f"数据处理失败: {e}", exc_info=True)
        return None

process_data("10")   # 正常
process_data("abc")  # 异常

日志级别

import logging

logger = logging.getLogger(__name__)

# 日志级别（从低到高）
logger.debug("调试信息")      # 详细信息，用于调试
logger.info("一般信息")       # 确认一切正常
logger.warning("警告信息")    # 意外情况，但程序仍能运行
logger.error("错误信息")      # 严重问题，某些功能无法执行
logger.critical("严重错误")   # 程序可能无法继续运行

记录异常堆栈

import logging

logging.basicConfig(level=logging.ERROR)
logger = logging.getLogger(__name__)

def risky_operation():
    try:
        result = 1 / 0
    except ZeroDivisionError:
        # 方法1：记录异常信息
        logger.exception("发生除零错误")  # 自动包含堆栈跟踪

        # 方法2：手动指定
        # logger.error("发生除零错误", exc_info=True)

risky_operation()

# 输出包含完整的堆栈跟踪信息

日志到文件

import logging

# 创建 logger
logger = logging.getLogger("app_logger")
logger.setLevel(logging.DEBUG)

# 文件处理器
file_handler = logging.FileHandler("app.log")
file_handler.setLevel(logging.WARNING)

# 控制台处理器
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)

# 格式化器
formatter = logging.Formatter(
    '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# 添加处理器
logger.addHandler(file_handler)
logger.addHandler(console_handler)

# 使用
logger.info("这是一般信息")
logger.warning("这是警告信息")
logger.error("这是错误信息")

---

最佳实践

1. 精确捕获异常

# ❌ 不推荐：捕获所有异常
try:
    do_something()
except:
    pass

# ❌ 不推荐：捕获过于宽泛
try:
    do_something()
except Exception:
    pass

# ✅ 推荐：捕获特定异常
try:
    do_something()
except (ValueError, TypeError) as e:
    handle_error(e)

2. 不要静默异常

# ❌ 危险：静默异常
try:
    save_data()
except:
    pass  # 错误被吞掉，难以调试

# ✅ 推荐：至少记录日志
try:
    save_data()
except IOError as e:
    logging.error(f"保存数据失败: {e}")
    raise  # 或者采取其他措施

3. 清理资源使用 finally 或 with

# ❌ 不推荐：手动管理资源
file = open("data.txt")
try:
    data = file.read()
finally:
    file.close()

# ✅ 推荐：使用 with 语句
with open("data.txt") as file:
    data = file.read()

4. 使用有意义的异常消息

# ❌ 不推荐：模糊的错误消息
raise ValueError("错误")

# ✅ 推荐：详细的错误消息
raise ValueError(f"用户年龄必须在 0-150 之间，收到: {age}")

5. 不要过度使用异常

# ❌ 不推荐：用异常控制流程
def find_item(items, target):
    for item in items:
        try:
            if item == target:
                return item
        except:
            continue
    return None

# ✅ 推荐：正常的条件判断
def find_item(items, target):
    for item in items:
        if item == target:
            return item
    return None

6. EAFP vs LBYL

# EAFP (Easier to Ask Forgiveness than Permission)
# 先尝试，出错再处理（Python 风格）
try:
    value = my_dict[key]
except KeyError:
    value = default_value

# LBYL (Look Before You Leap)
# 先检查，再执行
if key in my_dict:
    value = my_dict[key]
else:
    value = default_value

# Python 更推崇 EAFP 风格

7. 自定义异常的最佳实践

# ✅ 推荐：创建异常层次结构
class MyAppError(Exception):
    """应用基础异常"""
    def __init__(self, message, code=None):
        super().__init__(message)
        self.code = code

class ValidationError(MyAppError):
    """验证错误"""
    pass

class AuthenticationError(MyAppError):
    """认证错误"""
    pass

# 使用
try:
    authenticate_user(token)
except AuthenticationError as e:
    log_security_event(e)
    raise

---

综合实战

实战1: 健壮的文件处理器

import os
import logging
from pathlib import Path
from contextlib import contextmanager

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class FileProcessorError(Exception):
    """文件处理错误基类"""
    pass

class FileNotFoundError(FileProcessorError):
    """文件不存在"""
    pass

class FileReadError(FileProcessorError):
    """文件读取错误"""
    pass

class FileWriteError(FileProcessorError):
    """文件写入错误"""
    pass

class FileProcessor:
    """健壮的文件处理器"""

    def __init__(self, base_dir="."):
        self.base_dir = Path(base_dir)

    @contextmanager
    def safe_open(self, filepath, mode='r'):
        """安全打开文件"""
        full_path = self.base_dir / filepath

        if mode == 'r' and not full_path.exists():
            raise FileNotFoundError(f"文件不存在: {full_path}")

        file_obj = None
        try:
            file_obj = open(full_path, mode, encoding='utf-8')
            yield file_obj
        except IOError as e:
            raise FileReadError(f"文件操作失败: {full_path}, 错误: {e}") from e
        finally:
            if file_obj:
                file_obj.close()
                logger.debug(f"文件已关闭: {full_path}")

    def read_file(self, filepath):
        """读取文件内容"""
        try:
            with self.safe_open(filepath, 'r') as f:
                content = f.read()
                logger.info(f"成功读取文件: {filepath}")
                return content
        except FileNotFoundError:
            logger.warning(f"文件不存在: {filepath}")
            return None
        except FileReadError as e:
            logger.error(f"读取文件失败: {e}")
            return None

    def write_file(self, filepath, content):
        """写入文件内容"""
        try:
            # 确保目录存在
            full_path = self.base_dir / filepath
            full_path.parent.mkdir(parents=True, exist_ok=True)

            with self.safe_open(filepath, 'w') as f:
                f.write(content)
                logger.info(f"成功写入文件: {filepath}")
                return True
        except FileWriteError as e:
            logger.error(f"写入文件失败: {e}")
            return False

    def append_file(self, filepath, content):
        """追加文件内容"""
        try:
            with self.safe_open(filepath, 'a') as f:
                f.write(content)
                logger.info(f"成功追加到文件: {filepath}")
                return True
        except FileWriteError as e:
            logger.error(f"追加文件失败: {e}")
            return False

    def process_lines(self, filepath, callback):
        """逐行处理文件"""
        results = []
        line_num = 0

        try:
            with self.safe_open(filepath, 'r') as f:
                for line in f:
                    line_num += 1
                    try:
                        result = callback(line.strip(), line_num)
                        results.append(result)
                    except Exception as e:
                        logger.warning(f"处理第 {line_num} 行失败: {e}")
                        results.append(None)

            logger.info(f"处理完成: {filepath}, 共 {line_num} 行")
            return results

        except FileNotFoundError:
            logger.error(f"文件不存在: {filepath}")
            return []
        except FileReadError as e:
            logger.error(f"读取文件失败: {e}")
            return []

# 使用示例
def main():
    processor = FileProcessor("./data")

    # 写入文件
    processor.write_file("test.txt", "Hello\nWorld\nPython\n")

    # 读取文件
    content = processor.read_file("test.txt")
    if content:
        print(f"文件内容:\n{content}")

    # 逐行处理
    def uppercase_line(line, line_num):
        return f"第{line_num}行: {line.upper()}"

    results = processor.process_lines("test.txt", uppercase_line)
    for result in results:
        if result:
            print(result)

    # 处理不存在的文件
    content = processor.read_file("nonexistent.txt")
    print(f"不存在的文件: {content}")

if __name__ == "__main__":
    main()

实战2: API 请求封装

import requests
import time
import logging
from functools import wraps

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class APIError(Exception):
    """API 错误基类"""
    def __init__(self, message, status_code=None, response=None):
        super().__init__(message)
        self.status_code = status_code
        self.response = response

class NetworkError(APIError):
    """网络错误"""
    pass

class AuthenticationError(APIError):
    """认证错误"""
    pass

class RateLimitError(APIError):
    """速率限制错误"""
    def __init__(self, message, retry_after=None):
        super().__init__(message)
        self.retry_after = retry_after

class NotFoundError(APIError):
    """资源不存在"""
    pass

def retry_on_failure(max_retries=3, delay=1, backoff=2):
    """重试装饰器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            last_exception = None

            for attempt in range(1, max_retries + 1):
                try:
                    return func(*args, **kwargs)
                except (NetworkError, RateLimitError) as e:
                    last_exception = e

                    if attempt < max_retries:
                        wait_time = delay * (backoff ** (attempt - 1))
                        logger.warning(
                            f"尝试 {attempt}/{max_retries} 失败: {e}. "
                            f"{wait_time} 秒后重试..."
                        )
                        time.sleep(wait_time)
                    else:
                        logger.error(f"所有 {max_retries} 次尝试都失败了")

            raise last_exception
        return wrapper
    return decorator

class APIClient:
    """健壮的 API 客户端"""

    def __init__(self, base_url, api_key=None, timeout=10):
        self.base_url = base_url.rstrip('/')
        self.api_key = api_key
        self.timeout = timeout
        self.session = requests.Session()

        if api_key:
            self.session.headers.update({
                'Authorization': f'Bearer {api_key}'
            })

    def _build_url(self, endpoint):
        """构建完整 URL"""
        return f"{self.base_url}/{endpoint.lstrip('/')}"

    def _handle_response(self, response):
        """处理响应"""
        if response.status_code == 200:
            return response.json()
        elif response.status_code == 401:
            raise AuthenticationError(
                "认证失败",
                status_code=401,
                response=response
            )
        elif response.status_code == 404:
            raise NotFoundError(
                f"资源不存在: {response.url}",
                status_code=404,
                response=response
            )
        elif response.status_code == 429:
            retry_after = response.headers.get('Retry-After', 1)
            raise RateLimitError(
                "请求过于频繁",
                retry_after=int(retry_after)
            )
        elif response.status_code >= 500:
            raise NetworkError(
                f"服务器错误: {response.status_code}",
                status_code=response.status_code,
                response=response
            )
        else:
            raise APIError(
                f"HTTP {response.status_code}: {response.text}",
                status_code=response.status_code,
                response=response
            )

    @retry_on_failure(max_retries=3, delay=1, backoff=2)
    def get(self, endpoint, params=None):
        """GET 请求"""
        url = self._build_url(endpoint)

        try:
            logger.info(f"GET {url}")
            response = self.session.get(
                url,
                params=params,
                timeout=self.timeout
            )
            response.raise_for_status()
            return self._handle_response(response)

        except requests.exceptions.ConnectionError as e:
            raise NetworkError(f"连接失败: {e}") from e
        except requests.exceptions.Timeout as e:
            raise NetworkError(f"请求超时: {e}") from e
        except requests.exceptions.RequestException as e:
            raise APIError(f"请求失败: {e}") from e

    @retry_on_failure(max_retries=3, delay=1, backoff=2)
    def post(self, endpoint, data=None, json=None):
        """POST 请求"""
        url = self._build_url(endpoint)

        try:
            logger.info(f"POST {url}")
            response = self.session.post(
                url,
                data=data,
                json=json,
                timeout=self.timeout
            )
            response.raise_for_status()
            return self._handle_response(response)

        except requests.exceptions.RequestException as e:
            raise APIError(f"POST 请求失败: {e}") from e

    def close(self):
        """关闭会话"""
        self.session.close()

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.close()

# 使用示例
def main():
    # 使用 JSONPlaceholder 测试 API
    with APIClient("https://jsonplaceholder.typicode.com") as client:
        try:
            # 获取帖子
            posts = client.get("/posts", params={"_limit": 5})
            print(f"获取到 {len(posts)} 个帖子")

            for post in posts[:2]:
                print(f"  - {post['title'][:50]}...")

            # 获取单个帖子
            post = client.get("/posts/1")
            print(f"\n帖子标题: {post['title']}")

            # 尝试获取不存在的资源
            try:
                client.get("/posts/999999")
            except NotFoundError as e:
                print(f"\n预期错误: {e}")

            # 发布新帖子
            new_post = {
                "title": "Test Post",
                "body": "This is a test",
                "userId": 1
            }
            result = client.post("/posts", json=new_post)
            print(f"\n创建帖子 ID: {result['id']}")

        except AuthenticationError as e:
            print(f"认证错误: {e}")
        except NetworkError as e:
            print(f"网络错误: {e}")
        except APIError as e:
            print(f"API 错误: {e}")

if __name__ == "__main__":
    main()

实战3: 数据验证框架

from typing import Any, Dict, List, Optional
from dataclasses import dataclass, field
import re
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@dataclass
class ValidationError:
    """验证错误"""
    field: str
    message: str
    value: Any = None

    def __str__(self):
        return f"{self.field}: {self.message} (值: {self.value})"

@dataclass
class ValidationResult:
    """验证结果"""
    is_valid: bool = True
    errors: List[ValidationError] = field(default_factory=list)

    def add_error(self, field: str, message: str, value: Any = None):
        self.is_valid = False
        self.errors.append(ValidationError(field, message, value))

    def merge(self, other: 'ValidationResult'):
        """合并验证结果"""
        if not other.is_valid:
            self.is_valid = False
            self.errors.extend(other.errors)

    def raise_if_invalid(self):
        """如果验证失败，抛出异常"""
        if not self.is_valid:
            error_messages = "\n".join(str(e) for e in self.errors)
            raise ValueError(f"验证失败:\n{error_messages}")

class Validator:
    """验证器基类"""

    def validate(self, value: Any) -> ValidationResult:
        raise NotImplementedError

class RequiredValidator(Validator):
    """必填验证"""

    def __init__(self, message: str = "此字段为必填项"):
        self.message = message

    def validate(self, value: Any) -> ValidationResult:
        result = ValidationResult()
        if value is None or value == "":
            result.add_error("field", self.message, value)
        return result

class StringValidator(Validator):
    """字符串验证"""

    def __init__(
        self,
        min_length: int = None,
        max_length: int = None,
        pattern: str = None,
        message: str = None
    ):
        self.min_length = min_length
        self.max_length = max_length
        self.pattern = re.compile(pattern) if pattern else None
        self.message = message or "字符串验证失败"

    def validate(self, value: Any) -> ValidationResult:
        result = ValidationResult()

        if not isinstance(value, str):
            result.add_error("field", "必须是字符串", value)
            return result

        if self.min_length and len(value) < self.min_length:
            result.add_error(
                "field",
                f"长度不能少于 {self.min_length} 个字符",
                value
            )

        if self.max_length and len(value) > self.max_length:
            result.add_error(
                "field",
                f"长度不能超过 {self.max_length} 个字符",
                value
            )

        if self.pattern and not self.pattern.match(value):
            result.add_error("field", self.message, value)

        return result

class NumberValidator(Validator):
    """数字验证"""

    def __init__(
        self,
        min_value: float = None,
        max_value: float = None,
        message: str = None
    ):
        self.min_value = min_value
        self.max_value = max_value
        self.message = message or "数字验证失败"

    def validate(self, value: Any) -> ValidationResult:
        result = ValidationResult()

        if not isinstance(value, (int, float)):
            result.add_error("field", "必须是数字", value)
            return result

        if self.min_value is not None and value < self.min_value:
            result.add_error(
                "field",
                f"不能小于 {self.min_value}",
                value
            )

        if self.max_value is not None and value > self.max_value:
            result.add_error(
                "field",
                f"不能大于 {self.max_value}",
                value
            )

        return result

class EmailValidator(Validator):
    """邮箱验证"""

    def __init__(self, message: str = "邮箱格式不正确"):
        self.pattern = re.compile(
            r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
        )
        self.message = message

    def validate(self, value: Any) -> ValidationResult:
        result = ValidationResult()

        if not isinstance(value, str):
            result.add_error("field", "必须是字符串", value)
            return result

        if not self.pattern.match(value):
            result.add_error("field", self.message, value)

        return result

class FieldValidator:
    """字段验证器"""

    def __init__(self, field_name: str):
        self.field_name = field_name
        self.validators: List[Validator] = []

    def add_validator(self, validator: Validator):
        self.validators.append(validator)
        return self

    def required(self, message: str = "此字段为必填项"):
        return self.add_validator(RequiredValidator(message))

    def string(self, min_length=None, max_length=None, pattern=None, message=None):
        return self.add_validator(
            StringValidator(min_length, max_length, pattern, message)
        )

    def number(self, min_value=None, max_value=None, message=None):
        return self.add_validator(
            NumberValidator(min_value, max_value, message)
        )

    def email(self, message: str = "邮箱格式不正确"):
        return self.add_validator(EmailValidator(message))

    def validate(self, value: Any) -> ValidationResult:
        result = ValidationResult()

        for validator in self.validators:
            field_result = validator.validate(value)

            # 更新错误信息的字段名
            for error in field_result.errors:
                error.field = self.field_name

            result.merge(field_result)

            # 如果当前验证失败，跳过后续验证
            if not field_result.is_valid:
                break

        return result

class SchemaValidator:
    """模式验证器"""

    def __init__(self):
        self.fields: Dict[str, FieldValidator] = {}

    def field(self, field_name: str) -> FieldValidator:
        """定义字段验证器"""
        if field_name not in self.fields:
            self.fields[field_name] = FieldValidator(field_name)
        return self.fields[field_name]

    def validate(self, data: Dict[str, Any]) -> ValidationResult:
        """验证数据"""
        result = ValidationResult()

        for field_name, field_validator in self.fields.items():
            value = data.get(field_name)
            field_result = field_validator.validate(value)
            result.merge(field_result)

        return result

# 使用示例
def main():
    # 定义用户注册验证模式
    user_schema = SchemaValidator()

    user_schema.field("username") \
        .required("用户名不能为空") \
        .string(min_length=3, max_length=20, message="用户名只能包含字母、数字和下划线")

    user_schema.field("email") \
        .required("邮箱不能为空") \
        .email("邮箱格式不正确")

    user_schema.field("age") \
        .required("年龄不能为空") \
        .number(min_value=0, max_value=150, message="年龄必须在 0-150 之间")

    user_schema.field("password") \
        .required("密码不能为空") \
        .string(min_length=8, message="密码至少8个字符")

    # 测试数据
    test_cases = [
        {
            "username": "john",
            "email": "john@example.com",
            "age": 25,
            "password": "Password123"
        },
        {
            "username": "ab",  # 太短
            "email": "invalid",  # 格式错误
            "age": -5,  # 超出范围
            "password": "123"  # 太短
        },
        {
            "username": "",
            "email": "",
            "age": None,
            "password": ""
        }
    ]

    for i, data in enumerate(test_cases, 1):
        print(f"\n{'='*60}")
        print(f"测试用例 {i}:")
        print(f"{'='*60}")

        result = user_schema.validate(data)

        if result.is_valid:
            print("✓ 验证通过")
        else:
            print("✗ 验证失败:")
            for error in result.errors:
                print(f"  - {error}")

if __name__ == "__main__":
    main()

---

小结

概念	说明	使用场景
try-except	捕获和处理异常	处理可预见的错误
finally	无论如何都执行	清理资源
else	无异常时执行	区分正常和异常流程
raise	抛出异常	报告错误
自定义异常	创建特定异常类	业务逻辑错误
异常链	保留原始异常	异常转换时保留上下文
上下文管理器	自动资源管理	文件、数据库连接等
日志记录	记录错误信息	调试和监控

核心要点：

• 异常处理让程序更健壮
• 精确捕获，不要吞掉异常
• 使用 finally 或 with 清理资源
• 创建有意义的自定义异常
• 合理使用日志记录错误
• EAFP 风格更符合 Python 哲学
• 不要滥用异常控制流程

掌握异常处理是编写高质量 Python 代码的关键！