罗罗编程学习记录
本页内容 展开查看

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=...)
  • [ ] 能说清迭代器协议与一次性耗尽的原因

自测题(先自己想,再看要点):

  1. 类型注解在 Python 里是运行时强制校验吗?
    • 要点:不是,默认只是元数据;运行时校验由 Pydantic 等工具完成,静态检查由 mypy 完成。
  2. Optional[X] 与 X | None 的关系?
    • 要点:等价;新项目推荐 X | None(Python 3.10+)。
  3. 生成器为什么二次遍历为空?
    • 要点:迭代器协议一次性,__next__ 耗尽后持续抛 StopIteration。
  4. 装饰器不写 @functools.wraps 会出什么问题?
    • 要点:__name__、__doc__、__wrapped__ 丢失,影响路由文档、调试、测试名。
  5. Protocol 与显式继承的区别?
    • 要点:Protocol 是结构子类型,方法签名匹配即实现,无需显式继承;继承是名义子类型。
  6. with 语句在异常发生时会做什么?
    • 要点:__exit__ 仍被调用,参数携带异常信息;返回 False/None 不吞异常。
  7. @dataclass 里可变默认值为什么必须用 default_factory?
    • 要点:直接写 = [] 会在所有实例间共享同一个 list(阶段 1 的默认可变参数陷阱)。