Python函数式编程——纯函数

一、什么是纯函数？

纯函数是函数式编程中的核心概念。一个函数被称为"纯函数"，必须满足两个条件：

1. 1. 相同输入始终产生相同输出（确定性）
2. 2. 没有副作用（不修改外部状态）

# 纯函数示例
defadd(a, b):
return a + b

print(add(2, 3))  # 5
print(add(2, 3))  # 5（相同输入，相同输出）

# 非纯函数示例
total = 0
defadd_to_total(x):
global total
    total += x      # 修改了外部变量（副作用）
return total

二、纯函数的两大特征详解

2.1 确定性（相同输入，相同输出）

纯函数的输出完全由输入参数决定，不受任何外部状态影响。

# ✅ 纯函数
defcircle_area(radius):
return3.14159 * radius * radius

# ❌ 非纯函数（依赖外部变量）
PI = 3.14159
defcircle_area(radius):
return PI * radius * radius  # 依赖外部变量

# ❌ 非纯函数（依赖随机数）
import random
defroll_dice():
return random.randint(1, 6)  # 每次调用结果不同

2.2 无副作用

纯函数不会：

• • 修改外部变量（全局变量、闭包中的变量）
• • 修改传入的可变对象（列表、字典等）
• • 执行 I/O 操作（打印、读写文件、网络请求）
• • 抛出异常（可选，但会破坏纯度）

# ❌ 有副作用的函数
counter = 0
defincrement():
global counter
    counter += 1# 修改全局变量
return counter

# ❌ 修改传入的可变对象
defadd_to_list(lst, item):
    lst.append(item)  # 修改了传入的列表
return lst

# ❌ 有 I/O 操作
deflog_message(msg):
print(msg)        # 控制台输出
returnlen(msg)

三、为什么不使用纯函数？

3.1 可测试性

纯函数非常容易测试，因为不需要设置复杂的外部状态。

# ✅ 纯函数：测试简单
defadd(a, b):
return a + b

# 测试只需检查输入输出
assert add(2, 3) == 5
assert add(-1, 1) == 0

# ❌ 非纯函数：测试困难
balance = 100
defwithdraw(amount):
global balance
if amount <= balance:
        balance -= amount
returnTrue
returnFalse
# 测试前需要重置 balance 状态

3.2 可缓存性（记忆化）

纯函数的结果可以被缓存，提高性能。

from functools import lru_cache

# 纯函数可以使用 lru_cache
@lru_cache(maxsize=128)
deffibonacci(n):
if n < 2:
return n
return fibonacci(n-1) + fibonacci(n-2)

# 非纯函数不能使用 lru_cache
counter = 0
defimpure_fib(n):
global counter
    counter += 1# 副作用，缓存会导致错误
if n < 2:
return n
return impure_fib(n-1) + impure_fib(n-2)

3.3 可并行性

纯函数不会共享状态，可以安全地并发执行。

# 纯函数可以安全地并行执行
defpure_work(x):
return x * x

# 并行处理
from concurrent.futures import ThreadPoolExecutor
with ThreadPoolExecutor() as executor:
    results = list(executor.map(pure_work, range(1000)))

3.4 可推理性和可维护性

纯函数的代码更容易理解和调试，因为不需要追踪外部状态变化。

# 纯函数：一目了然
defcalculate_total(price, quantity, tax_rate):
    subtotal = price * quantity
    tax = subtotal * tax_rate
return subtotal + tax

# 非纯函数：需要理解外部状态
tax_rate = 0.1
defcalculate_total(price, quantity):
global tax_rate
    subtotal = price * quantity
# 谁能想到 tax_rate 可能被其他地方修改？
return subtotal + subtotal * tax_rate

三、如何处理副作用

在实际项目中，完全避免副作用是不可能的（程序最终需要 I/O）。函数式编程的建议是：将副作用隔离到程序的边界，核心逻辑保持纯函数。

3.1 分离纯逻辑和非纯操作

import json

# ❌ 不好的设计：纯逻辑和 I/O 混在一起
defprocess_file(filename):
withopen(filename, 'r') as f:
        data = json.load(f)

# 业务逻辑
    result = {}
for item in data['items']:
        result[item['id']] = item['price'] * 1.1

withopen('output.json', 'w') as f:
        json.dump(result, f)

# ✅ 好的设计：分离纯逻辑
defprocess_items(items):
"""纯函数：处理数据逻辑"""
    result = {}
for item in items:
        result[item['id']] = item['price'] * 1.1
return result

defmain():
# I/O 在边界处理
withopen('input.json', 'r') as f:
        data = json.load(f)

# 调用纯函数
    result = process_items(data['items'])

# I/O 在边界处理
withopen('output.json', 'w') as f:
        json.dump(result, f)

3.2 使用不可变数据

# ❌ 修改传入的数据
defadd_discount(prices, discount):
for i inrange(len(prices)):
        prices[i] = prices[i] * (1 - discount)  # 修改原列表
return prices

# ✅ 返回新数据
defadd_discount(prices, discount):
return [p * (1 - discount) for p in prices]  # 返回新列表

prices = [100, 200, 300]
discounted = add_discount(prices, 0.1)
print(prices)      # [100, 200, 300]（原列表不变）
print(discounted)  # [90.0, 180.0, 270.0]

四、纯函数的实际应用

4.1 数据转换管道

# 一组纯函数
deffilter_positive(numbers):
return [n for n in numbers if n > 0]

defsquare(numbers):
return [n ** 2for n in numbers]

defsum_numbers(numbers):
returnsum(numbers)

# 组合成处理管道
numbers = [-3, 1, 2, -5, 3, 4]
result = sum_numbers(square(filter_positive(numbers)))
print(result)  # 1^2 + 2^2 + 3^2 + 4^2 = 30

4.2 购物车计算

# 纯函数计算购物车
defcalculate_subtotal(items):
"""计算小计"""
returnsum(item['price'] * item['quantity'] for item in items)

defapply_discount(amount, discount_rate):
"""应用折扣"""
return amount * (1 - discount_rate)

defapply_tax(amount, tax_rate):
"""应用税费"""
return amount * (1 + tax_rate)

defcalculate_total(items, discount_rate=0, tax_rate=0.1):
"""组合纯函数计算总价"""
    subtotal = calculate_subtotal(items)
    after_discount = apply_discount(subtotal, discount_rate)
    total = apply_tax(after_discount, tax_rate)
returnround(total, 2)

# 使用
cart = [
    {'name': '苹果', 'price': 8.5, 'quantity': 3},
    {'name': '香蕉', 'price': 5.0, 'quantity': 2},
]
total = calculate_total(cart, discount_rate=0.1)
print(f"总价: {total}")

五、高阶函数与纯函数

函数式编程中，map、filter、reduce 等高阶函数通常与纯函数配合使用。

from functools import reduce

# 纯函数：应用于每个元素
defdouble(x):
return x * 2

defis_even(x):
return x % 2 == 0

defadd(x, y):
return x + y

numbers = [1, 2, 3, 4, 5, 6]

# 函数式管道（纯函数组合）
result = reduce(
    add,
map(double, filter(is_even, numbers))
)
print(result)  # 2+4+6 = 12, double后 4+8+12 = 24

六、总结

核心要点：

• • 纯函数是函数式编程的基石，具有确定性、无副作用的特点。
• • 纯函数更容易测试、缓存、并行和推理。
• • 实际项目中，应将纯逻辑与副作用分离，核心业务逻辑保持纯函数。
• • 不追求"完全纯函数"，而是在合适的场景使用纯函数。

掌握纯函数的概念和实践，可以让你的代码更可靠、更易维护，是函数式编程的核心思想之一。