一、核心概念解析

1.1 基础定义：函数式编程的工具箱

functools模块提供了一些用于高阶函数（即操作或返回其他函数的函数）的工具。这些工具包括：

1. 偏函数（Partial Functions）：通过固定原函数的部分参数来创建新函数

2. 函数装饰器（Decorators）：用于修改或增强函数的行为

3. 函数比较和排序：提供用于比较和排序的函数工具

4. 函数包装（Wrapping）：帮助正确创建装饰器，保持函数元信息

1.2 基本语法：常用函数一览

from functools import partial, wraps, lru_cache, reduce, cmp_to_key

# 1. partial: 创建偏函数
def multiply(x, y):
    return x * y

double = partial(multiply, 2)
print(double(5))  # 10

# 2. wraps: 装饰器工具，保留被装饰函数的元信息
def my_decorator(f):
    @wraps(f)
    def wrapper(*args, **kwargs):
        print("调用函数")
        return f(*args, **kwargs)
    return wrapper

@my_decorator
def say_hello():
    """打招呼函数"""
    print("你好！")

print(say_hello.__name__)  # 输出'say_hello'，而不是'wrapper'
print(say_hello.__doc__)   # 输出'打招呼函数'

# 3. lru_cache: 函数结果缓存
@lru_cache(maxsize=32)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))  # 55，计算结果被缓存

# 4. reduce: 对序列中的元素进行累积操作
from functools import reduce
result = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
print(result)  # 15

# 5. cmp_to_key: 将比较函数转换为key函数
def compare(x, y):
    return x - y

sorted_list = sorted([5, 2, 8, 1, 9], key=cmp_to_key(compare))
print(sorted_list)  # [1, 2, 5, 8, 9]

1.3 核心特点：为什么选择functools？

1. 代码复用：通过偏函数等工具，减少重复代码

2. 性能优化：通过缓存装饰器，提高函数执行效率

3. 代码可读性：使函数式编程代码更清晰、更易理解

4. 装饰器支持：提供创建装饰器的工具，保持函数元信息

二、应用场景详解

2.1 偏函数（partial）：固定函数参数

偏函数允许我们固定一个函数的部分参数，从而创建一个新函数。这在需要重复调用同一个函数，且部分参数总是相同时非常有用。

from functools import partial

# 示例1：固定函数参数
def power(base, exponent):
    """计算幂"""
    return base ** exponent

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

print(f"5的平方: {square(5)}")  # 25
print(f"5的立方: {cube(5)}")    # 125

# 示例2：在GUI编程中固定回调函数参数
def button_click_handler(button_id, event):
    """按钮点击处理器"""
    print(f"按钮 {button_id} 被点击，事件: {event}")

# 为不同的按钮创建特定的处理器
button1_handler = partial(button_click_handler, "button1")
button2_handler = partial(button_click_handler, "button2")

# 模拟事件
button1_handler("click")
button2_handler("double_click")

# 示例3：固定多个参数
def send_email(sender, recipient, subject, body):
    """发送邮件（模拟）"""
    print(f"从 {sender} 发送给 {recipient}")
    print(f"主题: {subject}")
    print(f"正文: {body}")
    print("-" * 30)

# 固定发件人和主题
send_from_admin = partial(send_email, sender="admin@example.com", 
                          subject="系统通知")

# 现在只需要提供收件人和正文
send_from_admin(recipient="user1@example.com", 
                body="您的账户已创建。")
send_from_admin(recipient="user2@example.com", 
                body="您的密码已重置。")

# 示例4：与map结合使用
numbers = [1, 2, 3, 4, 5]

# 传统方式
squares = list(map(lambda x: x ** 2, numbers))
print(f"平方: {squares}")

# 使用偏函数
square_func = partial(power, exponent=2)
squares_with_partial = list(map(square_func, numbers))
print(f"使用偏函数的平方: {squares_with_partial}")

最佳实践：

• 当需要重复调用一个函数，且某些参数总是相同时，使用偏函数

• 偏函数可以增加代码的可读性，因为它为函数提供了更具描述性的名称

• 注意：偏函数创建的新函数和原函数具有相同的调用特性

2.2 缓存装饰器（lru_cache）：记住函数结果

lru_cache是一个装饰器，它为函数提供最近最少使用（LRU）缓存。这意味着函数的结果会被缓存，当再次以相同的参数调用函数时，可以直接返回缓存的结果，而不必重新计算。

from functools import lru_cache
import time

# 示例1：缓存斐波那契数列计算
@lru_cache(maxsize=128)
def fibonacci(n):
    """计算斐波那契数列（递归实现）"""
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print("计算斐波那契数列（带缓存）:")
start = time.time()
result = fibonacci(100)  # 计算第100个斐波那契数
end = time.time()
print(f"fibonacci(100) = {result}")
print(f"耗时: {end - start:.6f}秒")

# 比较无缓存的版本
def fibonacci_no_cache(n):
    if n < 2:
        return n
    return fibonacci_no_cache(n-1) + fibonacci_no_cache(n-2)

print("\n计算斐波那契数列（无缓存）:")
start = time.time()
try:
    # 注意：无缓存时计算较大的n会非常慢
    result = fibonacci_no_cache(30)  # 只计算到30
    end = time.time()
    print(f"fibonacci_no_cache(30) = {result}")
    print(f"耗时: {end - start:.6f}秒")
except RecursionError as e:
    print(f"递归深度错误: {e}")

# 示例2：缓存昂贵的API调用
@lru_cache(maxsize=32)
def get_weather(city, date):
    """获取天气信息（模拟昂贵的API调用）"""
    print(f"调用API获取 {city} 在 {date} 的天气...")
    time.sleep(1)  # 模拟网络延迟
    # 模拟返回数据
    return {
        "city": city,
        "date": date,
        "temperature": 25,  # 模拟温度
        "condition": "晴朗"
    }

print("\n模拟天气API调用（带缓存）:")
# 第一次调用，会实际执行
weather1 = get_weather("北京", "2024-01-15")
print(f"结果: {weather1}")

# 相同参数再次调用，从缓存中获取
weather2 = get_weather("北京", "2024-01-15")
print(f"结果（来自缓存）: {weather2}")

# 不同参数，会再次调用API
weather3 = get_weather("上海", "2024-01-15")
print(f"结果: {weather3}")

# 查看缓存信息
print(f"\n缓存信息: {get_weather.cache_info()}")

# 示例3：可变的maxsize参数
@lru_cache(maxsize=None)  # 无限制缓存
def factorial(n):
    """计算阶乘"""
    if n == 0:
        return 1
    return n * factorial(n-1)

print("\n计算阶乘（无限制缓存）:")
print(f"factorial(10) = {factorial(10)}")
print(f"factorial(5) = {factorial(5)}")  # 应该从缓存中获取
print(f"缓存信息: {factorial.cache_info()}")

# 清除缓存
factorial.cache_clear()
print(f"清除缓存后: {factorial.cache_info()}")

最佳实践：

• 对计算昂贵的纯函数（输出仅由输入决定，且无副作用）使用缓存

• 根据函数可能接收的不同参数数量来设置合适的maxsize

• 使用cache_info()监控缓存使用情况，调整maxsize参数

• 注意：缓存会消耗内存，所以不要滥用

2.3 函数装饰器工具（wraps）：保持函数元信息

在创建装饰器时，使用wraps装饰器可以保留原始函数的名称、文档字符串等元信息。

from functools import wraps
import time

# 示例1：计时装饰器
def timer(func):
    """函数执行时间计时器"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        result = func(*args, **kwargs)
        end_time = time.perf_counter()
        print(f"函数 {func.__name__} 执行时间: {end_time - start_time:.6f}秒")
        return result
    return wrapper

@timer
def slow_function(seconds):
    """模拟耗时操作"""
    time.sleep(seconds)
    return f"休眠了{seconds}秒"

print("计时装饰器示例:")
result = slow_function(0.5)
print(f"结果: {result}")
print(f"函数名: {slow_function.__name__}")
print(f"文档字符串: {slow_function.__doc__}")

# 示例2：重试装饰器
def retry(max_attempts=3, delay=1):
    """失败重试装饰器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            last_exception = None
            for attempt in range(1, max_attempts + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_exception = e
                    print(f"第{attempt}次尝试失败: {e}")
                    if attempt < max_attempts:
                        time.sleep(delay)
            
            # 所有尝试都失败
            raise Exception(f"函数 {func.__name__} 在{max_attempts}次尝试后失败") from last_exception
        return wrapper
    return decorator

@retry(max_attempts=3, delay=0.5)
def unstable_function():
    """模拟不稳定的函数（有时失败）"""
    import random
    if random.random() < 0.7:  # 70%概率失败
        raise ValueError("随机失败")
    return "成功"

print("\n重试装饰器示例:")
try:
    result = unstable_function()
    print(f"结果: {result}")
except Exception as e:
    print(f"最终失败: {e}")

# 示例3：参数验证装饰器
def validate_params(*validators):
    """参数验证装饰器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # 验证位置参数
            for i, (arg, validator) in enumerate(zip(args, validators)):
                if not validator(arg):
                    raise ValueError(f"参数{i}无效: {arg}")
            
            # 这里可以添加关键字参数验证
            return func(*args, **kwargs)
        return wrapper
    return decorator

# 定义验证函数
def is_positive(x):
    return x > 0

def is_even(x):
    return x % 2 == 0

@validate_params(is_positive, is_even)
def process_number(x, y):
    """处理数字，要求x为正数，y为偶数"""
    return x * y

print("\n参数验证装饰器示例:")
try:
    result = process_number(5, 4)
    print(f"结果: {result}")
    
    # 这会失败
    result = process_number(-1, 4)
    print(f"结果: {result}")
except ValueError as e:
    print(f"验证失败: {e}")

# 示例4：使用wraps与不使用的对比
def decorator_without_wraps(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

def decorator_with_wraps(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@decorator_without_wraps
def function1():
    """函数1"""
    pass

@decorator_with_wraps
def function2():
    """函数2"""
    pass

print("\nwraps使用对比:")
print(f"不使用wraps - 函数名: {function1.__name__}, 文档: {function1.__doc__}")
print(f"使用wraps - 函数名: {function2.__name__}, 文档: {function2.__doc__}")

最佳实践：

• 创建装饰器时，总是使用@wraps来保留原始函数的元信息

• 这有助于调试和保持代码的清晰性

• 许多工具（如测试框架、文档生成器）依赖这些元信息

三、高级技巧

3.1 total_ordering：简化比较运算符的实现

total_ordering装饰器可以帮助我们简化比较运算符的实现。只需要定义__eq__和__lt__、__le__、__gt__、__ge__中的一个，它就会自动帮我们实现其他的比较方法。

from functools import total_ordering

# 示例1：简化比较运算符
@total_ordering
class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score
    
    def __eq__(self, other):
        if not isinstance(other, Student):
            return NotImplemented
        return self.score == other.score
    
    def __lt__(self, other):
        if not isinstance(other, Student):
            return NotImplemented
        return self.score < other.score
    
    def __repr__(self):
        return f"Student(name={self.name}, score={self.score})"

print("total_ordering示例:")
s1 = Student("张三", 85)
s2 = Student("李四", 92)
s3 = Student("王五", 85)

print(f"s1: {s1}")
print(f"s2: {s2}")
print(f"s3: {s3}")
print()
print(f"s1 == s2: {s1 == s2}")
print(f"s1 == s3: {s1 == s3}")
print(f"s1 != s2: {s1 != s2}")
print(f"s1 < s2: {s1 < s2}")
print(f"s1 <= s2: {s1 <= s2}")
print(f"s1 > s2: {s1 > s2}")
print(f"s1 >= s2: {s1 >= s2}")

# 排序示例
students = [Student("张三", 85), Student("李四", 92), Student("王五", 78)]
sorted_students = sorted(students)
print(f"\n按成绩排序: {sorted_students}")

# 示例2：货币类
@total_ordering
class Money:
    def __init__(self, amount, currency="CNY"):
        self.amount = amount
        self.currency = currency
    
    def __eq__(self, other):
        if not isinstance(other, Money):
            return NotImplemented
        return self.amount == other.amount and self.currency == other.currency
    
    def __lt__(self, other):
        if not isinstance(other, Money):
            return NotImplemented
        if self.currency != other.currency:
            raise ValueError("不能比较不同货币")
        return self.amount < other.amount
    
    def __repr__(self):
        return f"Money({self.amount} {self.currency})"

print("\n货币类示例:")
m1 = Money(100)
m2 = Money(200)
m3 = Money(100)

print(f"m1: {m1}")
print(f"m2: {m2}")
print(f"m3: {m3}")
print()
print(f"m1 == m2: {m1 == m2}")
print(f"m1 == m3: {m1 == m3}")
print(f"m1 < m2: {m1 < m2}")
print(f"m1 <= m2: {m1 <= m2}")
print(f"m1 > m2: {m1 > m2}")
print(f"m1 >= m2: {m1 >= m2}")

# 示例3：不使用total_ordering的情况
class StudentWithoutTotalOrdering:
    def __init__(self, name, score):
        self.name = name
        self.score = score
    
    def __eq__(self, other):
        if not isinstance(other, StudentWithoutTotalOrdering):
            return NotImplemented
        return self.score == other.score
    
    def __lt__(self, other):
        if not isinstance(other, StudentWithoutTotalOrdering):
            return NotImplemented
        return self.score < other.score
    
    # 需要手动实现其他比较运算符
    def __le__(self, other):
        return self < other or self == other
    
    def __gt__(self, other):
        return not (self <= other)
    
    def __ge__(self, other):
        return not (self < other)
    
    def __repr__(self):
        return f"Student(name={self.name}, score={self.score})"

print("\n不使用total_ordering的实现对比:")
print("需要手动实现__eq__, __lt__, __le__, __gt__, __ge__")
print("而使用total_ordering只需要实现__eq__和__lt__等其中一个")

最佳实践：

• 当需要为自定义类实现完整的比较运算符时，使用total_ordering

• 只需要实现__eq__和__lt__、__le__、__gt__、__ge__中的一个即可

• 注意：如果比较操作很复杂，可能手动实现所有运算符会更清晰

3.2 reduce：序列累积操作

reduce函数对序列中的元素进行累积操作，将一个二元函数作用于序列的元素，每次携带一对元素，并将结果与下一个元素继续运算。

from functools import reduce

# 示例1：计算乘积
numbers = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, numbers)
print(f"列表 {numbers} 的乘积: {product}")

# 示例2：连接字符串
words = ["Hello", " ", "World", "!"]
sentence = reduce(lambda x, y: x + y, words)
print(f"连接后的字符串: '{sentence}'")

# 示例3：查找最大值
max_value = reduce(lambda x, y: x if x > y else y, numbers)
print(f"列表 {numbers} 的最大值: {max_value}")

# 示例4：实现阶乘
def factorial(n):
    return reduce(lambda x, y: x * y, range(1, n+1), 1)

print(f"5的阶乘: {factorial(5)}")

# 示例5：展开嵌套列表
def flatten(nested_list):
    return reduce(lambda x, y: x + y, nested_list, [])

nested = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
flat = flatten(nested)
print(f"展开嵌套列表 {nested}: {flat}")

# 示例6：统计字符出现次数
text = "hello world"
char_count = reduce(lambda d, c: {**d, c: d.get(c, 0) + 1}, text, {})
print(f"字符出现次数: {char_count}")

# 示例7：与map结合使用
# 计算平方和
squares_sum = reduce(lambda x, y: x + y, map(lambda x: x**2, numbers))
print(f"平方和: {squares_sum}")

# 示例8：实现自己的reduce函数
def my_reduce(func, iterable, initializer=None):
    it = iter(iterable)
    
    if initializer is None:
        try:
            value = next(it)
        except StopIteration:
            raise TypeError("reduce() of empty sequence with no initial value")
    else:
        value = initializer
    
    for element in it:
        value = func(value, element)
    
    return value

# 测试自己的reduce
result = my_reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
print(f"自定义reduce计算结果: {result}")

最佳实践：

• 当需要对序列进行累积操作时，考虑使用reduce

• 对于简单的求和、求积等操作，内置的sum、math.prod可能更合适

• 使用reduce时，提供初始值（initializer）通常更安全

3.3 cmp_to_key：将比较函数转换为key函数

cmp_to_key函数将老式的比较函数（返回-1, 0, 1）转换为key函数，用于sorted、min、max等函数。

from functools import cmp_to_key

# 示例1：自定义排序
def compare_length(s1, s2):
    """按长度排序，长度相同按字母顺序"""
    if len(s1) < len(s2):
        return -1
    elif len(s1) > len(s2):
        return 1
    else:
        if s1 < s2:
            return -1
        elif s1 > s2:
            return 1
        else:
            return 0

words = ["banana", "apple", "cherry", "date", "fig", "elderberry"]
sorted_words = sorted(words, key=cmp_to_key(compare_length))
print(f"按长度排序: {sorted_words}")

# 示例2：复杂的多条件排序
def student_comparator(s1, s2):
    """先按成绩降序，再按姓名升序"""
    if s1[1] > s2[1]:  # 成绩高的在前
        return -1
    elif s1[1] < s2[1]:
        return 1
    else:
        if s1[0] < s2[0]:  # 姓名按字母顺序
            return -1
        elif s1[0] > s2[0]:
            return 1
        else:
            return 0

students = [("张三", 85), ("李四", 92), ("王五", 85), ("赵六", 78)]
sorted_students = sorted(students, key=cmp_to_key(student_comparator))
print(f"学生排序: {sorted_students}")

# 示例3：版本号排序
def version_compare(v1, v2):
    """比较版本号，如'1.2.3'"""
    v1_parts = list(map(int, v1.split('.')))
    v2_parts = list(map(int, v2.split('.')))
    
    # 补齐长度
    max_len = max(len(v1_parts), len(v2_parts))
    v1_parts.extend([0] * (max_len - len(v1_parts)))
    v2_parts.extend([0] * (max_len - len(v2_parts)))
    
    for p1, p2 in zip(v1_parts, v2_parts):
        if p1 < p2:
            return -1
        elif p1 > p2:
            return 1
    
    return 0

versions = ["1.0", "2.1.5", "1.2", "1.10", "2.0", "1.0.1"]
sorted_versions = sorted(versions, key=cmp_to_key(version_compare))
print(f"版本号排序: {sorted_versions}")

# 示例4：与lambda结合
# 按绝对值排序，但保留原值
numbers = [-5, 3, -1, 4, -2, 0]
sorted_numbers = sorted(numbers, key=cmp_to_key(lambda x, y: abs(x) - abs(y)))
print(f"按绝对值排序: {sorted_numbers}")

最佳实践：

• 当需要复杂的多条件排序时，使用cmp_to_key

• 对于简单的排序，使用key参数通常更高效

• 比较函数应该返回负数、零或正数，表示第一个参数小于、等于或大于第二个参数

四、实战案例：构建函数式编程工具集

#!/usr/bin/env python3
"""
函数式编程工具集
演示functools模块在实际项目中的应用
"""

from functools import partial, lru_cache, wraps, reduce
import time
from typing import Callable, Any
import math

class FunctionPipeline:
    """函数管道，支持函数的组合和链式调用"""
    
    def __init__(self, func: Callable):
        self.func = func
        wraps(func)(self)  # 复制元信息
    
    def __call__(self, *args, **kwargs) -> Any:
        return self.func(*args, **kwargs)
    
    def then(self, next_func: Callable) -> 'FunctionPipeline':
        """将当前函数与下一个函数组合"""
        @wraps(self.func)
        def composed(*args, **kwargs):
            result = self.func(*args, **kwargs)
            return next_func(result)
        
        return FunctionPipeline(composed)
    
    def pipe(self, *funcs: Callable) -> 'FunctionPipeline':
        """将多个函数按顺序组合"""
        pipeline = self
        for func in funcs:
            pipeline = pipeline.then(func)
        return pipeline

# 示例1：数据处理管道
def add_tax(amount: float) -> float:
    """添加税费（10%）"""
    return amount * 1.1

def apply_discount(amount: float) -> float:
    """应用折扣（8折）"""
    return amount * 0.8

def format_currency(amount: float) -> str:
    """格式化货币显示"""
    return f"¥{amount:.2f}"

# 创建数据处理管道
calculate_total = FunctionPipeline(add_tax).then(apply_discount).then(format_currency)
print("数据处理管道示例:")
print(f"原始金额100 -> 最终结果: {calculate_total(100)}")

# 使用pipe方法
calculate_total2 = (FunctionPipeline(add_tax)
                    .pipe(apply_discount, format_currency))
print(f"使用pipe方法: {calculate_total2(100)}")

# 示例2：带缓存的API客户端
class APIClient:
    """模拟API客户端，带缓存功能"""
    
    def __init__(self):
        self.call_count = 0
    
    @lru_cache(maxsize=100)
    def get_user_data(self, user_id: int) -> dict:
        """获取用户数据（模拟API调用）"""
        self.call_count += 1
        time.sleep(0.5)  # 模拟网络延迟
        return {
            "id": user_id,
            "name": f"用户{user_id}",
            "email": f"user{user_id}@example.com"
        }
    
    def get_multiple_users(self, user_ids: list[int]) -> list[dict]:
        """获取多个用户数据，利用缓存"""
        return [self.get_user_data(user_id) for user_id in user_ids]

print("\n带缓存的API客户端示例:")
client = APIClient()
user_ids = [1, 2, 1, 3, 2, 1]  # 有重复ID

start_time = time.time()
users = client.get_multiple_users(user_ids)
end_time = time.time()

print(f"获取{len(user_ids)}个用户（实际{len(set(user_ids))}个不同用户）:")
print(f"实际API调用次数: {client.call_count}")
print(f"总耗时: {end_time - start_time:.2f}秒")
print(f"缓存信息: {client.get_user_data.cache_info()}")

# 示例3：偏函数在配置中的应用
class DatabaseConfig:
    """数据库配置，使用偏函数简化连接创建"""
    
    @staticmethod
    def create_connection(host: str, port: int, database: str, 
                          user: str, password: str) -> dict:
        """创建数据库连接配置"""
        return {
            "host": host,
            "port": port,
            "database": database,
            "user": user,
            "password": password,
            "connection_string": f"{user}:{password}@{host}:{port}/{database}"
        }
    
    # 为不同环境创建预配置的连接函数
    create_dev_connection = partial(
        create_connection,
        host="localhost",
        port=5432,
        user="dev_user",
        password="dev_pass"
    )
    
    create_prod_connection = partial(
        create_connection,
        host="prod-db.example.com",
        port=5432,
        user="prod_user",
        password="prod_pass_123"
    )

print("\n偏函数在配置中的应用:")
config = DatabaseConfig()

# 开发环境连接
dev_config = config.create_dev_connection(database="myapp_dev")
print(f"开发环境配置: {dev_config['connection_string']}")

# 生产环境连接
prod_config = config.create_prod_connection(database="myapp_prod")
print(f"生产环境配置: {prod_config['connection_string']}")

# 示例4：使用reduce实现复杂数据转换
def process_sales_data(sales: list[dict]) -> dict:
    """处理销售数据，计算各种统计信息"""
    
    def reducer(acc: dict, sale: dict) -> dict:
        """reduce函数，累积统计信息"""
        product = sale["product"]
        amount = sale["amount"]
        
        # 按产品统计
        if product not in acc["by_product"]:
            acc["by_product"][product] = {"total": 0, "count": 0}
        
        acc["by_product"][product]["total"] += amount
        acc["by_product"][product]["count"] += 1
        
        # 总体统计
        acc["total_amount"] += amount
        acc["total_count"] += 1
        acc["max_amount"] = max(acc["max_amount"], amount)
        acc["min_amount"] = min(acc["min_amount"], amount)
        
        return acc
    
    # 初始值
    initial = {
        "by_product": {},
        "total_amount": 0,
        "total_count": 0,
        "max_amount": float("-inf"),
        "min_amount": float("inf")
    }
    
    return reduce(reducer, sales, initial)

# 模拟销售数据
sales_data = [
    {"product": "手机", "amount": 2999},
    {"product": "电脑", "amount": 8999},
    {"product": "手机", "amount": 3999},
    {"product": "平板", "amount": 4999},
    {"product": "电脑", "amount": 7999},
    {"product": "手机", "amount": 2999},
]

print("\n使用reduce处理销售数据:")
result = process_sales_data(sales_data)
print(f"总销售额: ¥{result['total_amount']}")
print(f"总订单数: {result['total_count']}")
print(f"最高订单金额: ¥{result['max_amount']}")
print(f"最低订单金额: ¥{result['min_amount']}")
print("\n按产品统计:")
for product, stats in result["by_product"].items():
    avg = stats["total"] / stats["count"]
    print(f"  {product}: {stats['count']}笔, 总额: ¥{stats['total']}, 平均: ¥{avg:.0f}")

五、注意事项

5.1 使用限制

1. 缓存内存消耗：lru_cache会消耗内存存储结果，不宜缓存过多结果

2. 偏函数不可变：偏函数创建后不能修改已绑定的参数

3. reduce的可读性：复杂的reduce操作可能难以理解，需适当添加注释

4. 装饰器顺序：多个装饰器组合时，顺序很重要

5.2 常见问题

Q: 什么时候使用偏函数，什么时候使用lambda？

A: 偏函数更适合固定多个参数或提高代码可读性，lambda适合简单的一次性函数。

Q: lru_cache能缓存所有函数吗？

A: 不能，只有纯函数（输出只由输入决定）适合缓存，有副作用或依赖外部状态的函数不适合。

Q: 如何清除lru_cache的缓存？

A: 使用函数.cache_clear()方法。

Q: total_ordering有什么性能影响？

A: 会有轻微性能开销，因为需要在运行时生成比较方法，但对于大多数应用来说可以忽略。

5.3 替代方案

1. 装饰器库：第三方库如decorator提供更强大的装饰器工具

2. 缓存库：cachetools提供更多缓存策略

3. 函数组合：第三方库如toolz提供更多函数式编程工具

4. 列表推导式：简单的转换和过滤，列表推导式可能更合适

六、总结

functools模块是Python函数式编程的重要工具，它提供了：

• ✅ 偏函数：partial，固定函数参数，创建新函数

• ✅ 函数缓存：lru_cache，记住函数结果，提高性能

• ✅ 装饰器工具：wraps，保持被装饰函数的元信息

• ✅ 比较运算符：total_ordering，简化比较运算符的实现

• ✅ 序列操作：reduce，对序列进行累积操作

• ✅ 排序工具：cmp_to_key，将比较函数转换为key函数

核心价值：

1. 提高代码复用：通过偏函数、装饰器等减少重复代码

2. 提升性能：通过缓存装饰器优化函数性能

3. 增强可读性：使函数式编程代码更清晰易懂

4. 保持兼容性：提供与旧代码的兼容支持

给你的建议：

1. 创建装饰器时，总是使用@wraps

2. 对计算昂贵的纯函数使用lru_cache

3. 需要固定函数参数时，使用partial创建专用函数

4. 实现自定义类比较运算符时，使用total_ordering简化实现

5. 对序列进行复杂累积操作时，考虑使用reduce

掌握functools模块，你的Python代码将变得更加函数式、更高效、更优雅。这些函数式编程工具能帮助你写出更简洁、更可维护的代码。

---