Python 函数式编程进阶：functools 与 itertools 的高级应用
大家好！今天我们来深入探讨 Python 函数式编程的两个强大模块：functools 和 itertools。虽然 Python 并非纯粹的函数式语言，但它提供了足够的支持，让我们能够利用函数式编程的优势，编写更简洁、更可读、更易于维护的代码。这两个模块正是 Python 函数式编程工具箱中的利器。
一、functools：高阶函数与函数工具
functools 模块提供了一些用于操作函数的高阶函数，主要用于函数适配、缓存和比较等方面。
1.1 partial()：固定部分参数
partial() 允许我们“冻结”一个函数的部分参数，创建一个新的、参数更少的函数。这在需要重复使用具有某些相同参数的函数时非常有用。
from functools import partial
def power(base, exponent):
"""计算 base 的 exponent 次方。"""
return base ** exponent
# 创建一个计算平方的函数
square = partial(power, exponent=2)
# 创建一个计算立方体的函数
cube = partial(power, exponent=3)
print(square(5)) # 输出: 25
print(cube(2)) # 输出: 8在这个例子中，我们使用 partial() 创建了 square 和 cube 函数，分别固定了 exponent 参数为 2 和 3。 这避免了每次调用 power() 时都重复指定 exponent 的麻烦。
partial() 的一个常见应用场景是 GUI 编程中，将事件处理函数与特定的参数绑定。
import tkinter as tk
from functools import partial
def button_click(message):
print(f"Button clicked: {message}")
root = tk.Tk()
# 创建一个按钮，点击时打印 "Hello"
button1 = tk.Button(root, text="Button 1", command=partial(button_click, "Hello"))
button1.pack()
# 创建另一个按钮，点击时打印 "World"
button2 = tk.Button(root, text="Button 2", command=partial(button_click, "World"))
button2.pack()
root.mainloop()1.2 lru_cache()：缓存函数结果
lru_cache() 是一个装饰器，用于缓存函数的返回值。 当函数被调用时，如果参数与之前调用过的参数相同，则直接从缓存中返回结果，避免重复计算。这对于计算密集型或 I/O 密集型函数，以及具有重复调用的函数来说，可以显著提高性能。
from functools import lru_cache
import time
@lru_cache(maxsize=None) # maxsize=None 表示缓存大小无限制
def fibonacci(n):
"""计算斐波那契数列的第 n 个数。"""
if n <= 1:
return n
return fibonacci(n-1) + fibonacci(n-2)
start_time = time.time()
print(fibonacci(30))
end_time = time.time()
print(f"第一次调用耗时: {end_time - start_time:.4f} 秒")
start_time = time.time()
print(fibonacci(30))
end_time = time.time()
print(f"第二次调用耗时: {end_time - start_time:.4f} 秒")可以看到，第二次调用 fibonacci(30) 的速度明显快于第一次，因为结果已经从缓存中获取。lru_cache() 的 maxsize 参数控制缓存的大小，默认为 128。 当缓存满时，会使用 Least Recently Used (LRU) 算法淘汰最久未使用的缓存项。 maxsize=None 表示缓存大小无限制。
lru_cache() 还有一个 typed 参数，默认为 False。如果 typed=True，则会将不同类型的参数分开缓存。例如，fibonacci(3) 和 fibonacci(3.0) 会被认为是不同的调用，并分别缓存结果。
1.3 wraps()：保留函数元数据
wraps() 是一个装饰器，用于在编写装饰器时，保留被装饰函数的元数据（例如，__name__、__doc__ 等）。 这对于调试和文档生成非常重要。
from functools import wraps
def my_decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
"""Wrapper function."""
print("Before calling the function.")
result = func(*args, **kwargs)
print("After calling the function.")
return result
return wrapper
@my_decorator
def my_function(x):
"""This is my function."""
return x * 2
print(my_function.__name__) # 输出: my_function
print(my_function.__doc__) # 输出: This is my function.如果没有使用 wraps()，my_function.__name__ 将会是 wrapper，my_function.__doc__ 将会是 "Wrapper function."。 wraps() 可以确保装饰器不会改变被装饰函数的元数据，使其行为更符合预期。
1.4 reduce()：累计计算
虽然 reduce() 函数现在位于 functools 模块中，但它原本是内置函数。 reduce() 将一个函数应用于一个序列的所有元素，将其累计为一个单一的值。
from functools import reduce
numbers = [1, 2, 3, 4, 5]
# 计算列表中所有数字的和
sum_of_numbers = reduce(lambda x, y: x + y, numbers)
print(sum_of_numbers) # 输出: 15
# 计算列表中所有数字的乘积
product_of_numbers = reduce(lambda x, y: x * y, numbers)
print(product_of_numbers) # 输出: 120reduce() 接受两个参数：一个函数和一个序列。 函数必须接受两个参数，并返回一个值。reduce() 首先将函数应用于序列的前两个元素，然后将结果与序列的第三个元素一起应用于函数，依此类推，直到序列中的所有元素都被处理完毕。
虽然 reduce() 功能强大，但在很多情况下，使用循环或列表推导式可以更清晰地表达相同的逻辑。 因此，在选择使用 reduce() 之前，请仔细考虑其可读性。
1.5 cmp_to_key()：自定义排序
cmp_to_key() 用于将旧式的比较函数转换为 key 函数，以便与 sorted() 函数或 list.sort() 方法一起使用。 在 Python 3 中，已经移除了 cmp 参数，而是推荐使用 key 参数进行自定义排序。
from functools import cmp_to_key
def compare_numbers(x, y):
"""比较两个数字的大小。"""
if x < y:
return -1
elif x > y:
return 1
else:
return 0
numbers = [5, 2, 8, 1, 9]
# 使用 cmp_to_key 进行排序
sorted_numbers = sorted(numbers, key=cmp_to_key(compare_numbers))
print(sorted_numbers) # 输出: [1, 2, 5, 8, 9]在这个例子中，compare_numbers() 是一个比较函数，它接受两个参数，并返回 -1、0 或 1，分别表示第一个参数小于、等于或大于第二个参数。 cmp_to_key() 将这个比较函数转换为一个 key 函数，可以用于 sorted() 函数进行排序。
现在更推荐使用 lambda 表达式来定义 key 函数，这样可以更简洁地实现自定义排序。
numbers = [5, 2, 8, 1, 9]
# 使用 lambda 表达式进行排序（升序）
sorted_numbers = sorted(numbers, key=lambda x: x)
# 使用 lambda 表达式进行排序（降序）
sorted_numbers_descending = sorted(numbers, key=lambda x: -x)
print(sorted_numbers) # 输出: [1, 2, 5, 8, 9]
print(sorted_numbers_descending) # 输出: [9, 8, 5, 2, 1]二、itertools：迭代器工具
itertools 模块提供了一系列用于创建和操作迭代器的工具函数。 迭代器是一种可以逐个访问序列元素的对象，而无需一次性将整个序列加载到内存中。 这使得 itertools 非常适合处理大型数据集或无限序列。
2.1 无限迭代器
itertools 模块提供了三个无限迭代器：count()、cycle() 和 repeat()。
count(start=0, step=1): 生成一个从start开始，以step为步长的无限序列。
from itertools import count
# 生成一个从 1 开始，步长为 2 的无限序列
for i in count(1, 2):
if i > 10:
break
print(i) # 输出: 1 3 5 7 9cycle(iterable): 无限循环遍历一个可迭代对象。
from itertools import cycle
colors = ['red', 'green', 'blue']
# 无限循环遍历颜色列表
for color in cycle(colors):
print(color)
# 为了避免无限循环，需要添加一个停止条件
# 这里仅打印 5 次
if color == 'green':
count = 0
for color in cycle(colors):
print(color)
count += 1
if count == 5:
break
breakrepeat(object, times=None): 重复生成一个对象times次。 如果times为None，则无限重复。
from itertools import repeat
# 重复生成 "Hello" 5 次
for message in repeat("Hello", 5):
print(message)
#无限重复生成数字 1
#for one in repeat(1):
# print(one) #小心无限循环！2.2 组合迭代器
itertools 模块提供了几个用于生成组合的迭代器：combinations()、permutations() 和 combinations_with_replacement()。
combinations(iterable, r): 生成一个包含iterable中所有长度为r的组合的迭代器。 组合是元素的无序选择，不考虑顺序。
from itertools import combinations
letters = ['A', 'B', 'C']
# 生成所有长度为 2 的组合
for combination in combinations(letters, 2):
print(combination) # 输出: ('A', 'B') ('A', 'C') ('B', 'C')permutations(iterable, r=None): 生成一个包含iterable中所有长度为r的排列的迭代器。 排列是元素的有序选择，考虑顺序。 如果r为None，则生成所有可能的排列。
from itertools import permutations
letters = ['A', 'B', 'C']
# 生成所有长度为 2 的排列
for permutation in permutations(letters, 2):
print(permutation) # 输出: ('A', 'B') ('A', 'C') ('B', 'A') ('B', 'C') ('C', 'A') ('C', 'B')
# 生成所有可能的排列
for permutation in permutations(letters):
print(permutation) #输出：('A', 'B', 'C') ('A', 'C', 'B') ('B', 'A', 'C') ('B', 'C', 'A') ('C', 'A', 'B') ('C', 'B', 'A')combinations_with_replacement(iterable, r): 生成一个包含iterable中所有长度为r的组合（允许重复元素）的迭代器。
from itertools import combinations_with_replacement
letters = ['A', 'B', 'C']
# 生成所有长度为 2 的组合（允许重复元素）
for combination in combinations_with_replacement(letters, 2):
print(combination) # 输出: ('A', 'A') ('A', 'B') ('A', 'C') ('B', 'B') ('B', 'C') ('C', 'C')2.3 终止迭代器
itertools 模块提供了一些用于终止迭代的迭代器：accumulate()、chain()、compress()、dropwhile()、filterfalse()、groupby()、islice()、starmap()、takewhile()、tee() 和 zip_longest()。
这里只介绍几个常用的：
accumulate(iterable, func=operator.add): 生成一个包含iterable中元素累积结果的迭代器。func是一个接受两个参数的函数，用于计算累积结果。 默认情况下，func为operator.add，即计算累加和。
from itertools import accumulate
import operator
numbers = [1, 2, 3, 4, 5]
# 计算累加和
for accumulated_sum in accumulate(numbers):
print(accumulated_sum) # 输出: 1 3 6 10 15
# 计算累乘积
for accumulated_product in accumulate(numbers, operator.mul):
print(accumulated_product) # 输出: 1 2 6 24 120- *`chain(iterables)`**: 将多个可迭代对象连接成一个迭代器。
from itertools import chain
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = [7, 8, 9]
# 将三个列表连接成一个迭代器
for number in chain(list1, list2, list3):
print(number) # 输出: 1 2 3 4 5 6 7 8 9compress(data, selectors): 使用selectors中的布尔值来过滤data中的元素。 只有当selectors中的对应元素为True时，data中的元素才会被保留。
from itertools import compress
data = ['A', 'B', 'C', 'D', 'E']
selectors = [True, False, True, False, True]
# 使用 selectors 过滤 data
for item in compress(data, selectors):
print(item) # 输出: A C Egroupby(iterable, key=None): 将iterable中相邻的具有相同key值的元素分组。key是一个函数，用于计算元素的键值。 如果key为None，则使用元素本身作为键值。
from itertools import groupby
data = [
('A', 1),
('A', 2),
('B', 3),
('B', 4),
('C', 5)
]
# 按第一个元素分组
for key, group in groupby(data, lambda x: x[0]):
print(key, list(group)) # 输出: A [('A', 1), ('A', 2)] B [('B', 3), ('B', 4)] C [('C', 5)]islice(iterable, start, stop, step=1): 从iterable中切片，返回一个迭代器。 类似于列表切片，但返回的是迭代器。
from itertools import islice
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 从索引 2 开始，到索引 7 结束（不包含索引 7），步长为 2
for number in islice(numbers, 2, 7, 2):
print(number) # 输出: 2 4 6tee(iterable, n=2): 从一个可迭代对象创建n个独立的迭代器。
from itertools import tee
numbers = [1, 2, 3, 4, 5]
# 创建两个独立的迭代器
iterator1, iterator2 = tee(numbers, 2)
# 遍历第一个迭代器
for number in iterator1:
print(f"Iterator 1: {number}")
# 遍历第二个迭代器
for number in iterator2:
print(f"Iterator 2: {number}")- *`zip_longest(iterables, fillvalue=None)
**: 并行地从多个可迭代对象中获取元素，直到所有可迭代对象都耗尽。 如果某个可迭代对象比其他可迭代对象短，则使用fillvalue` 填充缺失的元素。
from itertools import zip_longest
list1 = [1, 2, 3]
list2 = ['A', 'B', 'C', 'D']
# 并行遍历两个列表，使用 "None" 填充缺失的元素
for number, letter in zip_longest(list1, list2, fillvalue="None"):
print(f"Number: {number}, Letter: {letter}")
#输出:
#Number: 1, Letter: A
#Number: 2, Letter: B
#Number: 3, Letter: C
#Number: None, Letter: D三、总结表格
| 函数/迭代器 | 所属模块 | 功能描述 | 示例 |
|---|---|---|---|
partial() |
functools |
固定函数的部分参数，创建一个新的函数。 | square = partial(power, exponent=2) |
lru_cache() |
functools |
缓存函数的返回值，提高性能。 | @lru_cache(maxsize=None) |
wraps() |
functools |
在编写装饰器时，保留被装饰函数的元数据。 | @wraps(func) |
reduce() |
functools |
将一个函数应用于一个序列的所有元素，将其累计为一个单一的值。 | sum_of_numbers = reduce(lambda x, y: x + y, numbers) |
cmp_to_key() |
functools |
将旧式的比较函数转换为 key 函数，以便与 sorted() 函数或 list.sort() 方法一起使用。 |
sorted_numbers = sorted(numbers, key=cmp_to_key(compare_numbers)) |
count() |
itertools |
生成一个无限序列，从指定的起始值开始，以指定的步长递增。 | for i in count(1, 2): ... |
cycle() |
itertools |
无限循环遍历一个可迭代对象。 | for color in cycle(colors): ... |
repeat() |
itertools |
重复生成一个对象指定的次数。 | for message in repeat("Hello", 5): ... |
combinations() |
itertools |
生成所有可能的组合（不考虑顺序）。 | for combination in combinations(letters, 2): ... |
permutations() |
itertools |
生成所有可能的排列（考虑顺序）。 | for permutation in permutations(letters, 2): ... |
combinations_with_replacement() |
itertools |
生成所有可能的组合，允许元素重复。 | for combination in combinations_with_replacement(letters, 2): ... |
accumulate() |
itertools |
生成一个包含累积结果的迭代器。 | for accumulated_sum in accumulate(numbers): ... |
chain() |
itertools |
将多个可迭代对象连接成一个迭代器。 | for number in chain(list1, list2, list3): ... |
compress() |
itertools |
使用布尔值选择器过滤数据。 | for item in compress(data, selectors): ... |
groupby() |
itertools |
将相邻的具有相同键值的元素分组。 | for key, group in groupby(data, lambda x: x[0]): ... |
islice() |
itertools |
从一个可迭代对象中切片，返回一个迭代器。 | for number in islice(numbers, 2, 7, 2): ... |
tee() |
itertools |
从一个可迭代对象创建多个独立的迭代器。 | iterator1, iterator2 = tee(numbers, 2) |
zip_longest() |
itertools |
并行地从多个可迭代对象中获取元素，直到所有可迭代对象都耗尽，用 fillvalue 填充缺失值。 |
for number, letter in zip_longest(list1, list2, fillvalue="None"): ... |
四、函数式编程的优势与注意事项
函数式编程具有以下优势：
- 代码简洁: 函数式编程通常可以使用更少的代码来实现相同的功能。
- 可读性强: 函数式编程可以使代码更易于理解和维护，因为它避免了副作用和状态变化。
- 易于测试: 函数式编程的函数是纯函数，易于测试，因为它们的输出只依赖于输入。
- 并发性好: 函数式编程的代码更容易并行化，因为它们避免了共享状态。
在使用函数式编程时，需要注意以下几点：
- 避免副作用: 函数式编程强调纯函数，即没有副作用的函数。
- 不可变数据: 函数式编程通常使用不可变数据，这意味着数据一旦创建就不能被修改。
- 递归: 函数式编程经常使用递归来实现循环。
- 学习曲线: 函数式编程可能需要一些时间来学习和适应。
五、利用函数式工具构建高效代码
functools 和 itertools 模块为 Python 开发者提供了强大的函数式编程工具。 functools 帮助我们创建更灵活、更高效的函数，而 itertools 则提供了处理迭代器的各种方法，特别适合处理大数据集和无限序列。 熟练掌握这些工具，可以编写出更简洁、更可读、更易于维护的代码，并提高程序的性能。
希望今天的分享对大家有所帮助。 函数式编程是一个强大的工具，值得我们深入学习和实践。 掌握了这些工具，可以写出更优雅，更高效的Python代码。