08.2 阶段 1:语言核心
所属:全栈开发面试题库 / 学习路径 / 08 Python 全栈
本页目录
一、阶段定位
阶段 0 只解决「脚本能在命令行跑起来」,本阶段开始真正进入 Python 的对象模型:变量是贴标签、对象在堆上、赋值只是引用、可变对象会在调用方之外被悄悄改掉。不把这套语义吃透,后面写函数会反复踩「默认参数共享状态」「闭包延迟绑定」「浅拷贝嵌套对象」三类坑,阶段 3 接类型注解、阶段 4 写 ORM 时也无法理解 Session 为什么不能跨请求复用。
与前后阶段的衔接:往下接阶段 2 的类型注解与现代特性(生成器、装饰器、上下文管理器),那时讨论的不再是「对象怎么传」,而是「函数与类如何带契约、如何惰性产出」。本阶段把异常体系讲透,阶段 4 写 FastAPI 异常处理器、阶段 5 写事务回滚时才有抓手。
原有卡点及判断依据:
- 默认可变参数在多次调用间共享状态:判断现象是写一个
def f(x=[]),连续调用两次后打印出[1, 1]之类累积结果。原因是默认参数在函数定义时只求值一次,见 5.4。 - 把可变对象改不改动与引用拷贝混为一谈:判断现象是函数里
append了入参,外部看到了变化,却以为「传参是值传递」。要答到「传参是传对象引用,改不改得动取决于对象是否可变」,见 5.1。 - 闭包延迟绑定导致循环内取值错误:判断现象是循环里定义一组 lambda,调用后全部拿到同一个值。原因是闭包捕获的是变量本身,不是定义时的值,见 5.3。
- 循环导入互相引用导致启动失败:判断现象是
ImportError: cannot import name 'X' from partially initialized module,常发生在两个模块互相 import 时。见 5.7。
二、阶段目标与投入
学完本页,应当能用可观察的行为证明以下六条能力:
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
| 能解释赋值、传参、返回值都是传引用,并区分浅拷贝与深拷贝 | 写一个函数修改嵌套 list,外部数据变化,用 copy.deepcopy 后不再变化 |
能区分 == 与 is,说清小整数与字符串驻留现象 |
对 a = [1]; b = [1] 判断 a == b 与 a is b 结果并解释 |
| 能写出带闭包的计数器,并修复循环内 lambda 延迟绑定问题 | 连续调用 inc() 得到递增结果;循环生成的函数列表各自返回正确值 |
| 能正确使用默认参数,避免可变默认参数陷阱 | 把 def f(items=[]) 改成 def f(items=None) 并通过测试 |
| 能按业务定义自定义异常并正确传播,区分编程错误与业务异常 | 非法输入抛出 ValueError 子类,外层用 except 精确捕获 |
| 能定位并修复循环导入,理解模块缓存 | 复现 partially initialized module 报错并用重构解法 |
建议学时:
- 全职(每天有效学习 4–6 小时):2 周,约 60 小时。其中读文档与看源码 15 小时、写代码 35 小时、复盘 10 小时。
- 在职(每天 2 小时、周末补 4 小时):5–6 周,约 70 小时。
学时分配建议:可变对象与引用 20%、容器与相等判断 15%、作用域与闭包 15%、函数与参数 15%、类与 MRO 15%、异常 10%、模块与循环导入 10%。闭包、MRO、异常链是面试高频重灾区,时间要给够。
三、先修自检
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| 命令行运行 Python | 能 python script.py 跑通脚本 |
08.1 阶段 0 |
| 虚拟环境可用 | 项目依赖装在 .venv 里 |
08.1 阶段 0 |
| 基础数据类型 | 知道 int、str、list、dict 的基本用法 |
补 30 分钟入门教程 |
| 编辑器与调试 | 能打断点看变量值 | VS Code Python 调试配置 |
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| 对象模型 | 可变/不可变对象、赋值即引用、浅拷贝与深拷贝 | 能讲清原理 | 04.7 Python |
| 容器与相等 | list/dict/set/tuple、== 与 is、hash/eq 契约 |
能讲清原理 | 04.7 Python |
| 作用域与闭包 | LEGB、闭包、延迟绑定、nonlocal |
能讲清原理 | 04.7 Python |
| 函数与参数 | 位置/关键字/*args/**kwargs、默认参数陷阱 |
会用 | 04.7 Python |
| 面向对象 | 类、实例、继承、MRO、super()、魔术方法 |
能讲清原理 | 04.7 Python |
| 异常 | 异常层次、try/except/else/finally、自定义异常、异常链 |
会用 | 04.7 Python |
| 模块与包 | import 机制、模块缓存、相对导入、循环导入 | 会用 | 04.7 Python |
进度管理建议:把这张表复制到笔记里,每学完一个模块把掌握程度往下调一档。《知识点全清单》里「语言核心」段是本阶段的全量打勾表。
五、分模块精讲
5.1 可变与不可变对象、引用与拷贝
为什么需要它:Python 里变量不是盒子,是标签;对象在堆上,赋值只是多贴一个标签。不理解这点,函数里 append 一个入参,外部数据被悄悄改了,就会以为「传参有 bug」。
核心机制:
- 不可变对象:
int、float、str、tuple、frozenset。对它做「修改」会产生新对象。 - 可变对象:
list、dict、set、自定义类实例。在原对象上原地修改,所有引用它的变量都能看到。 - 赋值
b = a不拷贝,只是多一个引用;a is b为True。 - 浅拷贝
copy.copy/list(a)/a[:]:复制外层容器,内层元素仍共享。 - 深拷贝
copy.deepcopy(a):递归复制整个对象树。
最小可运行示例:
# 不可变对象:i 自增后产生新对象
i = 1
j = i
i += 1
print(i, j) # 2 1,j 不受影响
# 可变对象:append 改的是原对象
def append_tail(items: list) -> None:
items.append(99)
data = [1, 2, 3]
append_tail(data)
print(data) # [1, 2, 3, 99]:外部被改了
# 浅拷贝与深拷贝
import copy
matrix = [[1, 2], [3, 4]]
shallow = matrix.copy()
deep = copy.deepcopy(matrix)
shallow[0][0] = 99
print(matrix[0][0]) # 99:浅拷贝内层共享,matrix 被改
print(deep[0][0]) # 1:深拷贝完全独立
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 函数改了入参,外部数据变了 | 传的是可变对象引用 | 需要隔离时在函数内 copy.deepcopy 或入参先拷贝 |
| 浅拷贝后内层元素仍共享 | 浅拷贝只复制外层 | 嵌套结构必须用 deepcopy |
tuple 里装 list,修改 list 后 tuple 也变了 |
tuple 不可变只约束自身引用,不约束内层 | 把 tuple 当不可变要小心嵌套可变对象 |
面试考法:高频题「Python 是值传递还是引用传递」。标准答法:「既不是值传递也不是纯引用传递,是传对象引用(pass-by-object-reference);函数收到的是对象引用,对不可变对象重新绑定局部变量不影响外部,对可变对象原地修改会影响外部」。追问常给一段代码问输出。
5.2 内建容器与相等判断(== 与 is)
为什么需要它:== 比的是值,is 比的是身份(内存地址)。把 is 当 == 用,判断 if x == None 时会写出 if x is None——这个是对的,但判断 if a == b 时写 if a is b 就会因为驻留规则踩坑。
核心机制:
==调用对象的__eq__,默认对自定义类比较身份;对内建类型按值比较。is比较两个引用是否指向同一对象,等价于id(a) == id(b)。- 小整数驻留:CPython 预创建
-5到256的整数对象,a = 1; b = 1; a is b为True。 - 短字符串驻留:符合标识符规则的短字符串会被 intern,但这是实现细节,不能依赖。
- 自定义对象要做 dict key 或 set 元素,必须同时定义
__eq__与__hash__,且相等对象 hash 必须相等。
最小可运行示例:
a = [1, 2]
b = [1, 2]
print(a == b) # True:值相等
print(a is b) # False:不同对象
# 小整数驻留
x = 256
y = 256
print(x is y) # True
x = 257
y = 257
print(x is y) # CPython 交互中可能 False(不跨驻留),不要依赖
# 判断 None 必须用 is
value = None
if value is None:
print("空")
# 自定义相等与 hash
class User:
def __init__(self, uid: int):
self.uid = uid
def __eq__(self, other: object) -> bool:
return isinstance(other, User) and self.uid == other.uid
def __hash__(self) -> int:
return hash(self.uid)
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
a is b 在某些版本为 True、某些为 False |
依赖驻留实现细节 | 比较值用 ==,比较 None 用 is |
| 自定义对象加入 set 后重复出现 | 只定义了 __eq__ 没定义 __hash__ |
同时定义 __hash__,返回相等对象的相同 hash |
== 比较两个 None 报错 |
自定义类 __eq__ 没处理 other 类型 |
isinstance(other, Self) 先判断 |
面试考法:常问「== 和 is 的区别」。答「== 比值,is 比身份;判断 None、单例用 is,其余一律 ==」。追问会到「为什么判断 None 推荐用 is」,因为 None 是单例,is 更快且不会被 __eq__ 重写影响。
5.3 作用域、LEGB 与闭包
为什么需要它:变量查找顺序、闭包怎么捕获变量,决定了装饰器、回调、工厂函数的写法。不理解延迟绑定,循环里写 lambda 会得到一组「全部指向最后一个值」的函数。
核心机制:
- LEGB 查找顺序:Local(局部)、Enclosing(外层函数)、Global(模块)、Built-in(内建)。
- 函数内对变量赋值会创建局部变量,除非用
global或nonlocal声明。 - 闭包:内层函数引用外层函数的变量,外层函数返回后这些变量仍被持有。
- 延迟绑定:闭包捕获的是变量本身,不是定义时的值;在循环中创建多个闭包,它们共享同一个变量,最终都取循环结束时的值。
nonlocal声明用于修改外层函数的变量;global用于修改模块级变量。
最小可运行示例:
# 闭包计数器
def make_counter():
count = 0
def inc():
nonlocal count
count += 1
return count
return inc
counter = make_counter()
print(counter(), counter(), counter()) # 1 2 3
# 延迟绑定陷阱:循环里定义 lambda
funcs = []
for i in range(3):
funcs.append(lambda: i)
print([f() for f in funcs]) # [2, 2, 2]:全部取最后一个值
# 修法:用默认参数在定义时绑定值
funcs = [lambda i=i: i for i in range(3)]
print([f() for f in funcs]) # [0, 1, 2]
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 循环里 lambda 全部返回同一个值 | 延迟绑定共享变量 | 用 lambda i=i: i 默认参数捕获当前值 |
UnboundLocalError: local variable referenced before assignment |
函数内对同名变量赋值,Python 把它当局部变量 | 在读之前赋值,或用 nonlocal/global |
| 计数器不递增 | 没写 nonlocal,count += 1 报错或创建局部变量 |
外层可变变量用 nonlocal |
面试考法:常问「闭包是什么、为什么返回后还能访问外层变量」。答「内层函数持有外层函数作用域的引用,形成 closure;外层函数栈帧虽然销毁,但 closure 对象引用的变量不会被回收」。追问「循环里闭包为什么全是最后一个值」,答延迟绑定。
5.4 函数参数与默认可变参数陷阱
为什么需要它:函数签名是接口契约。位置参数、关键字参数、*args、**kwargs 的写法直接决定调用方怎么传;默认可变参数是 Python 最经典的坑。
核心机制:
- 位置参数按顺序匹配;关键字参数按名字匹配。
*args收集多余位置参数为 tuple;**kwargs收集多余关键字参数为 dict。- 仅关键字参数:在
*之后声明,调用时必须传名字。 - 仅位置参数:在
/之前声明(Python 3.8+)。 - 关键陷阱:默认参数在函数定义时求值一次,不是每次调用时。可变默认参数(list、dict)会在多次调用间共享。
最小可运行示例:
# 默认可变参数陷阱
def append_bad(item, items=[]):
items.append(item)
return items
print(append_bad(1)) # [1]
print(append_bad(2)) # [1, 2]:默认参数被复用了
# 正确写法:用 None 作为哨兵
def append_good(item, items=None):
if items is None:
items = []
items.append(item)
return items
print(append_good(1)) # [1]
print(append_good(2)) # [2]
# 仅关键字参数
def connect(host: str, *, port: int = 80, timeout: float = 5.0):
return f"{host}:{port}"
connect("localhost", port=8080) # 必须传 port=
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 多次调用默认参数累积数据 | 默认参数只在定义时求值一次 | 用 items=None 哨兵,函数内初始化 |
传参时报 takes 1 positional argument but 2 were given |
调用方式与签名不符 | 看签名是位置还是关键字 |
修改 **kwargs 后外层看不到变化 |
kwargs 是 dict 的拷贝 |
需要修改直接改外层 dict 或用可变对象 |
面试考法:必考题「def f(x=[]) 有什么问题」。答「默认 list 在函数定义时创建一次,多次调用共享同一个 list,导致状态累积;修法是 x=None 哨兵,函数内新建 list」。
5.5 类、继承与 MRO
为什么需要它:ORM、异常体系、框架中间件都建立在类与继承之上。MRO 决定多继承时方法的查找顺序,super() 到底调用谁,不搞清楚就会出现「父类方法没被调到」或「被调了两次」。
核心机制:
- 类是对象的模板,实例是类的具体对象;属性存在实例
__dict__,方法存在类上。 - 单继承:子类继承父类属性与方法;
super()调用父类。 - 多继承:子类继承多个父类,方法按 MRO(C3 线性化)顺序查找。
- MRO 用
ClassName.__mro__查看;super()不是「调用父类」,而是「调用 MRO 中的下一个类」。 - 组合优于继承:继承表达「is-a」,组合表达「has-a」。
最小可运行示例:
class Base:
def hello(self):
print("Base.hello")
class A(Base):
def hello(self):
print("A.hello")
super().hello()
class B(Base):
def hello(self):
print("B.hello")
super().hello()
class C(A, B):
def hello(self):
print("C.hello")
super().hello()
print([c.__name__ for c in C.__mro__])
# [C, A, B, Base, object]
C().hello()
# C.hello
# A.hello
# B.hello
# Base.hello
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 多继承中父类方法没调到 | 不知道 MRO 顺序 | 打印 __mro__ 确认;保证每个父类都用 super() |
super() 调用了意外的类 |
以为 super() 就是父类 |
理解 super() 是 MRO 下一个类,不是直接父类 |
__init__ 没被调用 |
子类重写 __init__ 后忘了 super().__init__() |
显式调用 super().__init__(...) |
面试考法:常问「MRO 是什么、super() 调用谁」。答「MRO 是 C3 线性化算法生成的方法解析顺序;super() 在单继承下是父类,在多继承下是 MRO 中的下一个类,不是语法上的父类」。追问会给一个菱形继承图问 super().hello() 的输出。
5.6 异常体系与自定义异常
为什么需要它:异常是函数间错误传递的标准方式。Python 的异常层次、try/except/else/finally 执行顺序、自定义业务异常,决定了「编程错误」与「业务异常」能不能被区分。
核心机制:
- 异常层次:
BaseException是根;Exception是所有常规异常的父类;SystemExit、KeyboardInterrupt继承自BaseException,不要except Exception之外捕获它们。 try/except/else/finally:try抛错进except;没抛错进else;无论是否抛错都进finally。- 自定义异常继承
Exception,按业务语义分层,如PaymentError(BizError)、InsufficientBalanceError(PaymentError)。 - 异常链:
raise NewError(...) from original保留原因,__cause__可查;裸raise在except中重抛保留原栈。 - 不要裸
except:或过宽except Exception:吞掉所有错误。
最小可运行示例:
class BizError(Exception):
"""业务异常基类"""
class InsufficientBalanceError(BizError):
def __init__(self, need: float, have: float):
self.need = need
self.have = have
super().__init__(f"余额不足:需要 {need},当前 {have}")
def withdraw(balance: float, amount: float) -> float:
if amount > balance:
raise InsufficientBalanceError(need=amount, have=balance)
return balance - amount
try:
withdraw(100.0, 200.0)
except InsufficientBalanceError as e:
print(f"捕获到业务异常:{e},缺 {e.need - e.have}")
except Exception:
print("未预期的错误")
raise # 重抛,保留原栈
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
except Exception: 把 KeyboardInterrupt 也吞了 |
写了裸 except: 或过宽捕获 |
只捕获预期异常;需要兜底时 except Exception 后重抛 |
| 异常栈丢失,看不到原始错误 | raise NewError(...) 没写 from original |
用 raise NewError(...) from original 保留异常链 |
finally 里又抛异常 |
finally 中的异常会覆盖 try 中的 |
finally 只做清理,不抛业务异常 |
面试考法:常问「try/except/else/finally 的执行顺序」。答「无异常走 else,有异常走 except,finally 必走;return 也不会跳过 finally」。追问「自定义异常怎么设计」,答「按业务域建基类,具体错误继承,携带结构化字段」。
5.7 模块、包与循环导入
为什么需要它:代码组织成模块与包,import 机制决定了「从哪加载、什么时候加载」。两个模块互相 import 时,启动会得到 partially initialized module 报错。
核心机制:
- 模块:一个
.py文件;包:一个含__init__.py(或命名空间包)的目录。 - import 时执行模块顶层代码一次,结果缓存在
sys.modules;再次 import 直接取缓存。 - 绝对导入:
from package.module import X;相对导入:from .module import X(仅包内可用)。 - 循环导入:A import B,B import A;当 B 在 A 执行完前就尝试从 A 取名字,会报
cannot import name 'X' from partially initialized module 'A'。
最小可运行示例:
# 循环导入复现:a.py
# from b import func_b
#
# x = 1
# def func_a():
# func_b()
#
# b.py
# from a import func_a
#
# def func_b():
# print("b")
# 启动 python a.py 会报:
# ImportError: cannot import name 'func_a' from partially initialized module 'a'
# 修法 1:延迟 import,把 import 放到函数内
# b.py
def func_b():
from a import func_a # 运行时才导入,此时 a 已初始化完成
print("b")
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
ImportError: cannot import name 'X' from partially initialized module |
循环导入 | 延迟 import;把共用代码抽到第三个模块;调整依赖方向 |
ModuleNotFoundError: No module named 'X' |
运行方式不对,cwd 不在 sys.path | 用 python -m package.module 启动 |
| 修改模块代码后 import 还是旧结果 | sys.modules 缓存 |
重启解释器,或用 importlib.reload(仅调试) |
面试考法:常问「循环导入怎么产生、怎么解」。答「两个模块在顶层互相 import;解法有三:延迟 import、抽公共依赖到第三个模块、调整依赖方向让单向依赖」。追问「为什么 python a.py 会触发而 python -m a 不会」,涉及 sys.path 与模块名差异。
六、分层练习
6.1 复现型(照着做)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 可变对象实验 | 写函数修改入参 list,观察外部变化 | 能解释为什么外部被改 | 0.5 小时 |
| 浅拷贝深拷贝 | 对嵌套 list 做浅拷贝与深拷贝,对比修改 | 能说出两者区别 | 0.5 小时 |
| 闭包计数器 | 用 nonlocal 实现递增计数器 |
连续调用结果正确 | 1 小时 |
| 默认可变参数陷阱 | 复现 def f(x=[]) 累积问题并修复 |
修复后多次调用独立 | 0.5 小时 |
| 循环导入复现 | 写两个互相 import 的模块,启动观察报错 | 能说出报错原因 | 1 小时 |
6.2 改造型(给出现成代码改出正确行为)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 修延迟绑定 | 给定循环 lambda 全返回同一值的代码 | 用默认参数修复 | 0.5 小时 |
| 修 MRO 调用 | 给定多继承中父类方法漏调的代码 | 打印 __mro__ 确认后修复 |
1.5 小时 |
| 自定义异常 | 把裸 raise ValueError("余额不足") 改成自定义异常 |
外层精确捕获并打印字段 | 1 小时 |
| 修循环导入 | 用延迟 import 修掉复现的循环导入 | 正常启动 | 1 小时 |
6.3 设计型(自己定方案)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| CSV 统计 CLI | 用阶段 0 的脚本扩展,支持按列聚合、--top N |
非法输入抛自定义异常,命令行友好提示 | 4 小时 |
| 待办列表 | 实现内存待办,支持增删查,错误按业务异常分层 | 重复 ID 抛 DuplicateIdError |
3 小时 |
| 对象模型笔记 | 画出「赋值、传参、浅拷贝、深拷贝」的对象关系图 | 能讲清引用与拷贝的边界 | 2 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
| 函数改了入参外部数据变化 | 传的是可变对象引用 | print(type(items), id(items)) |
函数内拷贝或入参先拷贝 |
UnboundLocalError |
函数内对同名变量赋值被当局部 | 看报错行附近是否有赋值 | 用 nonlocal 或改名 |
TypeError: 'builtin_function_or_method' object is not subscriptable |
把方法当属性调用 | 看变量绑定 | 加括号调用 |
| 循环 lambda 全返回同一值 | 延迟绑定 | 打印 i 在调用时的值 |
用 i=i 默认参数 |
ImportError: cannot import name ... partially initialized |
循环导入 | 看堆栈定位两个互相 import 的模块 | 延迟 import 或抽公共模块 |
__hash__ 报错 unhashable type |
自定义类可变或 __eq__ 定义后 __hash__ 被置 None |
看类是否定义了 __eq__ |
同时定义 __hash__ 并保持相等对象 hash 一致 |
| 异常栈丢失 | 重抛时没写 from |
看 __cause__ 是否为 None |
用 raise New(...) from original |
| 修改代码后 import 还是旧结果 | sys.modules 缓存 |
重启解释器 | 生产环境不依赖 reload |
八、出口条件
全部勾选后再进入 08.3 阶段 2:类型注解与现代特性。
- [ ] 能解释赋值即引用,能区分浅拷贝与深拷贝并说出适用场景
- [ ] 能区分
==与is,说清小整数驻留与 None 判断规范 - [ ] 能写闭包并解释延迟绑定,能修复循环内 lambda 问题
- [ ] 能正确使用默认参数,避免可变默认参数陷阱
- [ ] 能按业务定义自定义异常并保留异常链
- [ ] 能定位循环导入并用延迟 import 或抽模块修复
- [ ] 能说出 MRO 的 C3 线性化与
super()的真实含义
自测题(先自己想,再看要点):
a = [1]; b = a; b.append(2); print(a)输出什么?为什么?- 要点:
[1, 2];b = a是引用赋值,两个变量指向同一 list。
- 要点:
def f(x=[]): x.append(1); return x,连续调用三次f()输出什么?怎么修?- 要点:
[1]、[1, 1]、[1, 1, 1];默认参数只创建一次;修法x=None哨兵。
- 要点:
- 循环里
lambda: i为什么全部返回最后一个值?怎么修?- 要点:闭包延迟绑定捕获变量本身;修法
lambda i=i: i默认参数在定义时绑定。
- 要点:闭包延迟绑定捕获变量本身;修法
==与is的区别?判断 None 应该用哪个?- 要点:
==比值,is比身份;None 用is(单例,不被__eq__影响)。
- 要点:
super()在多继承中调用的是「父类」吗?- 要点:不是,是 MRO 中的下一个类;菱形继承中
super()按 C3 顺序依次调用。
- 要点:不是,是 MRO 中的下一个类;菱形继承中
- 自定义异常为什么要带结构化字段而不是只传消息字符串?
- 要点:字段可被外层程序判断(如
e.need - e.have),消息字符串要解析;异常是接口契约的一部分。
- 要点:字段可被外层程序判断(如
except Exception:为什么被认为是坏习惯?- 要点:会吞掉
KeyboardInterrupt、SystemExit之外的所有错误,包括编程错误;应只捕获预期异常并重抛未预期的。
- 要点:会吞掉