好的，现在开始。
函数式编程是一种编程范式，它将计算视为数学函数的求值，并避免状态更改和可变数据。Python 提供了多种工具来支持函数式编程，其中 functools 模块是其中的重要组成部分。本讲座将深入探讨 functools 模块中的 lru_cache、partial 和 singledispatch，并展示它们如何在函数式编程中发挥作用。
一、lru_cache: 缓存结果，提高效率
在函数式编程中，函数应该具有引用透明性，即相同的输入始终产生相同的输出。这意味着我们可以安全地缓存函数的计算结果，并在后续调用中使用缓存的结果，而无需重新计算。functools.lru_cache 装饰器提供了一种简单而有效的方式来实现这种缓存。
lru_cache 代表 "Least Recently Used Cache"，它使用 LRU (最近最少使用) 算法来管理缓存。当缓存已满时，最近最少使用的结果将被丢弃，以便为新的结果腾出空间。
- 基本用法：
from functools import lru_cache
@lru_cache(maxsize=None) # maxsize=None 表示无限制缓存
def fibonacci(n):
if n < 2:
return n
return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(10)) # 第一次计算，耗时较长
print(fibonacci(10)) # 第二次计算，几乎瞬间完成，从缓存中获取
print(fibonacci.cache_info()) #获取缓存信息在这个例子中，fibonacci 函数的计算结果会被缓存。当我们第一次调用 fibonacci(10) 时，函数会执行计算并将其结果存储在缓存中。当我们第二次调用 fibonacci(10) 时，函数会直接从缓存中获取结果，而无需重新计算，从而大大提高了效率。
maxsize参数：
maxsize 参数控制缓存的大小。它可以设置为以下值：
* `None`: 表示缓存大小无限制。
* 正整数: 表示缓存可以存储的最大结果数量。当缓存已满时，最近最少使用的结果将被丢弃。
* 0: 禁用缓存。@lru_cache(maxsize=3)
def expensive_function(arg):
print(f"Calculating for {arg}")
# 模拟耗时操作
import time
time.sleep(1)
return arg * 2
print(expensive_function(1))
print(expensive_function(2))
print(expensive_function(3))
print(expensive_function(1)) # 1 被丢弃，重新计算
print(expensive_function(4)) # 2 被丢弃
print(expensive_function(2)) # 2 被丢弃，重新计算typed参数：
typed 参数指定是否根据参数类型进行缓存。如果 typed=True，则 fibonacci(3) 和 fibonacci(3.0) 将被视为不同的调用，并分别缓存其结果。如果 typed=False (默认值)，则它们将被视为相同的调用。
@lru_cache(maxsize=None, typed=True)
def my_function(arg):
print(f"Calculating for {arg}, type: {type(arg)}")
return arg * 2
print(my_function(3))
print(my_function(3.0)) #typed=True 时，会重新计算- 缓存信息和清理：
lru_cache 装饰器还提供了以下方法来获取缓存信息和清理缓存：
* `cache_info()`: 返回一个 namedtuple，包含缓存命中次数、未命中次数、最大缓存大小和当前缓存大小。
* `cache_clear()`: 清除缓存中的所有结果。fibonacci(12)
print(fibonacci.cache_info())
fibonacci.cache_clear()
print(fibonacci.cache_info())- 适用场景：
lru_cache 适用于以下场景：
* 函数具有引用透明性 (相同的输入始终产生相同的输出)。
* 函数的计算成本较高。
* 函数会被频繁调用，且具有重复的输入。
* 对内存消耗不敏感。-
注意事项：
lru_cache只能用于缓存可哈希 (hashable) 的参数。这意味着参数必须是不可变的，例如数字、字符串、元组等。列表和字典等可变对象不能作为参数。lru_cache会增加内存消耗，因为它需要存储缓存的结果。在内存受限的环境中，需要谨慎使用。- 不应该在有副作用的函数中使用
lru_cache，因为缓存可能会导致副作用只执行一次。
二、partial: 固定参数，创建新函数
functools.partial 允许我们创建一个新的函数，该函数固定了原始函数的部分参数。这在函数式编程中非常有用，因为它可以让我们创建更具特定用途的函数，而无需编写新的函数。
- 基本用法：
from functools import partial
def multiply(x, y):
return x * y
double = partial(multiply, 2) # 固定 x=2
triple = partial(multiply, y=3) # 固定 y=3
print(double(5)) # 相当于 multiply(2, 5)
print(triple(7)) # 相当于 multiply(7, 3)在这个例子中，我们使用 partial 创建了 double 函数，它固定了 multiply 函数的第一个参数为 2。我们还创建了 triple 函数，它固定了 multiply 函数的第二个参数为 3。
- 参数顺序：
partial 函数可以固定位置参数和关键字参数。位置参数按照原始函数定义的顺序进行固定，关键字参数则通过关键字进行固定。
def power(base, exponent=2):
return base ** exponent
square = partial(power) # 固定 exponent=2，等价于 power(base, exponent=2)
cube = partial(power, exponent=3) # 固定 exponent=3， 等价于 power(base, exponent=3)
power_of_2 = partial(power, 2) # 固定 base=2， 等价于 power(base=2, exponent=2)
print(square(5))
print(cube(5))
print(power_of_2(exponent=4))- 多个
partial调用：
我们可以多次调用 partial 来固定多个参数。
def add(x, y, z):
return x + y + z
add_1_2 = partial(add, 1, 2)
add_1_2_and_3 = partial(add_1_2, 3)
print(add_1_2_and_3())partial对象属性：
partial 对象具有以下属性：
* `func`: 原始函数。
* `args`: 固定位置参数的元组。
* `keywords`: 固定关键字参数的字典。print(double.func)
print(double.args)
print(double.keywords)- 适用场景：
partial 适用于以下场景：
* 需要创建具有特定用途的函数，而无需编写新的函数。
* 需要固定函数的某些参数，以便在后续调用中简化参数传递。
* 需要将函数作为参数传递给其他函数，但需要先固定某些参数。-
注意事项：
partial不会改变原始函数。它只是创建一个新的函数，该函数调用原始函数并传递固定的参数。partial可以用于固定任何可调用对象，包括函数、方法、类等。
三、singledispatch: 基于参数类型进行函数分派
functools.singledispatch 允许我们基于函数的第一个参数的类型来分派函数。这在函数式编程中非常有用，因为它可以让我们创建更通用的函数，该函数可以处理不同类型的数据。
- 基本用法：
from functools import singledispatch
@singledispatch
def my_function(arg):
print("Default implementation for:", type(arg))
@my_function.register(int)
def _(arg):
print("Integer implementation:", arg * 2)
@my_function.register(str)
def _(arg):
print("String implementation:", arg.upper())
my_function(10) # Integer implementation: 20
my_function("hello") # String implementation: HELLO
my_function([1, 2, 3]) # Default implementation for: <class 'list'>在这个例子中，我们使用 singledispatch 创建了 my_function 函数，它根据第一个参数的类型来分派不同的实现。我们使用 register 方法来注册不同类型的实现。
- 默认实现：
使用 @singledispatch 装饰的函数是默认实现，当没有找到与参数类型匹配的注册实现时，将调用默认实现。
- 类型层次结构：
singledispatch 支持类型层次结构。如果一个类型没有注册实现，则会查找其父类的实现。
class MyList(list):
pass
@my_function.register(list)
def _(arg):
print("List implementation:", len(arg))
my_function([1, 2, 3]) # List implementation: 3
my_function(MyList([4, 5])) # List implementation: 2在这个例子中，MyList 类继承自 list 类。当我们调用 my_function(MyList([4, 5])) 时，由于 MyList 类没有注册实现，因此会调用 list 类的实现。
- 抽象基类 (ABC)：
singledispatch 也支持抽象基类 (ABC)。我们可以使用 ABC 来定义一组接口，并为不同的 ABC 注册实现。
from abc import ABC, abstractmethod
class Animal(ABC):
@abstractmethod
def speak(self):
pass
class Dog(Animal):
def speak(self):
return "Woof!"
class Cat(Animal):
def speak(self):
return "Meow!"
@singledispatch
def make_sound(animal):
raise NotImplementedError("Unsupported animal type")
@make_sound.register(Dog)
def _(animal):
return animal.speak()
@make_sound.register(Cat)
def _(animal):
return animal.speak()
dog = Dog()
cat = Cat()
print(make_sound(dog))
print(make_sound(cat))- 适用场景：
singledispatch 适用于以下场景：
* 需要创建更通用的函数，该函数可以处理不同类型的数据。
* 需要基于参数类型来分派不同的实现。
* 需要支持类型层次结构和抽象基类。-
注意事项：
singledispatch只能基于函数的第一个参数的类型进行分派。singledispatch会增加代码的复杂性。- 如果参数类型太多，使用
singledispatch可能会导致代码难以维护。
四、lru_cache、partial 和 singledispatch 结合使用
这三个工具可以结合使用，以创建更强大和灵活的函数式程序。
from functools import lru_cache, partial, singledispatch
@lru_cache(maxsize=128)
@singledispatch
def process_data(data):
print(f"Default processing for type: {type(data)}")
return str(data) # Convert to string as default
@process_data.register(int)
def _(data):
print("Processing integer data")
return data * 2
@process_data.register(list)
def _(data):
print("Processing list data")
return [process_data(item) for item in data] # Recursively process items
# Create a specialized function using partial
process_list_data = partial(process_data, data=[1, 2, "a"])
print(process_data(5)) # Integer processing, cached
print(process_data([1, 2, 3])) # List processing, items processed recursively, cached
print(process_list_data()) # List processing (pre-defined data), cached
print(process_data([1,2,3])) #Retrieve from cache
在这个例子中，process_data 函数使用 singledispatch 根据输入数据的类型执行不同的处理。 lru_cache 装饰器用于缓存 process_data 函数的结果，以提高效率。 process_list_data 使用 partial 预先设置了process_data的参数，专门用于处理列表数据。
五、案例分析：使用 functools 优化数据处理管道
假设我们有一个数据处理管道，它包含多个步骤，每个步骤都对数据进行转换。我们可以使用 functools 来优化这个管道。
from functools import partial, lru_cache
def load_data(filename):
"""从文件中加载数据"""
with open(filename, 'r') as f:
return f.readlines()
def clean_data(data):
"""清理数据，去除空格和换行符"""
return [line.strip() for line in data]
@lru_cache(maxsize=32)
def process_line(line):
"""处理单行数据，进行一些计算"""
# 模拟耗时操作
result = len(line) * 2
return result
def analyze_data(processed_data):
"""分析处理后的数据，计算总和"""
return sum(processed_data)
# 创建数据处理管道
def data_pipeline(filename):
data = load_data(filename)
cleaned_data = clean_data(data)
processed_data = [process_line(line) for line in cleaned_data]
analysis_result = analyze_data(processed_data)
return analysis_result
# 使用 partial 创建一个预先指定文件名的管道
process_specific_file = partial(data_pipeline, filename="data.txt")
# 创建模拟数据文件
with open("data.txt", "w") as f:
f.write(" line 1n")
f.write("line 2 n")
f.write("line 1n") # 故意重复
f.write("line 3n")
# 执行数据处理管道
result1 = data_pipeline("data.txt")
result2 = data_pipeline("data.txt") # 第二次执行更快，因为 process_line 被缓存
result3 = process_specific_file() # 使用 partial 创建的管道
print(f"Result 1: {result1}")
print(f"Result 2: {result2}")
print(f"Result 3: {result3}")
print(process_line.cache_info())
在这个例子中，我们使用 lru_cache 来缓存 process_line 函数的结果，从而避免重复计算。我们还使用 partial 创建了一个预先指定文件名的管道 process_specific_file，从而简化了调用。
六、何时使用这些工具？
以下表格总结了 lru_cache、partial 和 singledispatch 的适用场景：
| 工具 | 适用场景 |
|---|---|
lru_cache |
函数具有引用透明性，计算成本高，会被频繁调用，且具有重复的输入。 |
partial |
需要创建具有特定用途的函数，固定函数的某些参数，将函数作为参数传递给其他函数。 |
singledispatch |
需要创建更通用的函数，该函数可以处理不同类型的数据，需要基于参数类型来分派不同的实现，需要支持类型层次结构和抽象基类。 |
总结和回顾
本讲座深入探讨了 functools 模块中的 lru_cache、partial 和 singledispatch。lru_cache 帮助我们缓存函数结果，提升性能；partial 允许我们固定函数参数，创建更专业化的函数；singledispatch 则实现了基于参数类型的函数分派，增强了函数的通用性。这些工具是 Python 函数式编程中不可或缺的组成部分，熟练掌握它们可以使我们编写出更高效、更灵活和更易于维护的代码。
掌握这些工具，写出更优雅的代码
通过学习本讲座的内容，你现在应该对 functools 模块中的 lru_cache、partial 和 singledispatch 有了更深入的了解。掌握这些工具，可以让你在函数式编程的道路上走得更远，编写出更优雅、更高效的代码。
灵活运用，解决实际问题
希望你能将这些工具应用到实际项目中，解决实际问题。函数式编程是一种强大的编程范式，它能帮助你更好地组织和管理代码，提高代码的可读性和可维护性。