实用指南：functools 是 Python 的标准库模块

一、作用：

提供了一些用于高阶函数（操作或返回其他函数的函数）的应用。

二、常用函数详解

1. partial - 部分应用函数（偏函数）

作用：固定函数的部分参数，生成新函数

语法格式：partial(func, *arys,**kwarys)

from functools import partial

def multiply(x, y):

return x * y

# 固定第一个参数

double = partial(multiply, 2)

print(double(5)) # 10

# 固定第二个参数

multiply_by_3 = partial(multiply, y=3)

print(multiply_by_3(4)) # 12

# 实际应用：处理文件

def read_file(filename, encoding='utf-8', mode='r'):

with open(filename, mode, encoding=encoding) as f:

return f.read()

# 创建专门读取文本文件的函数

read_text = partial(read_file, encoding='utf-8', mode='r')

read_binary = partial(read_file, mode='rb')

2. reduce - 累积计算

作用：对序列中的元素进行累积计算

语法格式：reduce(func,iterable,initializer)

参数：

• func：接收两个参数的函数。
• iterable：可迭代对象。
• initializer（可选）：初始值，用于指定累积计算的起始值

from functools import reduce

# 计算阶乘

def factorial(n):

return reduce(lambda x, y: x * y, range(1, n+1))

print(factorial(5)) # 120

3. lru_cache - 缓存装饰器

作用：为函数添加缓存，避免重复计算

用途：缓存已计算结果：当函数参数相同时，直接回没有结果，避免重复设计；

LRU淘汰策略：钢管从容量达到上限时，自动移除最久未使用的数据。；

线程安全：适用于多线程环境

语法格式：@lru_cache(maxsize,typed)

参数：

• maxsize：缓存容量上限（默认128），None代表无限缓存。
• typed：是否区分参数类型（默认为False）

清空缓存用cache_clear()

from functools import lru_cache

import time

# 基本用法

@lru_cache(maxsize=128)

def fibonacci(n):

if n < 2:

return n

return fibonacci(n-1) + fibonacci(n-2)

# 测试性能

start = time.time()

result = fibonacci(35)

end = time.time()

print(f"fibonacci(35) = {result}, 耗时: {end-start:.4f}秒")

# 查看缓存信息

print(f"缓存命中率: {fibonacci.cache_info()}")

4. wraps - 保留原函数信息

作用：在装饰器中保留原函数的元信息

语法格式：@wraps(fun)

from functools import wraps

def good_decorator(func):

@wraps(func)

def wrapper(*args, **kwargs):

print("函数被调用")

return func(*args, **kwargs)

return wrapper

@good_decorator

def example2():

pass

5. total_ordering - 自动生成比较方法

作用：基于 __eq__ 和 __lt__ 自动生成所有比较技巧的装饰器。

核心效果：只需要定义__eq__（判断相等） 和 __lt__ （小于）两个方式，total_ordering自动生成其他比较方法（如__le__，__gt__ 和 __ge__） 。

from functools import total_ordering

@total_ordering

class Student:

def __init__(self, name, score):

self.name = name

self.score = score

def __eq__(self, other):

return self.score == other.score

def __lt__(self, other):

return self.score < other.score

def __repr__(self):

return f"Student({self.name}, {self.score})"

students = [

Student("Alice", 85),

Student("Bob", 92),

Student("Charlie", 78)

]

# 排序

sorted_students = sorted(students)

print(sorted_students)

# [Student(Charlie, 78), Student(Alice, 85), Student(Bob, 92)]

6. singledispatch - 单分派泛型函数（装饰器）

作用：用于实现基于参数类型的函数分派，（即根据参数类型选择不同的执行逻辑），且它属于单分派泛函数，仅根据第1个参数的类型决定后续执行逻辑。

扩展性：帮助与利用.register(类型)方法注册多个类型对应的处理逻辑，同一函数可处理多种类型。

from functools import singledispatch

@singledispatch

def process(data):

"""默认处理函数"""

print(f"处理未知类型: {type(data)}")

return str(data)

@process.register

def _(data: int):

print("处理整数")

return f"整数: {data}"

@process.register

def _(data: list):

print("处理列表")

return f"列表长度: {len(data)}"

# 测试

print(process(42)) # 处理整数 → 整数: 42

print(process([1,2,3])) # 处理列表 → 列表长度: 3

7. cached_property - 缓存属性

作用：将方法转换为缓存属性（Python 3.8+）

核心功能：

缓存机制：首次调用方法是计算结果并存后续调用直接返回存储值，避免重复计算。

适用场景：适用于依赖外部资源或复杂计算的属性。例如网络请求复杂、数学计算的。

from functools import cached_property

import time

class DataProcessor:

def __init__(self, data):

self.data = data

@cached_property

def processed_data(self):

"""耗时处理，结果会被缓存"""

print("执行耗时处理...")

time.sleep(1) # 模拟耗时操作

return [x * 2 for x in self.data]

# 使用

processor = DataProcessor([1, 2, 3, 4, 5])

# 第一次访问会执行计算

print("第一次访问:")

result1 = processor.processed_data # 执行耗时处理...

print(result1)

# 第二次访问直接从缓存获取

print("第二次访问:")

result2 = processor.processed_data # 无输出，直接从缓存获取

print(result2)