Python 函数式特性深度解析：从迭代器协议到惰性计算管道

题眼: 生成器不只是语法糖，它是 Python 的惰性计算原语。
本文适合有 Java 背景、正在学习 Python 的开发者。用熟悉的术语类比，从迭代器协议到底层机制，从生成器到 itertools/functools，系统性介绍 Python 的函数式特性。核心洞察：Java Stream 是管道的末端操作触发计算，Python 生成器是 pull 一个算一个。

第 1 章：第一印象 --- 两段管道代码

看两段等价代码------从一个日志文件中提取所有 ERROR 行，取前 10 条，转成大写。

// Java Stream: 声明式管道，末端触发
List<String> errors = Files.lines(Path.of("app.log"))
    .filter(line -> line.contains("ERROR"))
    .limit(10)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

# Python 生成器管道：pull 一个算一个
with open("app.log") as f:
    errors = (line.upper() for line in f
              if "ERROR" in line)
    top10 = list(itertools.islice(errors, 10))

表面相似------都在构建"数据管道"。但底层机制根本不同：

Java Stream 管道:
  数据源 ──▶ filter ──▶ limit ──▶ map ──▶ collect()
                                        ↑
                                   末端操作触发整条管道一次性执行
                                   (push 模式：数据被"推"过管道)

Python 生成器管道:
  数据源 ──▶ 生成器表达式 ──▶ islice ──▶ list()
        ↑                              ↑
   每次 pull 一个元素              每次 pull 触发上游产出一个
   (pull 模式：消费者驱动，一次只算一个)

这不是"语法差异"，是计算模型的差异。Java Stream 是"准备好所有数据，一次性推过管道"；Python 生成器是"有人要，我才算，算完这次忘了上次"。

后面你会看到，这种 pull 模式渗透到了 Python 函数式特性的每一个角落------从 for 循环到迭代器协议，从生成器到 itertools，都是同一个原语的层层封装。

第 2 章：迭代器协议 --- 惰性计算的"接口层"

2.1 Python 的 for 循环到底在干什么

在 Java 中，for (T item : collection) 是语法糖，编译后等价于用 Iterator 遍历：

for (Iterator<T> it = collection.iterator(); it.hasNext(); ) {
    T item = it.next();
    // 循环体
}

Python 的 for item in obj: 也是语法糖，但依赖的协议不同：

# Python 的 for 循环等价于：
it = iter(obj)        # 调用 obj.__iter__()
while True:
    try:
        item = next(it)   # 调用 it.__next__()
    except StopIteration:
        break
    # 循环体

核心区别：

Java Iterator:                      Python Iterator Protocol:
┌──────────────────────┐            ┌──────────────────────┐
│ hasNext() → boolean  │            │ __iter__() → self    │
│ next()    → T        │            │ __next__() → T       │
│ remove()  → void     │            │ (StopIteration 终止) │
└──────────────────────┘            └──────────────────────┘
   二合一接口                             一协议
   主动询问"还有吗"                      直接取，取不到就抛异常

Java 翻译 : Java 的 hasNext() 是"先问再取"模式------你必须先调用 hasNext() 确认有下一个元素，才能安全调用 next()。Python 的 __next__() 是"直接取，取不到就甩异常"------这正是 EAFP 哲学的体现。关于 StopIteration 为什么被选为迭代终止信号（PEP 234 对比了三种被拒绝的替代方案：哨兵值、end() 函数、IndexError 复用），详见《Python 异常模型深度解析》第 3 章，这里不展开------我们关心的是它如何支撑惰性计算管道。

2.2 可迭代对象 vs 迭代器

这是 Python 函数式特性的第一个关键区分：

# 可迭代对象 (Iterable)：有 __iter__()，每次返回一个"新鲜的"迭代器
lst = [1, 2, 3]
it1 = iter(lst)  # 返回一个新的 list_iterator
it2 = iter(lst)  # 返回另一个新的 list_iterator
# it1 和 it2 独立遍历，互不影响

# 迭代器 (Iterator)：有 __iter__() 和 __next__()，__iter__() 返回自身
it = iter(lst)
it is iter(it)   # True ------ 迭代器的 __iter__() 返回自己

可迭代对象 ──iter()──▶ 迭代器 ──next()──▶ 元素
   (容器)               (游标)           (产出)
     │                    │
     │  __iter__()        │  __iter__() → self
     │  返回新迭代器       │  __next__()  → 下一个元素
     │                    │
  每次 iter() 创建       只能遍历一次
  新的游标              走完就耗尽

Java 翻译 : Java 中 Iterable<T> 和 Iterator<T> 是两个独立接口，对应关系完全一样------Iterable.iterator() 每次创建新的 Iterator。区别在于 Python 用协议（duck typing）而非接口声明：任何实现了 __iter__() 的对象都可以出现在 for 循环中，不需要 implements Iterable。

2.3 自己实现一个迭代器

class Countdown:
    """倒计时迭代器------每次 next() 返回下一个数字"""
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        return self   # 迭代器返回自身

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        self.current -= 1
        return self.current

# 使用
for n in Countdown(3):
    print(n)  # 2, 1, 0

这个实现暴露了手动迭代器的核心痛点：你必须手动维护 self.current 状态变量。更复杂的迭代逻辑（如二叉树遍历、文件解析）需要显式状态机------这正是生成器要解决的问题。

第 3 章：生成器函数 --- yield 将函数变为迭代器工厂

3.1 同样的倒计时，用生成器

def countdown(start):
    while start > 0:
        start -= 1
        yield start

没有 self.current，没有 __next__，没有 StopIteration，没有 __iter__。yield 做了所有事：

def countdown(start):         # 普通函数定义
    while start > 0:
        start -= 1
        yield start           # ← 一个 yield 改变了一切

调用 countdown(3):
  ┌─ 不立即执行函数体
  │  返回一个 generator object
  │  这个 generator object 实现了 __iter__() 和 __next__()
  │
  ├─ 第一次 next(g):
  │    执行到 yield start  → 产出值 2 → 暂停，保存所有局部变量
  │
  ├─ 第二次 next(g):
  │    从上次暂停处恢复 → 继续 while → yield → 产出值 1 → 暂停
  │
  └─ 第三次 next(g):
       从暂停处恢复 → while 结束 → 函数返回 → 自动 raise StopIteration

PEP 255（2001 年提出）这样描述生成器的核心动机：

"Generators are a simple and powerful tool for creating iterators. They are written like regular functions but use the yield statement whenever they want to return data. Each time they are resumed, they pick up where they left off."

3.2 帧保存：为什么生成器能"暂停"

CPython 中，每个生成器对象内部持有一个 gi_frame（PyFrameObject 指针）。帧（frame）包含了函数执行所需的全部上下文：局部变量、指令指针（f_lasti，记录执行到哪条字节码）、值栈（value stack）。

普通函数调用:
  PyEval_EvalFrameEx() 执行帧
  → 函数 return → 帧被回收

生成器函数调用:
  PyEval_EvalFrameEx() 执行帧
  → 遇到 YIELD_VALUE 字节码 → 暂停，帧保存到 gi_frame
  → 下次 next() → 帧从 gi_frame 恢复到执行栈
  → 从 f_lasti 指向的 YIELD_VALUE 之后继续执行

这就是生成器和 Java Iterator 的根本差异：

// Java: 你必须手动管理状态
class CountdownIterator implements Iterator<Integer> {
    private int current;           // ← 状态是类的字段
    public boolean hasNext() { return current > 0; }
    public Integer next() {
        if (!hasNext()) throw new NoSuchElementException();
        return --current;
    }
}

# Python: yield 自动保存所有状态
def countdown(start):
    while start > 0:
        start -= 1
        yield start

Java 翻译 : Java 自定义 Iterator 需要把遍历状态写成类的实例字段------对于简单遍历这还好，但对于需要多层嵌套循环、条件分支的复杂遍历（比如二叉树中序遍历），状态机代码会迅速膨胀。Python 生成器把"自动保存帧"这个能力内建到了语言层面------你写普通循环逻辑，yield 帮你处理暂停和恢复。这有点像 Java 的 Thread.sleep() 能暂停线程------但生成器暂停的是函数帧，不涉及线程切换。

3.3 生成器作为"无穷序列"

因为生成器是惰性的（pull 一个算一个），它天然适合表达无穷序列：

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# 取前 10 个斐波那契数
from itertools import islice
list(islice(fibonacci(), 10))  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Java 中表达无穷序列需要 Stream.iterate()：

Stream.iterate(new int[]{0, 1}, f -> new int[]{f[1], f[0] + f[1]})
    .mapToInt(f -> f[0])
    .limit(10)
    .toArray();

两者都是惰性的，但 Python 的生成器函数可以直接用自然语言逻辑写（a, b = b, a + b），不需要把状态打包成数组再解包。

第 4 章：生成器表达式 --- 一行代码的惰性管道

4.1 语法：把推导式的方括号换成圆括号

# 列表推导式 (迫切求值)  ------ 立即生成整个列表
squares_list = [x**2 for x in range(10)]  # [0, 1, 4, 9, ...]

# 生成器表达式 (惰性求值) ------ 返回生成器对象
squares_gen  = (x**2 for x in range(10))  # <generator object>

PEP 289（2002 年）引入生成器表达式，核心理由是：很多时候你不需要整个列表驻留在内存中，你只需要逐个消费。

# 迫切求值: 先构建完整的 1000 万个元素的列表
total = sum([x**2 for x in range(10_000_000)])  # ~80MB 内存峰值

# 惰性求值: 逐个计算、逐个累加
total = sum(x**2 for x in range(10_000_000))     # 几乎零额外内存

注意：当生成器表达式作为唯一的函数参数时，可以省略外层括号：

sum(x**2 for x in range(10))           # 等价于 sum((x**2 for x in range(10)))
any(line.startswith("#") for line in f) # 等价于 any((...) for line in f)

4.2 嵌套生成器表达式 = 惰性管道

# 从日志文件中逐行读取，过滤，转换------全程惰性
with open("server.log") as f:
    # 去掉换行符
    lines = (line.rstrip() for line in f)
    # 只保留 ERROR 行
    errors = (line for line in lines if "ERROR" in line)
    # 提取时间戳
    timestamps = (line[:19] for line in errors)

    for ts in timestamps:
        print(ts)

管道中的每一步都是生成器------数据从文件中逐行拉取，流经三个生成器表达式，最终在 for 循环中被消费。整个过程中只有当前行驻留在内存中。

Java 翻译 : Java Stream 的 filter().map().limit() 链式调用也是惰性管道。区别在于触发方式：Java Stream 管道的每一步返回一个新的 Stream 对象，管道的执行由末端操作 （collect()、forEach()）一次性触发。Python 生成器管道的执行由消费者的每次 pull 驱动------每调用一次 next()，整个管道只为这一个元素运转一次。

Java Stream 管道执行:
  Source ──▶ op1 ──▶ op2 ──▶ terminal
  [元素1 流经全管道] → [元素2 流经全管道] → ...
  (由末端操作驱动，元素逐一通过整条管道)

Python 生成器管道执行:
  Source ──▶ gen1 ──▶ gen2 ──▶ consumer
  consumer.next() → gen2.next() → gen1.next() → Source.next()
  (由消费者 pull 驱动，每次调用逐层穿透)

第 5 章：推导式全景 --- 声明式数据构造

5.1 列表推导式：迫切求值的声明式语法

# 命令式写法
result = []
for x in range(10):
    if x % 2 == 0:
        result.append(x ** 2)

# 列表推导式 ------ 一行表达同样逻辑
result = [x**2 for x in range(10) if x % 2 == 0]

推导式可以嵌套，但可读性是约束------超过两层嵌套建议拆成普通循环：

# 两层嵌套：展平二维列表
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [x for row in matrix for x in row]  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 等价于：
flat = []
for row in matrix:
    for x in row:
        flat.append(x)

for 子句的顺序与普通循环相同------从左到右是外层到内层。

5.2 字典推导式与集合推导式

# 字典推导式：反转 key-value
d = {"a": 1, "b": 2, "c": 3}
reversed_d = {v: k for k, v in d.items()}  # {1: "a", 2: "b", 3: "c"}

# 集合推导式：获取所有单词的首字母
words = ["hello", "world", "hello", "python"]
initials = {w[0] for w in words}  # {"h", "w", "p"}

5.3 推导式 vs 生成器表达式：迫切 vs 惰性

	列表推导式	生成器表达式
语法	[expr for x in seq]	(expr for x in seq)
求值时机	立即构建整个列表	每次 next() 时才计算一个元素
内存占用	与结果集大小成正比	常量级（只保存当前元素）
可重复遍历	可以	不可以（一次性）
适用场景	需要多次访问结果，结果集不大	结果集很大，只需要遍历一次

Java 翻译 : Python 列表推导式 ≈ Stream.map().filter().collect(Collectors.toList())------末端操作触发急切求值。Python 生成器表达式 ≈ Stream.map().filter()（没有末端操作时）------只构建管道，不执行。但有一个关键区别：Java Stream 的中间操作返回的仍然是 Stream 对象，可以继续链式调用；Python 生成器表达式返回的是生成器对象，需要用 itertools 函数组合或嵌套生成器表达式来构建多步管道。

5.4 推导式中的变量作用域

Python 3 中，推导式有自己的局部作用域------推导式内的循环变量不会泄露到外部：

x = "outer"
result = [x for x in range(3)]  # 推导式内的 x 是局部变量
print(x)  # Python 3: "outer" (推导式不污染外部作用域)

这是 Python 3 的行为。Python 2 中列表推导式的循环变量会泄露到外部------这是从 Python 2 迁移到 3 时的一个常见坑。

第 6 章：itertools --- 惰性计算的瑞士军刀

itertools 是 Python 标准库中专门为迭代器设计的"组合子工具箱"。它的函数分为三类：无穷迭代器、有限迭代器、组合迭代器。

6.1 无穷迭代器

from itertools import count, cycle, repeat

# count(start, step): 从 start 开始无限 +step
count(10, 2)          # 10, 12, 14, 16, ...

# cycle(iterable): 无限循环一个可迭代对象
cycle("ABC")          # A, B, C, A, B, C, ...

# repeat(elem, n): 重复 elem n 次（n 省略则无限）
repeat("x", 3)        # x, x, x

典型用法：给数据打编号。

# 给列表元素编上序号
list(zip(count(1), ["a", "b", "c"]))  # [(1, "a"), (2, "b"), (3, "c")]

6.2 有限迭代器：管道的核心构建块

itertools 的管道组件：
┌──────────────┬──────────────────────────────────────┐
│ 函数          │ 作用                  │ Java Stream 等价 │
├──────────────┼──────────────────────────────────────┤
│ islice       │ 切片（惰性）           │ limit() + skip() │
│ takewhile    │ 条件为真时取           │ (无直接等价)      │
│ dropwhile    │ 条件为真时跳过         │ dropWhile()      │
│ filterfalse  │ 条件为假时保留         │ filter(not ...)  │
│ chain        │ 拼接多个可迭代对象      │ concat()         │
│ tee          │ 分叉（复制迭代器）      │ (无直接等价)      │
│ groupby      │ 按 key 分组           │ groupingBy()     │
│ accumulate   │ 累积（前缀和）         │ (无直接等价)      │
│ pairwise     │ 相邻元素对             │ (无直接等价)      │
│ zip_longest  │ 最长匹配 zip          │ (无直接等价)      │
└──────────────┴──────────────────────────────────────┘

典型组合示例：

from itertools import islice, takewhile, dropwhile, chain

# 跳过注释行，取前 10 条数据行
with open("data.csv") as f:
    data_lines = dropwhile(lambda line: line.startswith("#"), f)
    header = next(data_lines)  # 取标题行
    top10 = list(islice(data_lines, 10))

# 拼接多个数据源
all_data = chain(iter(source_a), iter(source_b), iter(source_c))

Java 翻译 : Java Stream 的中间操作是方法链 （stream.filter().map().limit()），每个操作是 Stream 对象的方法。Python itertools 是独立函数 （islice(filter(map(...)))），每个函数返回一个迭代器。这不是优劣问题------是两种 API 设计风格：fluent interface vs functional composition。Python 的嵌套函数调用在 3 步以上会变得难读，这催生了用生成器表达式或第三方管道库（如 pipe）的需求。

6.3 组合迭代器

from itertools import product, permutations, combinations

# 笛卡尔积
list(product("AB", "12"))           # [('A','1'), ('A','2'), ('B','1'), ('B','2')]

# 排列
list(permutations("ABC", 2))        # [('A','B'), ('A','C'), ('B','A'), ('B','C'), ('C','A'), ('C','B')]

# 组合
list(combinations("ABC", 2))        # [('A','B'), ('A','C'), ('B','C')]

这些在算法题和测试用例生成中非常实用，但生产代码中用得较少。

6.4 accumulate：你需要的不是 for 循环

from itertools import accumulate
import operator

nums = [1, 2, 3, 4, 5]
list(accumulate(nums))              # [1, 3, 6, 10, 15]  前缀和
list(accumulate(nums, operator.mul)) # [1, 2, 6, 24, 120]  前缀积

accumulate 本质上是前缀扫描（prefix scan）------每次输出都基于前一次累积的结果。与 map（独立转换每个元素）不同，accumulate 维护一个跨迭代的状态。

6.5 惰性求值的代价

生成器每次 next() 涉及 Python 帧切换（保存/恢复 gi_frame），有微小但不可忽略的开销。对于单次大数据流处理，生成器的内存优势碾压这点开销。但对于极高频的小数据访问（如数值计算中的内层循环），列表推导式可能反而更快。

场景	推荐	原因
大文件逐行处理（GB 级）	生成器	内存友好
小列表反复访问（<1000 条）	列表/元组	避免重复创建迭代器
数值循环（百万次）	列表推导式	帧切换开销累积
数据管道组合（链式操作）	itertools + 生成器	惰性，可组合

选型原则：大数据走生成器（省内存），小数据高频访问走列表（省 CPU）。

6.6 实战：用 itertools 处理 GB 级日志

场景：一个 2GB 的 access.log，需要统计每个 HTTP 状态码的请求数 Top 5。

from itertools import islice, groupby
from collections import Counter

def parse_status(line):
    # "127.0.0.1 - - [20/Jun/2026:10:00:00] \"GET / HTTP/1.1\" 200 1234"
    return line.split("\" ")[-1].split()[0]

with open("access.log") as f:
    # 跳过注释行，取数据行
    lines = (line.strip() for line in f if not line.startswith("#"))
    # 提取状态码
    statuses = (parse_status(line) for line in lines)
    # 统计（Counter 内部遍历生成器，逐行消费）
    top5 = Counter(statuses).most_common(5)

print(top5)
# [('200', 152341), ('404', 8234), ('304', 4123), ('500', 891), ('403', 456)]

全程只有一个文件读取游标 + 两个生成器对象在内存中，2GB 文件处理峰值内存 < 10MB。这就是惰性管道的威力。

进阶阅读 ：标准库 itertools 之外，more-itertools 提供了 peekable（窥探下一个元素不消费）、chunked（固定大小分块）、distribute（轮流分发）等实用工具，适合更复杂的数据管道场景。

第 7 章：map/filter/reduce + lambda --- 函数式三板斧

7.1 map 和 filter 返回的是迭代器

Python 3 的一个关键变化：map() 和 filter() 不再返回列表，而是返回惰性迭代器。

# Python 3: map 返回迭代器
m = map(str.upper, ["a", "b", "c"])
print(m)    # <map object at 0x...>  ------ 不是 ['A', 'B', 'C']
print(list(m))  # ['A', 'B', 'C']
print(list(m))  # []  ← 迭代器已耗尽！

# Python 2: map 返回列表（迫切求值）
# m = map(str.upper, ["a", "b", "c"])  # ['A', 'B', 'C']

Java 翻译 : Java 的 Stream.map() 返回的也是惰性 Stream------这一点和 Python 3 一致。但 Java 的 Stream 有 collect()、toList() 等末端操作明确标识"现在执行"。Python 3 的 map/filter 返回的迭代器没有这种明确标识------新手很容易写出 map(...) 后以为已经得到列表，实际上什么都没计算。这是 Python 3 函数式编程最常见的坑之一（第 9 章会详细展开）。

7.2 lambda：匿名函数

# lambda 的参数语法与 def 相同，但函数体只能是单个表达式
add = lambda x, y: x + y
add(3, 5)  # 8

# 典型场景：作为 map/filter/sorted 的 key 函数
sorted(users, key=lambda u: u.age)
filter(lambda x: x % 2 == 0, range(10))

限制：lambda 只能包含一个表达式，不能有语句（赋值、if-else 块、循环等）。复杂逻辑用 def 定义具名函数------可读性更好，也更容易调试。

7.3 reduce：从 functools 中来

reduce 在 Python 3 中被移到了 functools（Python 2 中它是内置函数），因为 Guido 认为它可读性差：

from functools import reduce

# 求和
reduce(lambda a, b: a + b, [1, 2, 3, 4, 5])  # 15
# 等价于: ((((1 + 2) + 3) + 4) + 5)

# 但更可读的写法是：
sum([1, 2, 3, 4, 5])  # 直接用 sum()

Guido 的观点："Almost every time I see a reduce() call with a non-trivial function argument, I need to grab pen and paper to diagram what's actually being fed into the function." 能用 sum()、any()、all()、"".join()、生成器表达式的场景，不要用 reduce。

7.4 三板斧 vs 推导式 vs 生成器表达式

# 三种等价写法------过滤偶数，平方，求和

# 写法 1: map + filter + reduce
reduce(lambda a, b: a + b,
       map(lambda x: x ** 2,
           filter(lambda x: x % 2 == 0, range(10))))

# 写法 2: 生成器表达式（推荐）
sum(x ** 2 for x in range(10) if x % 2 == 0)

# 写法 3: 列表推导式（如果结果集小且需要复用）
squares = [x ** 2 for x in range(10) if x % 2 == 0]
sum(squares)

推荐顺序：生成器表达式 > 推导式 > map/filter > reduce 。生成器表达式可读性最好，惰性求值；推导式简洁但迫切求值；map/filter 搭配 lambda 的可读性不如推导式；reduce 只在必须累积且没有内置替代函数时使用。

Java 翻译 : Java 中 stream.map().filter().reduce() 是惯用写法------因为 Java 没有推导式/生成器表达式语法，方法链是表达数据管道的最自然方式。Python 中推导式/生成器表达式提供了更简洁的声明式语法，所以 map/filter/reduce 的使用频率远低于它们在 Java 中的对应物。

第 8 章：functools --- 高阶函数的工具箱

8.1 partial：预填充函数参数

from functools import partial

def format_number(prefix, num, suffix):
    return f"{prefix}{num:,}{suffix}"

# 固定 prefix 和 suffix
format_usd = partial(format_number, prefix="$", suffix=" USD")
format_usd(1234567)  # "$1,234,567 USD"

partial 的本质是柯里化（currying）的实用替代------它不是语言层面的柯里化，但能达到类似效果。

Java 翻译 : Java 中没有直接等价物。最接近的是 lambda 捕获外部变量：Function<Integer, String> formatUsd = n -> formatNumber("$", n, " USD");。partial 的优势在于可以部分应用于任何位置的关键字参数（不像 lambda 需要显式重写所有参数）。

8.2 lru_cache：用空间换时间的极致体验

from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

fibonacci(100)  # 瞬间完成------没有 lru_cache 这需要宇宙的寿命

lru_cache 将函数的输入→输出映射缓存在字典中。每次调用先查缓存------命中则直接返回，未命中则执行函数并存入缓存。这是 Python 中实现记忆化（memoization）的最简单方式。

关键参数：

• maxsize: 缓存上限（最久未使用的条目会被驱逐）。设为 None 表示无限缓存
• typed: 是否区分 f(3) 和 f(3.0)（默认不区分）

硬性约束 ：被缓存函数的参数必须是可哈希的（hashable）。若需缓存不可哈希参数（如 list），请考虑手动实现缓存或先转为 tuple。

lru_cache 的内部结构：
┌────────────────────────────────────────────┐
│  cache_info() → (hits, misses, maxsize, currsize)
│
│  缓存命中: fibonacci(5) → 直接从 dict 返回
│  缓存未命中: fibonacci(7) → 执行函数 → 存入 dict
│  缓存满: 淘汰最久未使用的条目 (LRU)
└────────────────────────────────────────────┘

Java 翻译 : Java 中实现 memoization 通常需要显式维护一个 ConcurrentHashMap 或使用 Guava 的 CacheBuilder。Python 的 @lru_cache 用一行装饰器完成了 Java 中需要十几行代码和依赖第三方库的事------这是动态语言在元编程上的天然优势（关于装饰器机制的深入讨论，见系列的下一篇文章）。

8.3 singledispatch：函数重载的 Python 方式

from functools import singledispatch

@singledispatch
def process(arg):
    raise NotImplementedError(f"Unsupported type: {type(arg)}")

@process.register(int)
def _(arg):
    return f"Integer: {arg}"

@process.register(str)
def _(arg):
    return f"String: {arg}"

@process.register(list)
def _(arg):
    return f"List with {len(arg)} items"

process(42)       # "Integer: 42"
process("hello")  # "String: hello"
process([1, 2])   # "List with 2 items"

这类似于 Java 的方法重载------但 Python 的 singledispatch 是在运行时根据第一个参数的类型分发，而非编译期决议。

第 9 章：常见陷阱

陷阱 1: 生成器只能遍历一次

gen = (x**2 for x in range(3))
list(gen)  # [0, 1, 4]
list(gen)  # []  ← 第二次遍历是空的！

Java 翻译 : Java Stream 也只能消费一次------stream.forEach() 之后再调用 stream.collect() 会抛 IllegalStateException。这是惰性管道的共同约束：数据不是存储的，是"流"过的。

规避 : 如果需要多次遍历，将结果转成 list/tuple 存储。

陷阱 2: map/filter 返回迭代器，不是列表

# 这是 Python 3 新手最常见的坑
result = map(str.upper, ["a", "b", "c"])
print(result)  # <map object at 0x...>  ← 不是 ['A', 'B', 'C']

# 正确做法：显式转换为列表
result = list(map(str.upper, ["a", "b", "c"]))

陷阱 3: 闭包中的变量延迟绑定

# 反直觉的行为
funcs = [lambda: i for i in range(3)]
print([f() for f in funcs])  # [2, 2, 2]  ← 不是 [0, 1, 2]！

# 原因: lambda 中的 i 是在调用时查找的，此时循环已结束，i=2

修复: 用默认参数捕获当前值：

funcs = [lambda i=i: i for i in range(3)]
print([f() for f in funcs])  # [0, 1, 2]  ← 正确

陷阱 4: yield from 的嵌套行为

def sub():
    yield 1
    yield 2

def main():
    yield from sub()  # 委托给子生成器
    yield 3

list(main())  # [1, 2, 3]  ← 不是 [generator, 3]

yield from 会展开 子生成器，把它的每个值逐一产出。如果本意是想把子生成器作为一个整体产出（比如"产出一个生成器对象"），直接用 yield sub() 即可。

陷阱 5: 推导式中的变量在 Python 2 中会泄露

# Python 2:
x = 10
result = [x for x in range(3)]
print(x)  # Python 2: 2 (被推导式覆盖)  Python 3: 10 (不受影响)

陷阱 6: itertools.groupby 需要预排序

from itertools import groupby

# 错误：groupby 只合并相邻的相同 key
data = ["apple", "banana", "apricot", "blueberry"]
groups = {k: list(g) for k, g in groupby(data, key=lambda x: x[0])}
# 结果: {"a": ["apple"], "b": ["banana"], "a": ["apricot"], ...}
# "apple" 和 "apricot" 没有被合并到同一组！

# 正确：先排序
data.sort(key=lambda x: x[0])
groups = {k: list(g) for k, g in groupby(data, key=lambda x: x[0])}
# 结果: {"a": ["apple", "apricot"], "b": ["banana", "blueberry"]}

类似 SQL 的 GROUP BY 会自动排序，但 itertools.groupby 是流式操作------它只合并连续出现的相同 key。这是有意为之的设计：如果你想按键聚合但不关心顺序（比如日志分析），groupby + 预排序是最高效的方案。

陷阱 7: 在迭代中修改正在遍历的集合

# 这会导致不可预测的行为
data = [1, 2, 3, 4, 5]
for x in data:
    if x % 2 == 0:
        data.remove(x)  # ← 危险：修改正在遍历的列表
print(data)  # [1, 3, 5]？不一定，取决于实现

修复: 用推导式创建新列表，或者遍历副本。

data = [x for x in data if x % 2 != 0]  # 创建新列表

第 10 章：收束 --- 选型决策框架与关键收获

10.1 选型决策框架

你的数据量有多大？
│
├── 小（<1000 条），需要多次访问
│   → 列表推导式 [expr for x in data]
│
├── 大（>100万条），只需遍历一次
│   → 生成器表达式 (expr for x in data)
│     或者 itertools 管道
│
├── 需要复杂的数据管道组合
│   ├── Java Stream 式的链式调用风格 → 用迭代器包装类或 pipe 库
│   ├── Pythonic 风格 → 嵌套生成器表达式 + itertools
│   └── 可读性优先 → 拆成多个生成器函数，每个做一件事
│
└── 需要缓存/记忆化
    → @lru_cache（纯函数）
      或手动维护 dict（有副作用）

10.2 惰性管道的三种构建方式对比

方式	可读性	惰性	可复用	适用场景
生成器函数 (def + yield)	★★★★★	✅	✅ (函数可复用)	复杂逻辑，需要调试
生成器表达式	★★★★	✅	❌ (用完即弃)	简单过滤/转换
itertools 管道	★★★	✅	✅	多步组合，类似 Stream
map/filter + lambda	★★	✅	✅	不推荐------推导式更好
列表推导式	★★★★★	❌	❌	小数据，需多次访问

10.3 生产排查工具

import sys
import tracemalloc
from itertools import islice

# 1. 检查对象是迭代器还是列表
def is_iterator(obj):
    return hasattr(obj, "__next__")

# 2. 检查迭代器是否已耗尽
gen = (x for x in range(3))
list(gen)
# 再次检查：
hasattr(gen, "__next__")  # True（但调用 next() 会抛 StopIteration）

# 3. 内存排查：生成器 vs 列表
tracemalloc.start()
# 生成器: 峰值内存极小
gen = (x for x in range(10_000_000))
current, peak = tracemalloc.get_traced_memory()
print(f"Generator peak: {peak / 1024:.1f} KB")

tracemalloc.reset_peaks()
# 列表: 峰值内存 ~80 MB
lst = list(range(10_000_000))
current, peak = tracemalloc.get_traced_memory()
print(f"List peak: {peak / 1024:.1f} KB")

# 4. 检查是否意外触发了迫切求值
# 生成器表达式被 *args 展开会触发遍历：
# list(*gen)   ← 这会展开所有元素再传给 list()，等于迫切求值
# 正确: list(gen)

# 5. 调试生成器：itertools 切片
# 不要 list() 整个大生成器，用 islice 只看前 N 个
for item in islice(large_generator, 5):
    print(f"Preview: {item}")

10.4 关键收获

1. Python 的函数式特性基于迭代器协议 ------__iter__/__next__ 是惰性计算的接口层，for 循环、yield、推导式、itertools 都构建在这个协议之上。

2. 生成器是惰性计算的原语------它把"自动保存帧状态"这个能力内建到了语言层面，让编写复杂惰性逻辑像写普通循环一样自然。这是 Python 对比 Java 的最大优势：Java 需要手动维护 Iterator 的状态变量。

3. Pull 模式 vs Push 模式------Python 的惰性计算是 pull 模式（消费者驱动），Java Stream 也是惰性的但由末端操作一次性 push 驱动。这个差异影响了你如何思考管道组合：Python 中你更倾向于拆成多个生成器函数，Java 中你更倾向于一条方法链。

4. 选型优先顺序: 生成器表达式 > 推导式 > map/filter > reduce。能用声明式语法的场景不写命令式循环，能用惰性求值的场景不迫切构建整个列表。

5. Python 3 的关键变化 : map/filter/range/zip/dict.keys() 都返回迭代器/视图而非列表------这是默认惰性的设计哲学。理解这一点是避免"迭代器已耗尽"类 bug 的关键。

6. 与先行文章的关系: 本文从"惰性计算/数据管道"角度展开函数式特性。《Python 异常模型深度解析》从"异常作为协议信号"角度覆盖了 StopIteration 的设计取舍。《Python 并发深度解析》覆盖了 asyncio 协程（生成器的"接收值"面）。三篇文章共同构成对 Python 生成器的完整认知------信号面、数据管道面、协程面。

---

下一站 : 装饰器与元编程------Python 的 AOP。装饰器用 @decorator 语法在不修改函数源码的情况下注入横切逻辑。理解装饰器需要先理解"函数是一等对象"和"闭包"------这正是本文第 7、8 章铺垫的基础。