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__,不参与类型检查。 - :重复次数或序列长度,取非负整数。
为什么重要
- 深度学习代码的多数静默错误来自别名而不是算法。
[[0] 2] 3生成三行共享同一内层列表的矩阵,修改一行会同时改变三行;def train(losses=[])让默认列表跨调用累积。这类错误不抛异常,只让指标缓慢偏移,难以从日志定位。 - 数据加载依赖迭代器协议。PyTorch 的
Dataset用__getitem__与__len__提供按索引访问,DataLoader依据采样器产生索引并组装 batch;流式数据实现__iter__。缺__len__时len(dataset)直接报错,该行为只能在协议层解释。 - 资源释放依赖上下文管理器。
torch.no_grad()、torch.autocast()、open、文件锁都必须在异常路径上退出;with是唯一由语言保证的机制,手写try/finally容易在提前返回的分支遗漏。 - 装饰器承担横切逻辑。计时、缓存、算子注册、禁用梯度都以装饰器实现;缺
functools.wraps会使__name__变成wrapper,破坏按名字注册与日志。 - 类型注解把形状与 dtype 的约定前移到接口。静态检查器能在运行前发现
Optional未判空、Iterable被重复消费;dataclass直接由注解生成初始化、比较与表示方法。 - 复杂度决定训练循环的常数因子。O(n²) 拼接、循环内的全局名字查找、
in list的线性扫描,在百万级样本上放大为可观测的分钟级差异。
本篇是「能复现」的语法前提:NumPy向量化 把索引与迭代语义搬到连续内存数组上,PyTorch实战入门 再把数组语义扩展到设备与自动求导;缺本篇,后两篇多数报错信息无法解读。
原理与推导
1 对象模型与名字绑定
赋值只改变命名空间中的绑定,不复制对象;函数调用把实参对象绑定到形参名,二者是同一对象的两个名字。函数是否修改调用方数据,取决于函数体是重绑定形参(xs = xs + [0])还是原地修改对象(xs.append(0))。
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)安全,对列表等可变元素则让 个位置共享同一对象。默认参数在 def 执行时求值一次,存于函数对象的 __defaults__,与函数同寿命。
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) 取得。
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 中推导式有独立函数作用域,循环变量不泄漏;生成器表达式捕获外层名字的引用,延迟求值时读取的是那时的绑定。
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 并挂起,帧中的局部变量与指令指针保持不变,因此峰值内存由同时存活的元素数决定,而不是序列总长。
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) 的返回值,再用它装饰函数。
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 才能保证清理。
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),使上层既能按类型捕获,也能按字段处理。
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__ 时后者优先。
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。
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 负责配置与标注数据的序列化。
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向量化。
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
关键直觉
两个可操作的判据
任何赋值语句之后,先问这一步是否创建了新对象:
id改变说明重绑定,id不变而内容改变说明原地修改,后者影响全部别名。任何yield或生成器表达式,先问求值发生在定义时还是迭代时:前者立即占用与长度成正比的内存,后者只占用当前帧的空间。两条判据分别是名字绑定规则与迭代器协议的直接推论,与「定义」一节的严格表述一致,区别只在观察角度。
例子与代码
下面的程序把本篇协议组合成一个最小数据管道:Dataset 实现 __len__ 与 __getitem__,生成器产出 batch,上下文管理器在正常与异常路径上恢复状态。运行环境为 Python 3.11 及以上,只用标准库。
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,这是协议缺失的直接后果。
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 迭代与批处理示例。