Python异常处理与单元测试实战指南

1. 异常处理：程序员的防弹衣

在Python开发中，异常处理就像给程序穿上防弹衣。想象你正在开发一个银行转账系统，如果没有异常处理，当用户输入错误金额时，整个系统可能直接崩溃，这显然是不可接受的。

1.1 常见异常类型解析

Python中的异常就像程序运行时的各种意外情况，我们需要提前预判：

• IndexError：当访问列表不存在的索引时触发

python复制my_list = [1,2,3]
print(my_list[5])  # 触发IndexError

• ZeroDivisionError：除数为零时的数学错误

python复制result = 10 / 0  # 触发ZeroDivisionError

• FileNotFoundError：文件操作时的经典错误

python复制with open('不存在的文件.txt') as f:  # 触发FileNotFoundError
    content = f.read()

• ValueError：当函数接收到类型正确但值不合适的参数

python复制int('abc')  # 触发ValueError

1.2 try-except的实战技巧

基础异常处理结构就像程序的安全网：

python复制try:
    # 可能出错的代码
    risky_operation()
except SpecificError as e:
    # 处理特定错误
    print(f"捕获到特定错误: {e}")
except (ErrorType1, ErrorType2) as e:
    # 同时处理多种错误
    print(f"捕获到复合错误: {e}")
except Exception as e:
    # 兜底处理所有未捕获的异常
    print(f"未知错误: {e}")
else:
    # 没有异常时执行的代码
    print("一切正常！")
finally:
    # 无论是否异常都会执行
    print("清理工作完成")

重要提示：永远不要使用裸露的except:，这会导致连KeyboardInterrupt（Ctrl+C）都无法终止程序。至少使用except Exception:

1.3 assert断言的艺术

assert就像程序中的安全检查点：

python复制def calculate_discount(price, discount):
    assert 0 <= discount <= 1, "折扣必须在0-1之间"
    return price * (1 - discount)

当assert条件为False时，会抛出AssertionError。但在生产环境中，由于Python的-O优化选项会忽略所有assert语句，所以不能依赖它做关键的业务逻辑验证。

2. unittest单元测试实战指南

单元测试是保证代码质量的基石。想象你开发了一个计算器库，每次修改后如何确保原有功能仍然正常？这就是unittest的用武之地。

2.1 测试框架核心要素

典型的测试类结构：

python复制import unittest
from mycalculator import add, multiply

class TestCalculator(unittest.TestCase):
    def setUp(self):
        """每个测试方法前执行"""
        self.test_data = [(1,2), (3,4), (5,6)]
    
    def tearDown(self):
        """每个测试方法后执行"""
        self.test_data = None
    
    def test_add_positive(self):
        for a, b in self.test_data:
            self.assertEqual(add(a,b), a+b)
    
    def test_multiply_edge_cases(self):
        self.assertEqual(multiply(0,100), 0)
        self.assertEqual(multiply(-1,1), -1)

if __name__ == '__main__':
    unittest.main(verbosity=2)

2.2 断言方法大全

unittest提供了丰富的断言方法：

2.3 测试覆盖率进阶技巧

仅仅有测试用例还不够，我们需要知道测试的完备性：

1. 安装覆盖率工具：

bash复制pip install coverage

2. 运行测试并生成报告：

bash复制coverage run -m unittest discover
coverage report -m

3. 生成HTML可视化报告：

bash复制coverage html

专业建议：项目应该至少保持80%以上的测试覆盖率，关键模块应达到95%以上

3. 高阶函数与lambda的妙用

高阶函数和lambda表达式是Python函数式编程的核心武器，能让代码更简洁优雅。

3.1 高阶函数实战模式

函数作为参数传递的典型场景：

python复制def data_processor(data, preprocess_fn, filter_fn, map_fn):
    """
    数据处理流水线
    :param data: 原始数据
    :param preprocess_fn: 预处理函数
    :param filter_fn: 过滤函数 
    :param map_fn: 映射函数
    :return: 处理后的数据
    """
    processed = preprocess_fn(data)
    filtered = [item for item in processed if filter_fn(item)]
    return [map_fn(item) for item in filtered]

# 使用示例
numbers = [1, 2, 3, 4, 5, 6]

def square(x):
    return x ** 2

result = data_processor(
    numbers,
    preprocess_fn=lambda x: [n * 2 for n in x],  # 预处理：所有元素×2
    filter_fn=lambda n: n % 3 == 0,  # 过滤：能被3整除的
    map_fn=square  # 映射：平方运算
)
print(result)  # 输出 [36, 144]

3.2 lambda表达式深度解析

lambda的本质是匿名函数，格式为：
lambda 参数列表: 表达式

关键限制：

• 只能包含一个表达式
• 不能包含return语句（表达式结果自动返回）
• 不能包含赋值语句（:=海象运算符除外）

典型使用场景：

1. 简单数学运算：

python复制squared = lambda x: x**2
print(squared(5))  # 输出25

2. 数据排序：

python复制users = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}]
users.sort(key=lambda user: user['age'], reverse=True)

3. 函数式编程配合：

python复制numbers = [1, 2, 3, 4, 5]
even_squares = map(lambda x: x**2, filter(lambda x: x%2==0, numbers))

3.3 何时使用lambda的黄金法则

虽然lambda很方便，但滥用会导致代码可读性下降。我的经验法则是：

1. 使用lambda当：

   • 函数只用一次且很简单
   • 作为高阶函数的参数
   • 表达式能在一行内清晰表达

2. 避免lambda当：

   • 逻辑需要多行表达
   • 需要复用该函数
   • 包含复杂条件判断
   • 需要文档说明函数用途

性能提示：lambda和普通def函数在性能上没有差异，选择依据应该是可读性而非性能

4. 异常处理与单元测试的工程实践

在实际项目中，异常处理和单元测试需要更系统化的方法。

4.1 自定义异常体系

创建有意义的业务异常：

python复制class InventoryError(Exception):
    """库存相关异常基类"""
    pass

class OutOfStockError(InventoryError):
    """缺货异常"""
    def __init__(self, item_name):
        super().__init__(f"商品{item_name}已售罄")
        self.item_name = item_name

class InvalidQuantityError(InventoryError):
    """无效数量异常"""
    def __init__(self, quantity):
        super().__init__(f"无效数量{quantity}，必须为正整数")
        self.quantity = quantity

# 使用示例
def purchase(item_name, quantity):
    if quantity <= 0:
        raise InvalidQuantityError(quantity)
    if not check_stock(item_name, quantity):
        raise OutOfStockError(item_name)
    # 处理购买逻辑...

4.2 单元测试最佳实践

1. 测试固件管理：

python复制class TestDatabaseOperations(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        """整个测试类执行前运行一次"""
        cls.db = create_test_database()
    
    @classmethod
    def tearDownClass(cls):
        """整个测试类执行后运行一次"""
        cls.db.close()
    
    def setUp(self):
        """每个测试方法前运行"""
        self.conn = self.db.get_connection()
    
    def tearDown(self):
        """每个测试方法后运行"""
        self.conn.rollback()
        self.conn.close()

2. 参数化测试：

python复制import unittest
from parameterized import parameterized

class TestMathFunctions(unittest.TestCase):
    @parameterized.expand([
        ("positive", 2, 3, 5),
        ("negative", -1, -1, -2),
        ("zero", 0, 0, 0),
    ])
    def test_add(self, name, a, b, expected):
        self.assertEqual(add(a, b), expected)

3. 模拟对象：

python复制from unittest.mock import patch, MagicMock

class TestAPIClient(unittest.TestCase):
    @patch('requests.get')
    def test_fetch_data(self, mock_get):
        # 设置模拟返回值
        mock_response = MagicMock()
        mock_response.json.return_value = {'key': 'value'}
        mock_response.status_code = 200
        mock_get.return_value = mock_response
        
        # 测试业务代码
        client = APIClient()
        result = client.fetch_data('http://example.com/api')
        
        # 验证行为
        self.assertEqual(result, {'key': 'value'})
        mock_get.assert_called_once_with('http://example.com/api')

4.3 性能测试与基准测试

单元测试不仅要验证正确性，还应关注性能：

python复制import unittest
import timeit

class TestPerformance(unittest.TestCase):
    def test_sort_performance(self):
        data = [random.randint(0, 1000) for _ in range(10000)]
        
        def test_fn():
            return sorted(data)
        
        elapsed = timeit.timeit(test_fn, number=100)
        self.assertLess(elapsed, 1.0, "排序100次耗时超过1秒")

在实际项目中，我通常会建立这样的测试体系：

1. 单元测试：验证单个函数/方法
2. 集成测试：验证模块间交互
3. 性能测试：验证关键路径性能
4. E2E测试：验证完整业务流程

5. 高阶函数设计模式

高阶函数不仅能接受函数作为参数，还能返回函数，这种特性可以实现强大的设计模式。

5.1 装饰器工厂模式

python复制def retry(max_attempts=3, delay=1, exceptions=(Exception,)):
    """
    重试装饰器工厂
    :param max_attempts: 最大尝试次数
    :param delay: 重试间隔(秒)
    :param exceptions: 触发重试的异常类型
    :return: 装饰器函数
    """
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            last_error = None
            for attempt in range(1, max_attempts+1):
                try:
                    return func(*args, **kwargs)
                except exceptions as e:
                    last_error = e
                    if attempt < max_attempts:
                        time.sleep(delay)
            raise last_error
        return wrapper
    return decorator

# 使用示例
@retry(max_attempts=5, delay=2, exceptions=(ConnectionError, TimeoutError))
def fetch_data_from_api(url):
    # 实现数据获取逻辑
    ...

5.2 策略模式的高阶实现

python复制class PaymentProcessor:
    def __init__(self):
        self._strategies = {
            'credit': self._process_credit,
            'paypal': self._process_paypal,
            'crypto': self._process_crypto
        }
    
    def process(self, payment_type, amount):
        strategy = self._strategies.get(payment_type)
        if not strategy:
            raise ValueError(f"未知支付方式: {payment_type}")
        return strategy(amount)
    
    def _process_credit(self, amount):
        print(f"处理信用卡支付: {amount}")
        # 实际信用卡处理逻辑
    
    def _process_paypal(self, amount):
        print(f"处理PayPal支付: {amount}")
        # 实际PayPal处理逻辑
    
    def _process_crypto(self, amount):
        print(f"处理加密货币支付: {amount}")
        # 实际加密货币处理逻辑

# 使用示例
processor = PaymentProcessor()
processor.process('credit', 100.00)

5.3 函数柯里化技术

柯里化（Currying）是把多参数函数转换为一系列单参数函数的技术：

python复制from functools import partial

def power(base, exponent):
    return base ** exponent

# 创建平方和立方函数
square = partial(power, exponent=2)
cube = partial(power, exponent=3)

print(square(5))  # 25
print(cube(3))    # 27

更通用的柯里化实现：

python复制def curry(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        if len(args) + len(kwargs) >= func.__code__.co_argcount:
            return func(*args, **kwargs)
        return lambda *more_args, **more_kwargs: wrapper(
            *(args + more_args), 
            **{**kwargs, **more_kwargs}
        )
    return wrapper

# 使用示例
@curry
def add_three_numbers(a, b, c):
    return a + b + c

add_5 = add_three_numbers(5)  # 返回一个函数
add_5_and_10 = add_5(10)      # 返回另一个函数
result = add_5_and_10(15)     # 30

在实际项目中，我发现高阶函数特别适合以下场景：

• 数据处理流水线
• 回调机制实现
• 动态策略选择
• 装饰器创建
• 中间件实现

6. 综合案例：构建健壮的API客户端

让我们综合运用异常处理、单元测试和高阶函数，构建一个健壮的API客户端。

6.1 基础实现

python复制import requests
import json
from functools import wraps
from typing import Callable, Any, Optional

class APIClient:
    def __init__(self, base_url: str, timeout: int = 10):
        self.base_url = base_url.rstrip('/')
        self.timeout = timeout
        self.session = requests.Session()
    
    def handle_errors(func: Callable) -> Callable:
        @wraps(func)
        def wrapper(self, *args, **kwargs) -> Any:
            try:
                return func(self, *args, **kwargs)
            except requests.Timeout:
                raise APIError("请求超时")
            except requests.ConnectionError:
                raise APIError("连接错误")
            except json.JSONDecodeError:
                raise APIError("响应解析错误")
            except requests.RequestException as e:
                raise APIError(f"请求错误: {str(e)}")
        return wrapper
    
    @handle_errors
    def get(self, endpoint: str, params: Optional[dict] = None) -> dict:
        url = f"{self.base_url}/{endpoint.lstrip('/')}"
        response = self.session.get(
            url, 
            params=params, 
            timeout=self.timeout
        )
        response.raise_for_status()
        return response.json()
    
    @handle_errors
    def post(self, endpoint: str, data: dict) -> dict:
        url = f"{self.base_url}/{endpoint.lstrip('/')}"
        response = self.session.post(
            url,
            json=data,
            timeout=self.timeout
        )
        response.raise_for_status()
        return response.json()

class APIError(Exception):
    """API客户端专用异常"""
    pass

6.2 单元测试实现

python复制import unittest
from unittest.mock import patch, MagicMock

class TestAPIClient(unittest.TestCase):
    def setUp(self):
        self.client = APIClient("https://api.example.com")
    
    @patch('requests.Session.get')
    def test_get_success(self, mock_get):
        # 配置模拟响应
        mock_response = MagicMock()
        mock_response.json.return_value = {'key': 'value'}
        mock_response.raise_for_status.return_value = None
        mock_get.return_value = mock_response
        
        # 调用测试方法
        result = self.client.get('/test')
        
        # 验证结果
        self.assertEqual(result, {'key': 'value'})
        mock_get.assert_called_once_with(
            'https://api.example.com/test',
            params=None,
            timeout=10
        )
    
    @patch('requests.Session.get')
    def test_get_with_params(self, mock_get):
        mock_response = MagicMock()
        mock_response.json.return_value = {'param': 'value'}
        mock_get.return_value = mock_response
        
        result = self.client.get('/search', params={'q': 'python'})
        
        self.assertEqual(result, {'param': 'value'})
        mock_get.assert_called_once_with(
            'https://api.example.com/search',
            params={'q': 'python'},
            timeout=10
        )
    
    @patch('requests.Session.get')
    def test_get_handles_errors(self, mock_get):
        mock_get.side_effect = requests.Timeout("请求超时")
        
        with self.assertRaises(APIError) as context:
            self.client.get('/timeout')
        
        self.assertEqual(str(context.exception), "请求超时")

6.3 高阶函数增强

为APIClient添加缓存功能：

python复制from functools import lru_cache
from datetime import timedelta

def cached(timeout: timedelta):
    """响应缓存装饰器"""
    def decorator(func):
        # 使用lru_cache实现内存缓存
        cached_func = lru_cache(maxsize=128)(func)
        
        @wraps(func)
        def wrapper(self, *args, **kwargs):
            # 生成缓存键
            cache_key = (args, frozenset(kwargs.items()))
            
            # 检查缓存
            if hasattr(self, '_cache'):
                cached_data = self._cache.get(cache_key)
                if cached_data and (time.time() - cached_data['timestamp']) < timeout.total_seconds():
                    return cached_data['data']
            
            # 调用原始函数
            result = cached_func(self, *args, **kwargs)
            
            # 更新缓存
            if not hasattr(self, '_cache'):
                self._cache = {}
            self._cache[cache_key] = {
                'data': result,
                'timestamp': time.time()
            }
            
            return result
        return wrapper
    return decorator

# 增强APIClient
class EnhancedAPIClient(APIClient):
    @cached(timeout=timedelta(minutes=5))
    def get(self, endpoint: str, params: Optional[dict] = None) -> dict:
        return super().get(endpoint, params)

这个综合案例展示了如何将异常处理、单元测试和高阶函数有机结合，构建出既健壮又灵活的组件。在实际项目中，这种模式可以应用于数据库客户端、文件操作工具等各种需要稳定性和灵活性的场景。