Python中的函数式编程工具：functools模块详解

1. 模块概述
functools是Python标准库中用于支持函数式编程的模块，提供了一系列高阶函数和工具，用于增强或扩展函数的行为。常见工具包括：缓存、函数包装、部分函数应用等。下面通过具体功能逐步解析。

2. 核心功能详解

2.1 缓存机制：@lru_cache

• 问题场景：递归或重复计算密集型函数时，避免重复计算。
• 原理：使用最近最少使用（LRU）策略缓存函数结果，通过字典存储参数与结果的映射。
• 使用步骤：
  1. 导入装饰器：from functools import lru_cache
  2. 修饰目标函数，指定缓存大小（如maxsize=128，默认为128，None表示无限制）：

     @lru_cache(maxsize=32)  
     def fib(n):  
         if n < 2:  
             return n  
         return fib(n-1) + fib(n-2)  
     

  3. 首次调用fib(10)会递归计算并缓存结果，后续相同参数直接返回缓存值。
• 注意事项：
  • 函数参数必须是可哈希的（如整数、字符串、元组）。
  • 缓存会占用内存，需根据业务需求设置maxsize。

2.2 部分函数应用：partial

• 问题场景：固定函数的部分参数，生成新函数简化调用。
• 原理：通过闭包绑定部分参数，返回一个接受剩余参数的新函数。
• 示例：

  from functools import partial  
  
  def multiply(x, y):  
      return x * y  
  
  # 固定x=2，生成新函数double  
  double = partial(multiply, 2)  
  print(double(4))  # 输出8（等价于multiply(2, 4)）  
  

• 应用场景：
  • 回调函数参数预置（如GUI事件处理）。
  • 替代lambda实现更清晰的代码（如partial(sorted, key=lambda x: x[1])）。

2.3 函数包装与元数据保留：wraps

• 问题场景：使用装饰器时，被装饰函数的__name__、__doc__等元信息会被覆盖。
• 解决方案：用@wraps装饰器将原函数的元数据复制到包装函数。
• 示例：

  from functools import wraps  
  
  def my_decorator(func):  
      @wraps(func)  # 保留func的元数据  
      def wrapper(*args, **kwargs):  
          print("函数被调用")  
          return func(*args, **kwargs)  
      return wrapper  
  
  @my_decorator  
  def example():  
      """示例函数文档"""  
      pass  
  
  print(example.__name__)  # 输出"example"（而非"wrapper"）  
  print(example.__doc__)   # 输出"示例函数文档"  
  

2.4 函数排序与比较：cmp_to_key

• 问题场景：Python 3废弃了cmp参数（接受两个参数的比较函数），但某些场景仍需自定义复杂比较逻辑。
• 作用：将旧式比较函数转换为key函数，用于sorted()、min()等。
• 示例（按字符串长度和字母序排序）：

  from functools import cmp_to_key  
  
  def compare(a, b):  
      # 长度优先，长度相同按字母序  
      if len(a) != len(b):  
          return len(a) - len(b)  
      return 1 if a > b else -1  
  
  words = ["apple", "cat", "banana", "z"]  
  sorted_words = sorted(words, key=cmp_to_key(compare))  
  # 输出：['z', 'cat', 'apple', 'banana']  
  

2.5 高阶归约函数：reduce

• 功能：对序列中的元素连续应用二元函数，逐步合并为单个结果。
• 示例（计算阶乘）：

  from functools import reduce  
  
  n = 5  
  factorial = reduce(lambda x, y: x * y, range(1, n+1))  
  print(factorial)  # 输出120  
  

• 等效过程：reduce(f, [a, b, c, d]) → f(f(f(a, b), c), d)。

3. 进阶工具：singledispatch

• 问题场景：根据参数类型实现函数重载（类似Java的多态）。
• 用法：
  1. 用@singledispatch装饰基础函数处理默认类型。
  2. 用@<基函数名>.register注册特定类型的处理逻辑。
• 示例：

  from functools import singledispatch  
  
  @singledispatch  
  def process(arg):  
      print("默认处理", arg)  
  
  @process.register(int)  
  def _(arg):  
      print("处理整数", arg)  
  
  @process.register(list)  
  def _(arg):  
      print("处理列表", arg)  
  
  process(10)    # 输出"处理整数 10"  
  process([])    # 输出"处理列表 []"  
  process("hi")  # 输出"默认处理 hi"  
  

4. 总结

• 缓存优化：lru_cache适合递归或重复计算场景，注意参数可哈希性。
• 函数简化：partial减少参数冗余，提升代码可读性。
• 元数据保护：wraps是装饰器编程的最佳实践。
• 兼容性与灵活性：cmp_to_key和singledispatch提供面向传统和类型驱动的解决方案。
• 函数式编程核心：reduce是处理累积计算的重要工具。

通过掌握functools模块，可以写出更高效、易维护的函数式代码，尤其在装饰器、缓存和类型处理等场景中作用显著。