Functional Programming (函数式编程)

以下是一份「Python 函数式编程知识体系：map / filter / reduce / lambda / 生成器 / 迭代器」全套整理。

结构清晰、应用场景明确、每节都有示例，可直接作为文档或你今后项目中的工具知识库。

☘️ Python 函数式编程知识体系（完整版）

核心理念：什么是函数式编程
lambda 表达式
map 函数
filter 函数
reduce 函数
生成器（generator）
迭代器（iterator）
惰性执行（lazy evaluation）
三者组合实战
Python 函数式编程最佳实践

1️⃣ 核心理念：什么是函数式编程？

函数式编程（Functional Programming, FP）强调：

无副作用
函数是“一等公民”
链式处理数据
可组合、可复用
偏向使用不可变对象

核心思想：

👉 用函数处理数据，而不是写 for 循环。

体现：map / filter / reduce、迭代器、生成器、lambda。

2️⃣ lambda 表达式（匿名函数）

语法

lambda 参数: 表达式

例子：

add = lambda a, b: a + b
print(add(3, 5))   # 8

常用于 map / filter / reduce / sorted。

3️⃣ map —— 映射（对每个元素做变换）

语法

map(function, iterable)

功能：对 iterable 每个元素应用函数，返回一个惰性 map 对象。

示例：

nums = [1, 2, 3]
result = list(map(lambda x: x * 2, nums))
print(result)  # [2, 4, 6]

等价写法：

[x * 2 for x in nums]

4️⃣ filter —— 过滤（保留符合条件的元素）

语法

filter(function, iterable)

示例：

nums = [1, 2, 3, 4, 5]
result = list(filter(lambda x: x % 2 == 0, nums))
print(result)  # [2, 4]

等价写法

[x for x in nums if x % 2 == 0]

5️⃣ reduce —— 折叠（把序列归约为一个值）

来自 functools：

from functools import reduce

语法

reduce(function, iterable, initializer)

示例：累加

reduce(lambda a, b: a + b, [1, 2, 3, 4])

过程等价为：

(((1 + 2) + 3) + 4)

初始化值 initializer

reduce(lambda a, b: a + b, [1, 2, 3], 10)

6️⃣ 生成器（generator） —— 用 yield 动态生成数据（惰性）

特点：

每次只生成一个数据
内存占用极小
可无限序列
很适合数据流处理

示例

def gen_nums(n):
    for i in range(n):
        yield i

g = gen_nums(5)
print(next(g))
print(next(g))

7️⃣ 迭代器（iterator） —— 支持 next() 的对象

判断是否迭代器

from collections.abc import Iterator
isinstance(obj, Iterator)

自定义迭代器

class Counter:
    def __init__(self, n):
        self.i = 0
        self.n = n

    def __iter__(self):
        return self

    def __next__(self):
        if self.i < self.n:
            self.i += 1
            return self.i
        raise StopIteration

c = Counter(3)
for x in c:
    print(x)

8️⃣ 惰性执行（Lazy Evaluation）

以下对象都是“惰性的”：

类型	是否惰性
generator	✅️
map	✅️
filter	✅️
zip	✅️
iter(range)	✅️
file 对象	✅️
itertools 链接类	✅️

惰性意味着：

👉 不会一次性生成数据，只在需要时生成

效率高、内存占用小。

9️⃣ map / filter / reduce / generator / iterator 组合实战

示例 1：处理股票数据

from functools import reduce

stocks = [
    {"code": "600001", "price": 12},
    {"code": "600002", "price": 8},
    {"code": "600003", "price": 15},
]

# (1) 提取价格
prices = map(lambda s: s["price"], stocks)

# (2) 过滤 > 10 的价格
high_prices = filter(lambda p: p > 10, prices)

# (3) 求和
total = reduce(lambda a, b: a + b, high_prices, 0)

print(total)  # 27

链式函数式写法，比 for 循环更优雅。

示例 2：生成器处理大规模日志

def read_lines(path):
    with open(path) as f:
        for line in f:
            yield line.strip()

# 惰性过滤
errors = (line for line in read_lines("app.log") if "ERROR" in line)

for e in errors:
    print(e)

适合大型日志处理，不会占大量内存。

示例 3：迭代器 + map 实现无限序列

def infinite(start=0):
    while True:
        yield start
        start += 1

# 取无限序列的平方
squared = map(lambda x: x * x, infinite())

for i in range(5):
    print(next(squared))

🔟 Python 函数式编程最佳实践（非常重要）

推荐使用：

map/filter（仅当简单规则时）
reduce（用于累积/归约）
生成器（用于数据流）
链式组合

生成器优先于列表（节省内存）

所有大规模数据处理都尽量用生成器

可读性优先，如果逻辑复杂不要硬用 map/filter

复杂逻辑用 for，简单逻辑用 map/filter

避免 lambda 里写复杂语句（影响可读性）

📘 整体记忆公式（超简版）

map：对每个元素做变换
filter：过滤元素
reduce：把所有元素折叠成一个值
lambda：简短函数表达式
生成器：yield，一次一个，惰性
迭代器：支持 next() 的对象