---
tags: [AI, python, 对象模型]
阶段: 02-Python与数据处理
难度: ★★☆
created: 2026-10-18
related: "[[MOC-Python]], [[NumPy向量化]], [[PyTorch实战入门]], [[Pandas数据清洗]]"
---

# Python语法速查

## 定义

Python 语法速查是对 CPython 运行时中名字绑定、对象与协议三者交互规则的条目化整理：每条规则都能由一段可运行代码验证，并对应一个可命名的语言机制。

- 对象（object）：内存中带类型、标识与值的数据单元。`id(obj)` 给出对象在其生命周期内唯一的标识，`type(obj)` 给出类型。
- 名字（name）：标识符到对象的绑定条目，存放在模块、函数或类的命名空间中。赋值语句 `name = expr` 只修改绑定，不修改对象。
- 引用（reference）：从名字、容器元素或属性指向对象的指针；`sys.getrefcount(obj)` 返回其计数，函数实参本身额外计入一次。
- 可变对象（mutable object）：`id` 不变而值可变的类型，如 `list`、`dict`、`set`、`bytearray` 与多数自定义类实例。
- 不可变对象（immutable object）：创建后值不可变的类型，如 `int`、`float`、`str`、`tuple`、`frozenset`；对它们运算会返回新对象。
- 迭代器协议（iterator protocol）：`__iter__` 返回迭代器对象，迭代器的 `__next__` 返回下一个元素，耗尽时抛 `StopIteration`。
- 生成器（generator）：函数体含 `yield` 的函数被调用后返回的对象。它自动实现迭代器协议，并在两次 `next` 之间保留执行帧与局部变量。
- 上下文管理器（context manager）：实现 `__enter__` 与 `__exit__` 的对象，由 `with` 在进入与退出（含异常退出）时调用。
- 装饰器（decorator）：接受可调用对象并返回可调用对象的可调用对象；`@deco` 等价于在函数定义结束后执行 `f = deco(f)`。
- 类型注解（type annotation）：写在形参、返回值或变量后的表达式；运行时默认只写入 `__annotations__`，不参与类型检查。
- $n$：重复次数或序列长度，取非负整数。

## 为什么重要

1. 深度学习代码的多数静默错误来自别名而不是算法。`[[0] * 2] * 3` 生成三行共享同一内层列表的矩阵，修改一行会同时改变三行；`def train(losses=[])` 让默认列表跨调用累积。这类错误不抛异常，只让指标缓慢偏移，难以从日志定位。
2. 数据加载依赖迭代器协议。PyTorch 的 `Dataset` 用 `__getitem__` 与 `__len__` 提供按索引访问，`DataLoader` 依据采样器产生索引并组装 batch；流式数据实现 `__iter__`。缺 `__len__` 时 `len(dataset)` 直接报错，该行为只能在协议层解释。
3. 资源释放依赖上下文管理器。`torch.no_grad()`、`torch.autocast()`、`open`、文件锁都必须在异常路径上退出；`with` 是唯一由语言保证的机制，手写 `try/finally` 容易在提前返回的分支遗漏。
4. 装饰器承担横切逻辑。计时、缓存、算子注册、禁用梯度都以装饰器实现；缺 `functools.wraps` 会使 `__name__` 变成 `wrapper`，破坏按名字注册与日志。
5. 类型注解把形状与 dtype 的约定前移到接口。静态检查器能在运行前发现 `Optional` 未判空、`Iterable` 被重复消费；`dataclass` 直接由注解生成初始化、比较与表示方法。
6. 复杂度决定训练循环的常数因子。O(n²) 拼接、循环内的全局名字查找、`in list` 的线性扫描，在百万级样本上放大为可观测的分钟级差异。

本篇是「能复现」的语法前提：[[NumPy向量化]] 把索引与迭代语义搬到连续内存数组上，[[PyTorch实战入门]] 再把数组语义扩展到设备与自动求导；缺本篇，后两篇多数报错信息无法解读。

## 原理与推导

### 1 对象模型与名字绑定

赋值只改变命名空间中的绑定，不复制对象；函数调用把实参对象绑定到形参名，二者是同一对象的两个名字。函数是否修改调用方数据，取决于函数体是重绑定形参（`xs = xs + [0]`）还是原地修改对象（`xs.append(0)`）。

```python
a = [1, 2]; b = a          # b 与 a 绑定同一对象
b.append(3); print(a, a is b)   # 输出: [1, 2, 3] True
c = a + [4]                # 拼接产生新对象
print(a, a is c)           # 输出: [1, 2, 3] False

def push(xs):
    xs.append(0)           # 原地修改，调用方可见
push(a); print(a)          # 输出: [1, 2, 3, 0]
```

`a += [4]` 调用 `list.__iadd__` 原地扩展，别名同时看到变化；`a = a + [4]` 才创建新对象。`int` 等不可变类型没有原地版本，`+=` 一律重绑定。

### 2 可变性与两类别名陷阱

`[obj] * n` 复制引用而非对象：对不可变元素（`int`、`str`、`None`）安全，对列表等可变元素则让 $n$ 个位置共享同一对象。默认参数在 `def` 执行时求值一次，存于函数对象的 `__defaults__`，与函数同寿命。

```python
grid = [[0] * 2] * 3              # 三行共享同一内层列表
grid[0][0] = 1
print(grid)                       # 输出: [[1, 0], [1, 0], [1, 0]]
grid2 = [[0] * 2 for _ in range(3)]
grid2[0][0] = 1
print(grid2)                      # 输出: [[1, 0], [0, 0], [0, 0]]

def add(x, acc=[]):               # 默认列表只创建一次
    acc.append(x); return acc
def add_ok(x, acc=None):          # None 为哨兵，每次调用新建
    acc = [] if acc is None else acc
    acc.append(x); return acc
print(add(1))                     # 输出: [1]
print(add(2))                     # 输出: [1, 2]
print(add_ok(1), add_ok(2))       # 输出: [1] [2]
```

### 3 切片与步长

`s[i:j:k]` 表示从索引 `i` 开始、以 `k` 为步长、在到达 `j` 之前停止的子序列。三个分量都可省略；负数索引从尾部计数；`k` 为负时默认 `i = len(s) - 1`、`j` 为序列头之前的位置。切片不检查越界，越界部分截断为空；对 `list` 返回新列表（浅拷贝），规范边界可由 `slice(i, j, k).indices(n)` 取得。

```python
s = list(range(10))
print(s[2:8:2], s[-3:], s[::-1][:3])   # 输出: [2, 4, 6] [7, 8, 9] [9, 8, 7]
print(s[5:2:-1], s[100:200])           # 输出: [5, 4, 3] []
print(slice(2, 100, 3).indices(10))    # 输出: (2, 10, 3)
t = s[:]
print(t is s, t == s)                  # 输出: False True
```

切片赋值 `s[2:4] = [9, 9, 9]` 允许右侧长度与切片长度不同，仅对可变序列有效。NumPy 中同样的语法返回视图而非拷贝，赋值会写回原数组，差异见 [[NumPy向量化]]。

### 4 列表、字典与集合推导式

`[expr for x in it if cond]` 等价于先建空列表、再按 `for` 顺序求值 `expr` 并 `append`；多个 `for` 子句按书写顺序从左到右嵌套，`if` 只过滤其所在层。字典与集合推导式分别写作 `{k: v for ...}`、`{expr for ...}`，生成器表达式写作 `(expr for ...)` 且惰性求值。Python 3 中推导式有独立函数作用域，循环变量不泄漏；生成器表达式捕获外层名字的引用，延迟求值时读取的是那时的绑定。

```python
xs = [1, 2, 3, 4, 5]
print([x * x for x in xs if x % 2 == 1])   # 输出: [1, 9, 25]
print({x: x % 2 for x in xs})              # 输出: {1: 1, 2: 0, 3: 1, 4: 0, 5: 1}
print(sorted({x % 3 for x in xs}))         # 输出: [0, 1, 2]（集合本身无序）
print([(x, y) for x in range(2) for y in range(2)])
# 输出: [(0, 0), (0, 1), (1, 0), (1, 1)]
n = 3
_ = [n for n in range(5)]                  # 推导式内 n 为局部名
print(n, sum(x * x for x in xs))           # 输出: 3 55
```

### 5 迭代器协议与生成器

`for x in obj` 先调用 `iter(obj)` 得到迭代器，再反复 `next()`，捕获 `StopIteration` 结束。可迭代对象能反复产生新的迭代器（`list`、`dict`），迭代器只能耗尽一次（生成器、文件对象、`map` 与 `filter` 的返回值）。生成器函数调用时不执行函数体，只创建生成器对象；每次 `next` 执行到下一个 `yield` 并挂起，帧中的局部变量与指令指针保持不变，因此峰值内存由同时存活的元素数决定，而不是序列总长。

```python
import sys

def countdown(n):
    while n > 0:
        yield n            # 挂起并保存 n
        n -= 1
g = countdown(3)
print(next(g), next(g), next(g))    # 输出: 3 2 1
print(list(g))                      # 输出: []（已耗尽，不能重放）

def read_batches(rows, size):
    for i in range(0, len(rows), size):
        yield list(rows[i:i + size])

print(list(read_batches(range(5), 2)))   # 输出: [[0, 1], [2, 3], [4]]
print(sys.getsizeof(countdown(10)), sys.getsizeof(list(range(1000))))
# 输出: 约 180 字节 与 8056 字节（平台相关）
```

### 6 装饰器与闭包

闭包是引用外层函数局部变量的内层函数；外层返回内层时，这些变量保存在 `__closure__` 的 cell 中，生命周期延长到内层函数被回收。装饰器把原函数 `fn` 存入闭包并返回包装函数 `wrapper`；`@deco` 与 `f = deco(f)` 等价，发生在 `def` 执行完成之后、模块继续执行之前。`functools.wraps` 把 `__module__`、`__name__`、`__qualname__`、`__annotations__`、`__doc__`、`__dict__` 复制到包装函数并设置 `__wrapped__`，使 `inspect.signature` 能取回真实签名。带参装饰器多一层求值：`@retry(times=3)` 先得到 `retry(times=3)` 的返回值，再用它装饰函数。

```python
import functools, time

def timed(times=1):                  # 带参装饰器：三层结构
    def deco(fn):
        @functools.wraps(fn)         # 保留 __name__、__doc__、__wrapped__
        def wrapper(*args, **kwargs):
            t0 = time.perf_counter()
            out = [fn(*args, **kwargs) for _ in range(times)]
            print(f"{fn.__name__} {time.perf_counter() - t0:.4f}s")
            return out[0] if times == 1 else out
        return wrapper
    return deco

@timed()
def add(a, b):
    return a + b

@timed(times=3)
def ping():
    return "pong"

print(add(1, 2))       # 输出: add 0.0000s 换行 3
print(add.__name__)    # 输出: add（去掉 wraps 则为 wrapper）
print(ping())          # 输出: ping 0.0000s 换行 ['pong', 'pong', 'pong']
```

PyTorch 的 `@torch.no_grad()` 属于带参装饰器；`@functools.lru_cache` 用于缓存可哈希输入的数据预处理结果。

### 7 上下文管理器

`with expr as var:` 的求值顺序为：求值 `expr` 得到管理器 `cm`；调用 `cm.__enter__()`，返回值绑定到 `var`；执行语句体；无论正常结束还是异常，调用 `cm.__exit__(exc_type, exc, tb)`。`__exit__` 返回真值时异常被抑制，返回 `None` 或假值时继续向外传播。`contextlib.contextmanager` 把生成器转换为上下文管理器：`yield` 之前的代码对应 `__enter__`，之后的代码对应 `__exit__`，异常在 `yield` 处抛出，需要 `try/finally` 才能保证清理。

```python
import time

class Timer:
    def __enter__(self):
        self.t0 = time.perf_counter()
        return self
    def __exit__(self, exc_type, exc, tb):
        print(f"elapsed {time.perf_counter() - self.t0:.4f}s")
        return False          # 不抑制异常

with Timer():
    sum(range(100000))
# 输出: elapsed 0.00xx s（耗时随机器变化）
```

`return False` 让异常继续传播；若返回 `True`，`with` 块内的异常被吞掉，调用方无法察觉失败。深度学习代码中 `torch.no_grad()` 关闭自动求导记录以降低推理显存，`torch.autocast()` 在块内切换算子精度并在退出时恢复；二者若在异常路径未恢复，后续训练步会沿用错误配置。

### 8 异常处理与自定义异常

`try/except/else/finally` 的分工：`except` 按书写顺序匹配异常类型，`else` 在无异常时执行，`finally` 无条件执行且在 `return` 之前。异常对象带 `__traceback__`；`raise New from e` 设置 `__cause__` 形成显式因果链，隐式上下文记录在 `__context__`。自定义异常应继承 `Exception` 的具体子类（如 `ValueError`），在 `__init__` 中保存结构化字段并调用 `super().__init__(message)`，使上层既能按类型捕获，也能按字段处理。

```python
class ShapeError(ValueError):
    def __init__(self, expected, got):
        super().__init__(f"expected {expected}, got {got}")
        self.expected, self.got = expected, got

try:
    raise ShapeError(4, 3)
except ShapeError as e:
    print(type(e).__name__, e.expected, e.got)   # 输出: ShapeError 4 3

def f():
    try:
        return "try"
    finally:
        print("finally 执行")     # 先于返回执行
print(f())                        # 输出: finally 执行 换行 try
```

捕获 CUDA 显存不足应匹配 `torch.cuda.OutOfMemoryError` 而非裸 `Exception`；捕获后释放缓存并降低 batch size 重试，才能把可恢复错误与代码缺陷分开。

### 9 类、继承、dataclass 与魔术方法

类体执行时创建类对象，实例属性默认存入 `__dict__`；属性查找沿 MRO 进行，`super()` 按 MRO 定位下一个类。`@dataclass` 依类级注解生成 `__init__`、`__repr__`、`__eq__`；可变默认值必须用 `field(default_factory=list)`，否则所有实例共享同一列表；`frozen=True` 生成不可变实例与 `__hash__`。魔术方法把语法映射到调用：`__repr__` 面向开发者且应能重建对象，`__str__` 面向输出；`__len__` 必须返回非负整数；`__getitem__` 支持索引与切片，越界抛 `IndexError`，它的存在也使对象可被 `for` 迭代（旧式迭代协议），定义 `__iter__` 时后者优先。

```python
from dataclasses import dataclass, field

@dataclass
class Batch:
    ids: list
    labels: list = field(default_factory=list)   # 每个实例新建
    def __len__(self): return len(self.ids)
    def __getitem__(self, i): return self.ids[i]
    def __repr__(self): return f"Batch(n={len(self)}, ids={self.ids[:3]}...)"

b, c = Batch([1, 2, 3, 4]), Batch([1])
print(len(b), b[0], b[-1])        # 输出: 4 1 4
print(b, b.labels is c.labels)    # 输出: Batch(n=4, ids=[1, 2, 3]...) False

class Model:
    def forward(self, x): raise NotImplementedError
class Linear(Model):
    def __init__(self, w): self.w = w
    def forward(self, x): return self.w * x

print(Linear(2).forward(3))                      # 输出: 6
print([k.__name__ for k in Linear.__mro__])      # 输出: ['Linear', 'Model', 'object']
```

### 10 类型注解与 typing

注解在函数定义时求值并写入 `__annotations__`；`from __future__ import annotations` 使其保存为字符串，避免前向引用问题与求值开销。注解不强制检查，运行时校验需显式 `assert isinstance` 或交给 pydantic 一类库。常用构造：`list[int]` 与 `dict[str, float]`（3.9 起内置泛型）、`Optional[T]` 或 `T | None`（3.10 起）、`Callable[[int], str]`、`Iterable[T]` 与 `Sequence[T]`、`TypeVar`、`Protocol`、`TypedDict`。

```python
from typing import Iterable, Optional, TypeVar

T = TypeVar("T")

def first(xs: Iterable[T], default: Optional[T] = None) -> Optional[T]:
    for x in xs:
        return x
    return default

print(first([7]), first([], None))          # 输出: 7 None
print(first.__annotations__["return"])      # 输出: typing.Optional[~T]

def attn(q, k):
    # q: (B, H, T, D), k: (B, H, S, D) -> (B, H, T, S)
    assert q.shape[-1] == k.shape[-1]
    return q @ k.swapaxes(-1, -2)
```

### 11 常用标准库

`pathlib.Path` 负责路径拼接与跨平台分隔符，`collections` 提供分组计数与双端队列，`itertools` 提供惰性切片与组合，`functools` 提供缓存与参数绑定，`json` 负责配置与标注数据的序列化。

```python
from pathlib import Path
from collections import Counter, defaultdict
from itertools import chain, islice
from functools import lru_cache
import json

p = Path("data") / "train.jsonl"
print(p.name, p.suffix, p.parent)               # 输出: train.jsonl .jsonl data
print(Counter("abracadabra").most_common(2))    # 输出: [('a', 5), ('b', 2)]

d = defaultdict(list)
for k, v in [("a", 1), ("a", 3), ("b", 2)]:
    d[k].append(v)
print(dict(d), list(islice(chain([1, 2], [3, 4]), 3)))
# 输出: {'a': [1, 3], 'b': [2]} [1, 2, 3]

@lru_cache(maxsize=None)
def fib(n): return n if n < 2 else fib(n - 1) + fib(n - 2)
print(fib(30), json.loads('{"lr": 0.1}')["lr"])  # 输出: 832040 0.1
```

`lru_cache` 以参数元组为键，参数必须可哈希；返回可变对象时调用方应自行复制。`Path` 在 Windows 上自动使用反斜杠并接受正斜杠，避免手写拼接的转义错误。

### 12 性能要点

- 名字查找：函数内局部名编译为 `LOAD_FAST`，按数组下标访问；全局名与属性走字典查找。循环内把 `out.append` 绑定为局部名可减少重复属性查找。
- 字符串拼接：`"".join(parts)` 先算总长度再一次分配，复杂度 O(n)；循环内 `s += part` 依赖 CPython 对唯一引用字符串的原地扩容优化，该优化不属于语言语义，存在别名或更换实现时退化为 O(n²)。
- 成员检测：`x in list` 为 O(n)，`x in set` 平均 O(1)；反复判重时先构造 `set`。
- 头部插入：`list.insert(0, x)` 为 O(n)，累计 O(n²)；改用 `collections.deque.appendleft`。
- 数值循环：逐元素 Python 循环应下沉到 NumPy 的编译内核，量级差异见 [[NumPy向量化]]。

```python
import timeit
xs = list(range(10000)); ys = set(xs)
t1 = min(timeit.repeat(lambda: 9999 in xs, number=1000, repeat=3))
t2 = min(timeit.repeat(lambda: 9999 in ys, number=1000, repeat=3))
print(f"list {t1:.4f}s, set {t2:.6f}s")   # 输出: list 约 0.1 s，set 约 0.00008 s
```

## 关键直觉

> [!tip] 两个可操作的判据
> 任何赋值语句之后，先问这一步是否创建了新对象：`id` 改变说明重绑定，`id` 不变而内容改变说明原地修改，后者影响全部别名。任何 `yield` 或生成器表达式，先问求值发生在定义时还是迭代时：前者立即占用与长度成正比的内存，后者只占用当前帧的空间。两条判据分别是名字绑定规则与迭代器协议的直接推论，与「定义」一节的严格表述一致，区别只在观察角度。

## 例子与代码

下面的程序把本篇协议组合成一个最小数据管道：`Dataset` 实现 `__len__` 与 `__getitem__`，生成器产出 batch，上下文管理器在正常与异常路径上恢复状态。运行环境为 Python 3.11 及以上，只用标准库。

```python
class ArrayDataset:
    def __init__(self, xs, ys):
        assert len(xs) == len(ys)
        self.xs, self.ys = xs, ys
    def __len__(self): return len(self.xs)
    def __getitem__(self, i): return self.xs[i], self.ys[i]

def batches(ds, size):
    for start in range(0, len(ds), size):
        yield [ds[i] for i in range(start, min(start + size, len(ds)))]

ds = ArrayDataset([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]], [0, 1, 0, 1, 0])
for batch in batches(ds, 2):
    print(len(batch), batch[0])
# 输出: 2 ([1, 2], 0)
#       2 ([5, 6], 0)
#       1 ([9, 10], 0)
```

这段代码在做什么：`ArrayDataset` 只用两个魔术方法就满足 map-style 数据集的契约，`batches` 按索引区间切片并逐个产出。为什么这样写：`yield` 使任意长度的数据集都以常量内存流式产出，`len(ds)` 与 `ds[i]` 的分工与 `DataLoader` 的调用方式一致。去掉 `__len__` 后 `range(0, len(ds), size)` 立即抛 `TypeError`，这是协议缺失的直接后果。

```python
class grad_mode:
    _enabled = True
    def __init__(self, enabled):
        self.enabled = enabled
    def __enter__(self):
        self.prev, grad_mode._enabled = grad_mode._enabled, self.enabled
        return self
    def __exit__(self, *exc):
        grad_mode._enabled = self.prev
        return False

print("before", grad_mode._enabled)      # 输出: before True
with grad_mode(False):
    print("inside", grad_mode._enabled)  # 输出: inside False
try:
    with grad_mode(False):
        raise ValueError("boom")
except ValueError:
    pass
print("restored", grad_mode._enabled)    # 输出: restored True
```

这段代码在做什么：`grad_mode` 在进入时保存全局标志，在退出时无条件恢复。为什么这样写：异常路径与正常路径共用同一个 `__exit__`，恢复逻辑不需要在业务代码中重复。去掉 `__exit__` 的恢复语句后，`with` 块内一旦抛异常，`_enabled` 停留在 `False`，后续所有前向计算都不再记录梯度，而报错信息与梯度缺失之间没有直接线索。

## 易错点

> [!warning]
> - `[[0] * 3] * 2` 只复制引用：`m[0][0] = 1` 后两行同时变为 `[1, 0, 0]`；正确写法是 `[[0] * 3 for _ in range(2)]`。
> - `def f(x, acc=[])` 的默认列表存于 `f.__defaults__`，跨调用累积；改用 `None` 哨兵并在函数体内新建。
> - `a += b` 对列表原地扩展并让别名可见，`a = a + b` 才产生新对象；对元组内的列表做 `+=` 修改的是列表本身，元组不变但仍影响别名。
> - 生成器只能消费一次：先 `sum(g)` 再 `list(g)` 得到 `[]`。需要重复遍历时返回容器，或调用生成器工厂函数重新创建。
> - 装饰器不使用 `functools.wraps` 时，`__name__`、`__doc__`、`__wrapped__` 与签名全部丢失，`inspect.signature` 退化为 `(*args, **kwargs)`。
> - 裸 `except:` 会捕获 `KeyboardInterrupt` 与 `SystemExit`，使程序无法用 Ctrl+C 中断；至少写 `except Exception`，重抛时用 `raise ... from e` 保留 `__cause__`。

## 关联笔记

- 前置：[[MOC-Python]] —— 阶段入口，给出本篇与后续四篇的阅读顺序与达标要求。
- 后续：[[NumPy向量化]] —— 本篇的切片与索引语义在 ndarray 上分化为视图与副本，广播规则取代逐元素循环。
- 后续：[[Pandas数据清洗]] —— 本篇的推导式与可变对象用于构造清洗管道，索引对齐另有一套规则。
- 应用：[[PyTorch实战入门]] —— `Dataset`、`DataLoader`、`torch.no_grad()` 与装饰器实践直接复用本篇协议。
- 对照：[[数据工程入门]] —— 本篇讲语言层语义，该篇讲数据版本、schema 与可复现性，二者共同决定管道是否可信。

## 达标检测

- [ ] 不看笔记，写出 `a = [1]; b = a; b.append(2)` 之后 `a` 的值，并解释 `a is b` 为何为 `True`。
- [ ] 画出 `[[0] * 2] * 3` 与嵌套推导式两种写法的引用结构，并预测修改 `m[1][0]` 后另一行的值。
- [ ] 手写生成器 `read_batches(rows, size)`，说明峰值内存与总行数的关系，并解释第二次迭代为何为空。
- [ ] 写出带参装饰器 `@retry(times=3, delay=0.1)` 的三层结构，并列出 `functools.wraps` 保留的属性。
- [ ] 实现一个上下文管理器，在正常与异常两条路径上都恢复全局标志，并说明 `__exit__` 返回 `True` 与 `False` 的行为差异。
- [ ] 用 `timeit` 比较 `list` 与 `set` 的成员检测，给出量级比并由复杂度解释差距来源。

## 参考来源

- Python 官方文档, *The Python Language Reference*, "Data model" 章 —— 对应本篇对象模型、魔术方法、迭代器协议与上下文管理器协议。
- Python 官方文档, *The Python Tutorial*, "Errors and Exceptions"、"Classes"、"Iterators and Generators" 节 —— 对应第 5、6、8、9 节的示例。
- Python 官方文档, `functools`、`contextlib`、`pathlib`、`collections`、`itertools`、`json` 模块页 —— 对应第 11 节标准库用法与第 6、7 节实现。
- Luciano Ramalho, *Fluent Python*（第 2 版）, 第 1、2、6、9、17 章 —— 对应名字绑定、可变性、装饰器与生成器四部分。
- d2l.ai《动手学深度学习》, "数据操作" 与 "数据预处理" 节 —— 对应 Dataset 迭代与批处理示例。
