Python函数式编程技巧

Python函数式编程技巧

一、函数式编程的核心概念

函数式编程强调使用纯函数、不可变数据和函数组合来构建程序。

1.1 纯函数

纯函数是指相同输入总是产生相同输出，且没有副作用的函数。

# 纯函数
def add(a, b):
return a + b

# 非纯函数（有副作用）
counter = 0
def increment():
global counter
counter += 1
return counter

二、高阶函数

高阶函数是接受函数作为参数或返回函数的函数。

2.1 map()函数

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared) # [1, 4, 9, 16, 25]

# 使用自定义函数
def double(x):
return x * 2

doubled = list(map(double, numbers))
print(doubled) # [2, 4, 6, 8, 10]

2.2 filter()函数

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens) # [2, 4, 6, 8, 10]

2.3 reduce()函数

from functools import reduce

numbers = [1, 2, 3, 4, 5]
sum_all = reduce(lambda x, y: x + y, numbers)
print(sum_all) # 15

# 计算阶乘
factorial = reduce(lambda x, y: x * y, range(1, 6))
print(factorial) # 120

三、lambda表达式

lambda表达式用于创建匿名函数。

# 基本语法
square = lambda x: x**2
print(square(5)) # 25

# 多个参数
add = lambda x, y: x + y
print(add(3, 4)) # 7

# 在排序中使用
students = [
{'name': 'Alice', 'age': 25},
{'name': 'Bob', 'age': 20},
{'name': 'Charlie', 'age': 23}
]
sorted_students = sorted(students, key=lambda s: s['age'])

四、函数组合

函数组合是将多个函数组合成一个新函数。

def compose(*functions):
"""组合多个函数"""
def inner(arg):
result = arg
for func in reversed(functions):
result = func(result)
return result
return inner

# 使用示例
def add_one(x):
return x + 1

def double(x):
return x * 2

def square(x):
return x ** 2

# 组合函数：先加1，再翻倍，最后平方
combined = compose(square, double, add_one)
print(combined(3)) # ((3 + 1) * 2) ** 2 = 64

五、偏函数

偏函数用于固定函数的部分参数。

from functools import partial

def power(base, exponent):
return base ** exponent

# 创建平方函数
square = partial(power, exponent=2)
print(square(5)) # 25

# 创建立方函数
cube = partial(power, exponent=3)
print(cube(5)) # 125

六、闭包

闭包是指函数可以访问其外部作用域的变量。

def make_multiplier(factor):
"""创建乘法器"""
def multiplier(x):
return x * factor
return multiplier

times_two = make_multiplier(2)
times_three = make_multiplier(3)

print(times_two(5)) # 10
print(times_three(5)) # 15

七、柯里化

柯里化是将多参数函数转换为一系列单参数函数。

def curry(func):
"""柯里化装饰器"""
def curried(*args, **kwargs):
if len(args) + len(kwargs) >= func.__code__.co_argcount:
return func(*args, **kwargs)
return lambda *more_args, **more_kwargs: curried(
*(args + more_args), **{**kwargs, **more_kwargs}
)
return curried

@curry
def add_three(a, b, c):
return a + b + c

# 可以分步调用
print(add_three(1)(2)(3)) # 6
print(add_three(1, 2)(3)) # 6
print(add_three(1)(2, 3)) # 6

八、不可变数据结构

函数式编程倾向于使用不可变数据。

# 使用元组代替列表
immutable_data = (1, 2, 3, 4, 5)

# 使用frozenset代替set
immutable_set = frozenset([1, 2, 3, 4, 5])

# 使用namedtuple创建不可变对象
from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
# p.x = 3 # 会抛出AttributeError

九、递归

递归是函数式编程的重要技术。

9.1 基本递归

def factorial(n):
if n <= 1:
return 1
return n * factorial(n - 1)

print(factorial(5)) # 120

9.2 尾递归优化

# Python不支持尾递归优化，但可以手动实现
def factorial_tail(n, accumulator=1):
if n <= 1:
return accumulator
return factorial_tail(n - 1, n * accumulator)

print(factorial_tail(5)) # 120

十、实战案例：数据处理管道

from functools import reduce

# 原始数据
data = [
{'name': 'Alice', 'age': 25, 'score': 85},
{'name': 'Bob', 'age': 30, 'score': 92},
{'name': 'Charlie', 'age': 22, 'score': 78},
{'name': 'David', 'age': 28, 'score': 95}
]

# 函数式处理管道
result = reduce(
lambda acc, x: acc + x['score'],
filter(
lambda x: x['age'] >= 25,
map(
lambda x: {**x, 'score': x['score'] * 1.1},
data
)
),
0
)

print(f"总分: {result:.2f}")

十一、实战案例：函数式错误处理

from typing import Union, Callable, TypeVar

T = TypeVar('T')
E = TypeVar('E')

class Result:
"""函数式错误处理"""
def __init__(self, value=None, error=None):
self.value = value
self.error = error

def is_ok(self):
return self.error is None

def map(self, func):
if self.is_ok():
try:
return Result(value=func(self.value))
except Exception as e:
return Result(error=str(e))
return self

def flat_map(self, func):
if self.is_ok():
return func(self.value)
return self

def or_else(self, default):
return self.value if self.is_ok() else default

# 使用示例
def divide(a, b):
if b == 0:
return Result(error="除数不能为0")
return Result(value=a / b)

result = (divide(10, 2)
.map(lambda x: x * 2)
.map(lambda x: x + 5))

print(result.or_else(0)) # 15.0

十二、实战案例：惰性求值

class LazyList:
"""惰性列表"""
def __init__(self, iterable):
self.iterable = iter(iterable)

def map(self, func):
return LazyList(func(x) for x in self.iterable)

def filter(self, predicate):
return LazyList(x for x in self.iterable if predicate(x))

def take(self, n):
result = []
for _ in range(n):
try:
result.append(next(self.iterable))
except StopIteration:
break
return result

# 使用示例
lazy = (LazyList(range(1000000))
.map(lambda x: x * 2)
.filter(lambda x: x % 3 == 0)
.take(10))

print(lazy)

十三、itertools模块

itertools提供了许多函数式编程工具。

from itertools import *

# accumulate: 累积计算
print(list(accumulate([1, 2, 3, 4, 5]))) # [1, 3, 6, 10, 15]

# takewhile: 条件为真时取值
print(list(takewhile(lambda x: x < 5, [1, 2, 3, 4, 5, 6, 1, 2]))) # [1, 2, 3, 4]

# dropwhile: 条件为真时跳过
print(list(dropwhile(lambda x: x < 5, [1, 2, 3, 4, 5, 6, 1, 2]))) # [5, 6, 1, 2]

# groupby: 分组
from itertools import groupby
data = [('A', 1), ('A', 2), ('B', 3), ('B', 4)]
for key, group in groupby(data, key=lambda x: x[0]):
print(f"{key}: {list(group)}")

十四、operator模块

operator模块提供了函数形式的运算符。

from operator import add, mul, itemgetter, attrgetter

# 使用add代替lambda x, y: x + y
from functools import reduce
numbers = [1, 2, 3, 4, 5]
total = reduce(add, numbers)
print(total) # 15

# itemgetter用于排序
students = [
{'name': 'Alice', 'age': 25},
{'name': 'Bob', 'age': 20}
]
sorted_students = sorted(students, key=itemgetter('age'))

十五、函数式编程的优势

1. 代码更简洁、可读性更强
2. 易于测试和调试（纯函数）
3. 易于并行化
4. 减少副作用和状态管理
5. 更容易推理代码行为

十六、函数式编程的局限

1. Python不是纯函数式语言
2. 递归深度有限制
3. 性能可能不如命令式代码
4. 学习曲线较陡
5. 过度使用可能降低可读性

十七、最佳实践

1. 优先使用纯函数
2. 避免修改输入参数
3. 使用不可变数据结构
4. 合理使用高阶函数
5. 不要过度使用lambda表达式
6. 结合命令式和函数式编程

十八、总结

函数式编程为Python提供了另一种编程范式。通过使用高阶函数、纯函数、不可变数据等技术，我们可以编写更简洁、更易维护的代码。虽然Python不是纯函数式语言，但合理运用函数式编程技巧可以显著提升代码质量。