Python functools模块：偏函数缓存与装饰器实践

脚本专家

functools 是 Python 标准库中处理函数和可调用对象的高阶工具集合。原文列出的核心导入包括 reduce、partial、lru_cache、wraps、total_ordering、singledispatch、cmp_to_key、cached_property。它常用于缓存优化、偏函数、装饰器元信息保留、函数重载和比较方法补全。

一、partial：预填充参数生成新函数

partial(func, *args, **kwargs) 可以固定部分参数，创建一个新的可调用对象，相当于 Python 中函数柯里化的一种实现。基础示例如下：

2. from functools import partial
4. def power(base, exponent):
5.     return base ** exponent
7. square = partial(power, exponent=2)
8. cube = partial(power, exponent=3)
10. print(square(10))  # 100
11. print(cube(10))    # 1000

复制代码

在实际回调场景中，可以用 partial 固定 logger 名称，再继续固定 event_type 和时间戳，减少重复传参：

2. from functools import partial
3. import time
5. def log_event(logger, event_type, message, timestamp):
6.     print(f'[{timestamp}] {event_type}: {message} (logger={logger})')
8. app_log = partial(log_event, 'app')
9. app_log_error = partial(app_log, 'ERROR', timestamp=time.time())
10. app_log_error('数据库连接失败')
11. # [1718000000.0] ERROR: 数据库连接失败 (logger=app)

复制代码

数据处理管道也适合用 partial 生成专用转换函数：

2. from functools import partial
4. def transform(data, multiplier, offset, round_digits=2):
5.     return round(data * multiplier + offset, round_digits)
7. c_to_f = partial(transform, multiplier=9/5, offset=32, round_digits=1)
8. f_to_c = partial(transform, multiplier=5/9, offset=-32*5/9, round_digits=1)
10. print(c_to_f(0))    # 32.0
11. print(c_to_f(100))  # 212.0
12. print(f_to_c(32))   # 0.0

复制代码

二、lru_cache 与 cache：缓存函数结果

lru_cache 用于最近最少使用缓存；cache 是 Python 3.9+ 提供的无限制缓存，等价于 lru_cache(maxsize=None)。用 lru_cache 改写递归函数，可以避免重复子问题计算：

2. from functools import lru_cache
3. import time
5. @lru_cache(maxsize=128)
6. def fibonacci(n):
7.     if n < 2:
8.         return n
9.     return fibonacci(n - 1) + fibonacci(n - 2)
11. start = time.perf_counter()
12. print(fibonacci(35))
13. print(f'首次: {time.perf_counter() - start:.4f}秒')
15. start = time.perf_counter()
16. print(fibonacci(35))
17. print(f'缓存: {time.perf_counter() - start:.6f}秒')
19. print(fibonacci.cache_info())
20. # CacheInfo(hits=34, misses=36, maxsize=128, currsize=36)
22. fibonacci.cache_clear()

复制代码

使用 lru_cache 时要注意：被缓存函数的参数必须可哈希；lru_cache 装饰器不能直接用于方法，否则可能导致内存泄漏。数据库查询缓存是常见场景：

2. from functools import lru_cache
4. @lru_cache(maxsize=256)
5. def get_user_by_id(user_id):
6.     print(f'查询数据库: user_id={user_id}')
7.     return {'id': user_id, 'name': f'用户{user_id}'}
9. print(get_user_by_id(1))  # 查询数据库
10. print(get_user_by_id(1))  # 缓存命中，不查数据库

复制代码

三、wraps：保留被装饰函数的元信息

写装饰器时，如果不使用 wraps，原函数的 __name__、__doc__ 等元信息会被 wrapper 覆盖：

2. from functools import wraps
4. def bad_decorator(func):
5.     def wrapper(*args, **kwargs):
6.         '''这是wrapper的文档'''
7.         return func(*args, **kwargs)
8.     return wrapper
10. @bad_decorator
11. def greet(name):
12.     '''向用户打招呼'''
13.     return f'Hello, {name}!'
15. print(greet.__name__)  # wrapper
16. print(greet.__doc__)   # 这是wrapper的文档

复制代码

加上 @wraps(func) 后，元信息能够正确保留：

2. from functools import wraps
4. def good_decorator(func):
5.     @wraps(func)
6.     def wrapper(*args, **kwargs):
7.         '''这是wrapper的文档'''
8.         return func(*args, **kwargs)
9.     return wrapper
11. @good_decorator
12. def greet_v2(name):
13.     '''向用户打招呼'''
14.     return f'Hello, {name}!'
16. print(greet_v2.__name__)  # greet_v2
17. print(greet_v2.__doc__)   # 向用户打招呼

复制代码

因此，@wraps 基本是编写装饰器时的标配，不加会增加调试和文档阅读成本。

四、singledispatch：按类型分派的函数重载

singledispatch 可以根据第一个参数类型选择不同实现，类似单分派函数重载：

2. from functools import singledispatch
4. @singledispatch
5. def format_output(data):
6.     return str(data)
8. @format_output.register(list)
9. def _(data):
10.     return '[' + ', '.join(format_output(item) for item in data) + ']'
12. @format_output.register(dict)
13. def _(data):
14.     items = [f'{k}: {format_output(v)}' for k, v in data.items()]
15.     return '{' + ', '.join(items) + '}'
17. @format_output.register(int)
18. def _(data):
19.     return f'{data:,}'
21. print(format_output(1234567))                  # 1,234,567
22. print(format_output([1, 'hello', [2, 3]]))      # [1, hello, [2, 3]]
23. print(format_output({'name': '张三', 'age': 25}))  # {name: 张三, age: 25}

复制代码

五、cached_property：只计算一次的惰性属性

cached_property 把耗时计算变成实例属性风格访问，第一次访问时计算并缓存，后续访问直接取缓存：

2. from functools import cached_property
3. import time
5. class DataAnalyzer:
6.     def __init__(self, data):
7.         self.data = data
9.     @cached_property
10.     def statistics(self):
11.         print('正在计算统计数据...')
12.         time.sleep(0.5)
13.         return {
14.             'sum': sum(self.data),
15.             'avg': sum(self.data) / len(self.data),
16.             'min': min(self.data),
17.             'max': max(self.data),
18.         }
20. analyzer = DataAnalyzer([1, 2, 3, 4, 5])
21. print(analyzer.statistics)  # 计算，并打印“正在计算...”
22. print(analyzer.statistics)  # 缓存命中，不再打印

复制代码

它与 property 的区别在于：cached_property 像实例属性一样直接访问，同时只计算一次。

六、total_ordering：自动补全比较方法

total_ordering 适合实现版本号等可比较对象。只要定义 __eq__ 和 __lt__，其余比较方法会自动生成：

2. from functools import total_ordering
4. @total_ordering
5. class Version:
6.     def __init__(self, major, minor, patch):
7.         self.major = major
8.         self.minor = minor
9.         self.patch = patch
11.     def __eq__(self, other):
12.         return (self.major, self.minor, self.patch) == (other.major, other.minor, other.patch)
14.     def __lt__(self, other):
15.         return (self.major, self.minor, self.patch) < (other.major, other.minor, other.patch)
17.     def __repr__(self):
18.         return f'v{self.major}.{self.minor}.{self.patch}'
20. v1 = Version(1, 2, 3)
21. v2 = Version(2, 0, 0)
23. print(v1 < v2)   # True
24. print(v1 <= v2)  # True，自动生成
25. print(v1 >= v2)  # False，自动生成
26. print(v1 != v2)  # True，自动生成

复制代码

七、总结：functools 工具选择建议

原文章给出的常用工具可以归纳为：partial 固定参数并创建新函数；lru_cache 自动缓存，适合加速递归和重复调用；wraps 保留装饰函数的元信息；cached_property 惰性计算且只算一次；singledispatch 根据类型选择实现；total_ordering 补全所有比较方法。实践时可以按场景选择：写装饰器用 wraps，慢递归用 lru_cache，重复参数用 partial。