08.3 阶段 2:类型注解与现代特性
所属:全栈开发面试题库 / 学习路径 / 08 Python 全栈
本页目录
一、阶段定位
阶段 1 解决「对象怎么传、异常怎么抛」,但函数接口没有显式契约:调用方不知道该传什么类型、返回什么结构。本阶段引入类型注解,让编辑器与静态检查工具在运行前暴露接口错误;同时补上生成器、装饰器、上下文管理器这三个现代 Python 写法的基础设施。阶段 3 会用 mypy 把注解变成门禁,阶段 4 的 FastAPI 直接从类型注解生成请求校验与 OpenAPI 文档——注解写得对,后面全是红利。
与前后阶段的衔接:因为阶段 1 只做到「能写对脚本」,本阶段要解决「接口怎么写清楚、资源怎么自动释放、大文件怎么流式处理」。不理解迭代器协议,阶段 6 讲 async for、阶段 5 讲流式响应时会卡住;不理解装饰器,阶段 3 的 @lru_cache、阶段 4 的 @app.get、依赖注入都会变成魔法。
原有卡点及判断依据:
- 把类型注解当成运行时强制校验:判断现象是写了
def f(x: int)后传f("abc")期待报错。实际上默认运行时不检查,必须用 mypy 或 Pydantic。见 5.1。 - 装饰器叠加后函数名与文档丢失:判断现象是
@decorator之后f.__name__变成wrapper,FastAPI 的路由文档、pytest 的测试名异常。见 5.5。 - 生成器被多次遍历后耗尽:判断现象是
list(g)打印一遍正常,再for x in g就没数据。见 5.4。 - 不理解 Protocol 与继承的区别:判断现象是写
class Cat(Animal)才能被接受,而不写继承、只实现speak()方法却通不过类型检查。见 5.2。
二、阶段目标与投入
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
能为函数参数与返回值写完整类型注解,区分 Optional[X] 与 X | None |
用 mypy 默认配置检查通过 |
能定义 Protocol 表达鸭子类型,用 TypedDict 描述字典结构 |
无需显式继承即可被接受 |
| 能写生成器函数处理大文件,证明内存不随文件大小增长 | 读取 1GB 文件内存占用稳定 |
能写带参装饰器并用 functools.wraps 保留元信息 |
装饰后 f.__name__ 与 f.__doc__ 正确 |
能用 contextlib.contextmanager 封装资源获取与释放 |
异常发生时退出逻辑仍执行 |
能用 dataclass 定义数据结构并自动生成 __init__/__repr__ |
少写样板代码且字段类型明确 |
建议学时:
- 全职:1.5 周,约 45 小时。注解与类型 15 小时、迭代器生成器 10 小时、装饰器 10 小时、上下文管理器与 dataclass 10 小时。
- 在职:4 周,约 50 小时。
学时分配建议:类型注解与 Protocol 25%、生成器与迭代器 20%、装饰器 20%、上下文管理器 15%、dataclass 与标准库工具 20%。
三、先修自检
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| 函数与类基础 | 能定义函数、类、继承 | 08.2 阶段 1 |
| 异常体系 | 能抛出自定义异常 | 08.2 阶段 1 |
| 模块导入 | 能写 from x import y |
08.2 阶段 1 |
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| 类型注解 | int/str/list/dict、Optional、联合类型 X | None |
会用 | 04.7 Python |
| Protocol 与 TypedDict | 结构子类型、TypedDict、泛型 Generic |
能讲清原理 | 04.7 Python |
| 迭代器协议 | __iter__/__next__、可迭代对象与迭代器 |
能讲清原理 | 04.7 Python |
| 生成器 | yield、yield from、惰性求值、一次性耗尽 |
会用 | 04.7 Python |
| 装饰器 | 无参/带参装饰器、functools.wraps、叠加顺序 |
会用 | 04.7 Python |
| 上下文管理器 | __enter__/__exit__、contextlib、async with 预告 |
会用 | 04.7 Python |
| dataclass | @dataclass、字段默认值、frozen |
会用 | 04.7 Python |
进度管理建议:本阶段是「为阶段 3 质量工具链铺路」,所有注解写进代码后,阶段 3 的 mypy 门禁才有东西可查。《知识点全清单》「类型注解」段是全量清单。
五、分模块精讲
5.1 类型注解基础与 Optional/联合类型
为什么需要它:Python 默认运行时不校验类型,注解只是给人看、给工具看。但现代 Python 工程把注解当接口契约,编辑器补全、mypy 检查、FastAPI 请求校验都靠它。不写注解,这些工具全部失效。
核心机制:
- 注解写在参数与返回值后:
def f(name: str, age: int) -> str:。 list[int]、dict[str, int]在 Python 3.9+ 可直接用内建泛型;3.8 及以前要from typing import List。- 可空:
Optional[str]等价于str | None(3.10+);后者更简洁。 - 默认值与可空配合:
def f(x: int = 0)或def f(x: str | None = None)。 - 注解存在
__annotations__里,运行时不检查;要强制校验用 Pydantic(阶段 4)。
最小可运行示例:
def greet(name: str, age: int | None = None) -> str:
if age is None:
return f"你好,{name}"
return f"你好,{name},今年 {age} 岁"
def aggregate(items: list[int]) -> dict[str, int]:
return {"count": len(items), "sum": sum(items)}
# 即使传错类型,运行时也不报错,mypy 才会拦
greet(123) # mypy 报错:Argument 1 to "greet" has incompatible type "int"; expected "str"
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 传错类型运行时不报错 | 注解默认不参与运行时检查 | 用 mypy 静态检查;或 Pydantic 做运行时校验 |
Optional[X] 与 X | None 关系 |
二者等价 | 新项目统一用 X | None |
list 不参数化被 mypy 警告 |
用了裸 list 而非 list[int] |
写全泛型参数 |
面试考法:常问「类型注解在 Python 里是强制的吗」。答「默认不是,只是元数据;运行时由 mypy、Pydantic 等工具消费」。追问「Optional[X] 和 X | None 的关系」,答等价。
5.2 Protocol、TypedDict 与泛型
为什么需要它:鸭子类型在动态语言里灵活,但静态检查时不知道对象有没有某个方法。Protocol 用类型注解表达「结构子类型」——只要方法签名匹配,不需要显式继承。TypedDict 让字典有结构约束,替代松散的 dict[str, Any]。
核心机制:
class Animal(Protocol): def speak(self) -> str: ...:任何实现了speak()的类都自动满足Animal,无需继承。@dataclass或TypedDict:class UserDict(TypedDict): name: str; age: int,描述字典键值类型。- 泛型:
T = TypeVar("T"); def first(items: list[T]) -> T:,函数参数化类型。 Generic[T]:类级泛型,class Repository(Generic[T]): ...。
最小可运行示例:
from typing import Protocol
# 结构子类型:Cat 与 Dog 不需要继承 Animal
class Animal(Protocol):
def speak(self) -> str: ...
class Cat:
def speak(self) -> str:
return "meow"
class Dog:
def speak(self) -> str:
return "woof"
def make_sound(animal: Animal) -> str:
return animal.speak()
make_sound(Cat()) # OK
make_sound(Dog()) # OK
# TypedDict
from typing import TypedDict
class UserDict(TypedDict):
name: str
age: int
def greet_user(u: UserDict) -> str:
return f"你好,{u['name']}"
greet_user({"name": "Ann", "age": 30}) # OK
# greet_user({"name": "Ann"}) # mypy 报错:缺少 age
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 不继承 Protocol 却通不过 mypy | 方法签名不完全匹配 | 核对方法名、参数、返回值类型 |
TypedDict 字段缺了运行时不报错 |
同注解一样,运行时不检查 | mypy 检查;运行时用 Pydantic 模型 |
泛型函数返回 Any |
没用 TypeVar 参数化 | 用 T = TypeVar("T") 并标注 -> T |
面试考法:常问「Protocol 和继承的区别」。答「继承是名义子类型,必须显式声明;Protocol 是结构子类型,方法签名匹配即视为实现,解耦了调用方与实现方」。
5.3 迭代器与可迭代对象协议
为什么需要它:for x in items 背后是迭代器协议。理解它,才能写「能被 for 循环消费」的自定义对象,也才能理解为什么生成器、文件对象、数据库游标都是可迭代的。
核心机制:
- 可迭代对象(Iterable):实现
__iter__(),返回一个迭代器。 - 迭代器(Iterator):实现
__iter__()(返回 self)与__next__(),返回下一个元素,耗尽时抛StopIteration。 for x in obj等价于:it = iter(obj); while True: try: x = next(it)捕获StopIteration。- 迭代器是一次性的:遍历一次后指针到末尾,再遍历没数据。
最小可运行示例:
class CountDown:
def __init__(self, start: int):
self.current = start
def __iter__(self):
return self # 自身是迭代器
def __next__(self) -> int:
if self.current <= 0:
raise StopIteration
self.current -= 1
return self.current + 1
for n in CountDown(3):
print(n) # 3 2 1
# 迭代器一次性:再遍历一次没数据
cd = CountDown(2)
print(list(cd)) # [2, 1]
print(list(cd)) # []:耗尽了
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
自定义对象 for 报错 TypeError: object is not iterable |
没实现 __iter__ |
实现 __iter__ 返回迭代器 |
| 迭代器遍历一次后为空 | 迭代器协议本身一次性 | 需要重复遍历就返回新迭代器,或用 list 物化 |
面试考法:常问「可迭代对象和迭代器的区别」。答「可迭代对象实现 __iter__ 返回迭代器;迭代器实现 __next__,是一次性的指针」。
5.4 生成器与 yield
为什么需要它:生成器用 yield 惰性产出数据,不用一次性把整个列表装进内存。读大文件、处理流式数据、生成序列,都靠它。
核心机制:
def gen(): yield 1; yield 2调用后返回生成器对象,不执行函数体;next(gen)才执行到下一个yield。yield from subgen委托给子生成器,逐个产出。- 生成器是迭代器,一次性耗尽;适合「读一行处理一行」的场景。
- 内存占用恒定:生成器对象本身很小,不随产出数量增长。
最小可运行示例:
# 大文件按行读取,内存不随文件大小增长
def read_lines(path: str):
with open(path, encoding="utf-8") as f:
for line in f:
yield line.strip()
# 调用方逐行消费
for line in read_lines("big.log"):
if "ERROR" in line:
print(line)
# 生成器表达式:列表推导的惰性版本
squares = (x * x for x in range(1_000_000))
# list(squares) 才会真的计算;next(squares) 取一个
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 生成器遍历一次后为空 | 一次性协议 | 需要多次用 list 物化,或每次重新调用生成器函数 |
以为 gen() 立即执行函数体 |
函数体在第一次 next 时才执行 |
在 next/for 时观察副作用 |
生成器里 return 的值拿不到 |
return 只用于提前结束,值在 StopIteration.value 里 |
不需要返回值时用 return 结束 |
面试考法:常问「生成器和列表的区别」。答「列表一次性物化占内存;生成器惰性产出,内存恒定,但只能遍历一次」。追问「什么时候必须用生成器」,答大文件、流式数据、无限序列。
5.5 装饰器与 functools.wraps
为什么需要它:装饰器是 Python 在不改原函数代码的前提下加行为的标准方式——缓存、日志、计时、权限、路由注册全靠它。但不写 functools.wraps,函数名与文档会丢失,FastAPI 路由文档、pytest 测试名都会异常。
核心机制:
- 装饰器是一个接收函数、返回新函数的可调用对象;
@deco写在def f上等价于f = deco(f)。 - 无参装饰器:
def deco(f): def wrapper(*a, **kw): ...; return wrapper。 - 带参装饰器:外层接收参数,中层接收函数,内层是包装函数。
functools.wraps(f)把原函数的__name__、__doc__、__wrapped__复制到 wrapper。- 多个装饰器叠加时,执行顺序是「最靠近函数的先执行包装」:
@deco1在上、@deco2在下,调用顺序是deco1(deco2(f))。
最小可运行示例:
import time
from functools import wraps
def timer(func):
@wraps(func) # 保留原函数元信息
def wrapper(*args, **kwargs):
start = time.perf_counter()
try:
return func(*args, **kwargs)
finally:
cost = time.perf_counter() - start
print(f"{func.__name__} 耗时 {cost:.4f}s")
return wrapper
def retry(times: int = 3):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
last = None
for i in range(times):
try:
return func(*args, **kwargs)
except Exception as e:
last = e
print(f"第 {i+1} 次失败:{e}")
raise last
return wrapper
return decorator
@timer
@retry(times=2)
def call_api(url: str) -> str:
if not url:
raise ValueError("url 为空")
return "ok"
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
装饰后 f.__name__ 变成 wrapper |
没写 @wraps(func) |
在 wrapper 上 @wraps(func) |
| 多个装饰器顺序搞反 | 不理解叠加方向 | 记住「下在上之前执行包装」,调用时从上到下进入 |
带参装饰器 @retry 直接用报错 |
带参装饰器必须加括号 @retry(times=3) |
调用外层工厂 |
面试考法:常问「写一个装饰器统计函数执行时间」。要答到 *args, **kwargs、functools.wraps、try/finally。追问「装饰器何时执行」,答「函数定义时执行一次,返回 wrapper;调用时执行 wrapper」。
5.6 上下文管理器与 contextlib
为什么需要它:with open(...) as f 自动关闭文件、自动释放锁。不理解 __enter__/__exit__,就无法写出「异常发生也释放资源」的自定义管理器。
核心机制:
- 上下文管理器协议:
__enter__返回资源对象,__exit__做清理;异常发生时__exit__仍被调用,参数携带异常信息。 @contextlib.contextmanager:用生成器写上下文管理器,yield之前是__enter__,之后是__exit__。- 异步上下文管理器
async with在阶段 6 展开,这里只掌握同步版。
最小可运行示例:
from contextlib import contextmanager
@contextmanager
def timer(label: str):
start = time.perf_counter()
try:
yield
finally:
cost = time.perf_counter() - start
print(f"{label} 耗时 {cost:.4f}s")
with timer("读文件"):
data = open("a.txt", encoding="utf-8").read()
# 类式上下文管理器
class Transaction:
def __init__(self, conn):
self.conn = conn
def __enter__(self):
print("BEGIN")
return self.conn
def __exit__(self, exc_type, exc, tb):
if exc_type is None:
print("COMMIT")
else:
print(f"ROLLBACK:{exc}")
return False # 不吞异常
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 异常时清理逻辑没执行 | 把清理写在 yield 之后但没用 try/finally |
用 try: yield finally: ... |
__exit__ 返回 True 后异常被吞 |
返回 True 表示处理了异常 | 不吞异常返回 False 或 None |
面试考法:常问「with 背后做了什么」。答「进入时调用 __enter__,退出时(含异常)调用 __exit__」。追问「为什么数据库事务用上下文管理器合适」,答异常时自动 ROLLBACK、正常时 COMMIT。
5.7 dataclass 与标准库工具
为什么需要它:写一个数据类要手写 __init__、__repr__、__eq__,样板代码重复且容易漏。@dataclass 自动生成这些方法,同时保留类型注解。
核心机制:
@dataclass:根据注解自动生成__init__、__repr__、__eq__。field(default=...)与field(default_factory=list):可变默认值必须用default_factory,避免阶段 1 的默认可变参数陷阱。frozen=True:生成不可变类,可做 hash。- 与 Pydantic 模型的区别:dataclass 不做运行时校验,Pydantic 做(阶段 4)。
最小可运行示例:
from dataclasses import dataclass, field
@dataclass
class User:
name: str
age: int = 0
tags: list[str] = field(default_factory=list)
u = User(name="Ann", age=30, tags=["admin"])
print(u) # User(name='Ann', age=30, tags=['admin'])
u2 = User(name="Ann", age=30, tags=["admin"])
print(u == u2) # True:自动生成 __eq__
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
ValueError: mutable default ... |
直接写 tags: list = [] |
用 field(default_factory=list) |
| dataclass 字段缺了运行时不报错 | 不做运行时校验 | 用 Pydantic 模型 |
面试考法:常问「dataclass 和普通类的区别」。答「自动生成样板方法,字段由类型注解声明;不做运行时校验」。
六、分层练习
6.1 复现型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 类型注解函数 | 为阶段 1 的 CLI 脚本补全注解 | mypy 默认配置通过 | 1 小时 |
| 生成器读大文件 | 用 yield 按行读取大文件 |
内存占用稳定,不随文件大小增长 | 1 小时 |
| 带参装饰器 | 写 @retry(times=3) 装饰器 |
失败自动重试,@wraps 保留元信息 |
2 小时 |
| 上下文管理器 | 用 @contextmanager 写计时上下文 |
异常时仍打印耗时 | 1 小时 |
| dataclass | 把 User 类改成 dataclass | 自动生成 __repr__ 与 __eq__ |
0.5 小时 |
6.2 改造型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 修装饰器丢元信息 | 给定没写 @wraps 的装饰器 |
装饰后 f.__name__ 正确 |
0.5 小时 |
| 修生成器耗尽 | 给定「二次遍历为空」的代码 | 改成可重复遍历 | 1 小时 |
| 引入 Protocol | 把一个依赖具体类的函数改成依赖 Protocol | 新增类无需修改函数即通过 | 1.5 小时 |
| TypedDict 替换松散 dict | 把 dict[str, Any] 参数改成 TypedDict |
mypy 能检查字段缺失 | 1 小时 |
6.3 设计型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 流式日志分析器 | 用生成器逐行读日志,过滤 ERROR 并统计 | 内存恒定;能输出错误数 | 3 小时 |
| 重试装饰器库 | 支持 times、backoff、可指定异常类型 |
单元测试覆盖成功与失败路径 | 4 小时 |
| 数据结构重构 | 把阶段 1 待办列表的 dict 改成 dataclass | 代码更清晰,注解完整 | 2 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
| 传错类型运行时不报错 | 注解不参与运行时检查 | 跑 mypy |
用 mypy 或 Pydantic |
f.__name__ 变成 wrapper |
装饰器没写 @wraps |
打印 f.__name__ |
加 @functools.wraps(func) |
| 生成器二次遍历为空 | 一次性协议 | 重新调用生成器函数 | 物化 list 或每次新建 |
TypeError: object is not iterable |
自定义对象没实现 __iter__ |
看类定义 | 实现 __iter__ 返回迭代器 |
| 上下文管理器异常时清理不执行 | 没用 try/finally |
在 yield 处打断点 |
用 try: yield finally: 清理 |
@dataclass 报 mutable default |
直接写 = [] |
看字段定义 | 用 field(default_factory=list) |
TypeError: __init__() takes ... positional arguments |
泛型参数写错 | 看类签名 | 核对 TypeVar 与 Generic 用法 |
八、出口条件
全部勾选后再进入 08.4 阶段 3:环境依赖与质量工具链。
- [ ] 能为函数与类写完整类型注解,说清
Optional[X]与X | None的等价关系 - [ ] 能定义
Protocol表达结构子类型,用TypedDict描述字典结构 - [ ] 能写生成器处理大文件,证明内存不随文件大小增长
- [ ] 能写带参装饰器并用
functools.wraps保留元信息 - [ ] 能用
@contextmanager或类式上下文管理器封装资源 - [ ] 能用
@dataclass自动生成样板方法,正确使用field(default_factory=...) - [ ] 能说清迭代器协议与一次性耗尽的原因
自测题(先自己想,再看要点):
- 类型注解在 Python 里是运行时强制校验吗?
- 要点:不是,默认只是元数据;运行时校验由 Pydantic 等工具完成,静态检查由 mypy 完成。
Optional[X]与X | None的关系?- 要点:等价;新项目推荐
X | None(Python 3.10+)。
- 要点:等价;新项目推荐
- 生成器为什么二次遍历为空?
- 要点:迭代器协议一次性,
__next__耗尽后持续抛StopIteration。
- 要点:迭代器协议一次性,
- 装饰器不写
@functools.wraps会出什么问题?- 要点:
__name__、__doc__、__wrapped__丢失,影响路由文档、调试、测试名。
- 要点:
Protocol与显式继承的区别?- 要点:Protocol 是结构子类型,方法签名匹配即实现,无需显式继承;继承是名义子类型。
with语句在异常发生时会做什么?- 要点:
__exit__仍被调用,参数携带异常信息;返回 False/None 不吞异常。
- 要点:
@dataclass里可变默认值为什么必须用default_factory?- 要点:直接写
= []会在所有实例间共享同一个 list(阶段 1 的默认可变参数陷阱)。
- 要点:直接写