w wyl123ly 的博客
MD

Python语法速查

23 KB 2026.10.18 原文件

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__,不参与类型检查。
  • :重复次数或序列长度,取非负整数。

为什么重要

  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))。

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 迭代与批处理示例。