Python 函数式编程：从思想到实践函数式编程（Functional Programming，FP）是一种把"计算"看

函数式编程（Functional Programming，FP）是一种把"计算"看作数学函数求值的编程范式——它不像面向对象那样关注"对象状态"，而是强调用函数来描述数据的变换过程。Python 并非纯函数式语言，但它对这套思想的支持相当完善，掌握它能让你的代码更简洁、更易测试、更少 bug。下面我们一层一层把这件事讲清楚。

🧭 核心思想：函数式编程在想什么？

函数式编程的哲学核心只有一句话：数据流过一系列纯函数，产生结果，过程中不改变任何外部状态。 这和流水线工厂很像——每道工序只做一件事，不污染上下游。

🔬 核心概念详解

1. 纯函数（Pure Function）

纯函数有两个铁律：相同输入永远返回相同输出，以及不产生任何副作用（不修改全局变量、不写文件、不打印）。

# ❌ 非纯函数：依赖外部状态
total = 0
def add_to_total(x):
    global total
    total += x  # 修改了外部变量，有副作用
    return total

# ✅ 纯函数：只依赖输入，不改变外界
def add(x, y):
    return x + y  # 给定 x=1, y=2，永远返回 3

纯函数的好处是极易测试——你不需要准备任何环境，直接喂输入看输出就行。

2. 不可变数据（Immutability）

函数式编程倾向于不修改原始数据，而是返回新的数据结构。

# ❌ 命令式风格：直接修改列表
def double_items_imperative(lst):
    for i in range(len(lst)):
        lst[i] *= 2  # 原地修改，危险！
    return lst

# ✅ 函数式风格：返回新列表，原列表不变
def double_items_functional(lst):
    return [x * 2 for x in lst]

original = [1, 2, 3]
result = double_items_functional(original)
print(original)  # [1, 2, 3]  ← 原数据安然无恙
print(result)    # [2, 4, 6]

3. Lambda 匿名函数

Lambda 是一种一行写完的轻量函数，适合在需要临时传递简单逻辑的场合。

# 普通函数
def square(x):
    return x ** 2

# 等价的 lambda
square = lambda x: x ** 2

# 多参数 lambda
multiply = lambda x, y: x * y
print(multiply(3, 4))  # 12

# 常见用法：作为排序 key
students = [("Alice", 85), ("Bob", 92), ("Charlie", 78)]
sorted_students = sorted(students, key=lambda s: s[1], reverse=True)
print(sorted_students)
# [('Bob', 92), ('Alice', 85), ('Charlie', 78)]

4. 高阶函数：`map`、`filter`、`reduce`

这三个是函数式编程的"三板斧"，思路是把操作逻辑和数据分离。

from functools import reduce

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# map：对每个元素做变换，返回新序列
squares = list(map(lambda x: x ** 2, numbers))
print(squares)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# filter：筛选满足条件的元素
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4, 6, 8, 10]

# reduce：将序列"折叠"成单个值（累积计算）
total = reduce(lambda acc, x: acc + x, numbers)
print(total)  # 55（即 1+2+...+10）

# 组合使用：先筛选偶数，再求平方，再求和
result = reduce(
    lambda acc, x: acc + x,
    map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, numbers))
)
print(result)  # 220（即 4+16+36+64+100）

5. 高阶函数与闭包（Closure）

高阶函数可以接收函数作为参数，也可以返回函数。闭包是高阶函数的一种特殊形式——内层函数"记住"了外层函数的变量。

# 高阶函数：接收函数作为参数
def apply_twice(func, value):
    return func(func(value))

print(apply_twice(lambda x: x + 3, 10))  # 16（10+3=13，13+3=16）

# 闭包：工厂函数，返回一个"记住"了 n 的函数
def make_multiplier(n):
    def multiplier(x):
        return x * n  # 这里的 n 被"捕获"了
    return multiplier

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))   # 10
print(triple(5))   # 15
print(double(triple(4)))  # 24（先×3得12，再×2得24）

6. 装饰器（Decorator）

装饰器本质上是包裹函数的高阶函数，用来在不修改原函数的前提下增加功能。这是函数式思想在 Python 中最优雅的体现之一。

import time

# 定义一个计时装饰器
def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)         # 调用原函数
        end = time.time()
        print(f"{func.__name__} 耗时 {end - start:.4f} 秒")
        return result
    return wrapper

# 用 @ 语法糖应用装饰器
@timer
def slow_sum(n):
    return sum(range(n))

slow_sum(10_000_000)
# slow_sum 耗时 0.3241 秒

7. `functools` 与 `itertools`：函数式工具箱

Python 标准库为函数式编程提供了两个强力模块。

from functools import partial, lru_cache
from itertools import chain, takewhile, islice

# --- functools.partial：固定部分参数，生成新函数 ---
def power(base, exp):
    return base ** exp

square = partial(power, exp=2)
cube   = partial(power, exp=3)

print(square(5))  # 25
print(cube(3))    # 27

# --- functools.lru_cache：缓存纯函数结果（记忆化） ---
@lru_cache(maxsize=None)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(50))  # 12586269025，瞬间完成（无缓存会极慢）

# --- itertools：惰性处理大数据 ---
# chain：拼接多个可迭代对象
combined = list(chain([1, 2, 3], [4, 5], [6]))
print(combined)  # [1, 2, 3, 4, 5, 6]

# takewhile：取满足条件的前缀元素
data = [2, 4, 6, 7, 8, 10]
result = list(takewhile(lambda x: x % 2 == 0, data))
print(result)  # [2, 4, 6]（遇到 7 就停了）

# islice：惰性切片，适合超大数据流
def infinite_counter(start=0):
    while True:
        yield start
        start += 1

first_10 = list(islice(infinite_counter(), 10))
print(first_10)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

8. 函数组合（Function Composition）

把多个小函数串联成一条流水线，是函数式编程最迷人的地方。

from functools import reduce

# 手写 compose：从右到左依次应用函数
def compose(*funcs):
    return reduce(lambda f, g: lambda x: f(g(x)), funcs)

# 定义几个小函数
strip_spaces = lambda s: s.strip()
to_upper     = lambda s: s.upper()
add_exclaim  = lambda s: s + "!!!"

# 组合成流水线
shout = compose(add_exclaim, to_upper, strip_spaces)
print(shout("  hello world  "))  # HELLO WORLD!!!

📊 核心概念速查表

概念	一句话解释	Python 实现方式
纯函数	无副作用，输入决定输出	普通 `def`，避免全局变量
不可变数据	不修改原数据，返回新数据	`tuple`、列表推导式
Lambda	一行匿名函数	`lambda x: x+1`
map / filter	变换 / 筛选序列	内置函数
reduce	将序列折叠为单值	`functools.reduce`
闭包	函数记住外部变量	嵌套函数
装饰器	包裹函数增强功能	`@decorator` 语法
partial	固定部分参数	`functools.partial`
记忆化	缓存纯函数结果	`functools.lru_cache`
惰性求值	按需计算，节省内存	`itertools`、生成器

💡 写在最后

函数式编程不是要你抛弃 Python 的其他特性，而是给你多一把刀。纯函数让代码可预测，不可变数据减少 bug，高阶函数让逻辑复用变得优雅。 实际项目里，最好的做法是混合使用——用面向对象管理复杂状态，用函数式处理数据变换流程。MIT 的课程材料把 map/filter/reduce 称为"序列操作的三驾马车"，而 Python 官方文档也专门为此写了一份 Functional Programming HOWTO，值得深读。

从今天起，每次写 for 循环处理列表时，不妨停一秒问自己：这里能不能用一个 map 或列表推导式替代？答案往往是肯定的。

参考来源：

MIT 6.005 课程 & Python 官方 Functional Programming HOWTO — docs.python.org/3/howto/fun…
Medium — Lambda, Map, Filter & Reduce in Python
Reddit r/Python — Functional programming concepts that actually work in Python
adabeat.com — Functional Programming in Python

Python 函数式编程：从思想到实践