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

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() 的真实含义

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

  1. a = [1]; b = a; b.append(2); print(a) 输出什么?为什么?
    • 要点:[1, 2];b = a 是引用赋值,两个变量指向同一 list。
  2. def f(x=[]): x.append(1); return x,连续调用三次 f() 输出什么?怎么修?
    • 要点:[1]、[1, 1]、[1, 1, 1];默认参数只创建一次;修法 x=None 哨兵。
  3. 循环里 lambda: i 为什么全部返回最后一个值?怎么修?
    • 要点:闭包延迟绑定捕获变量本身;修法 lambda i=i: i 默认参数在定义时绑定。
  4. == 与 is 的区别?判断 None 应该用哪个?
    • 要点:== 比值,is 比身份;None 用 is(单例,不被 __eq__ 影响)。
  5. super() 在多继承中调用的是「父类」吗?
    • 要点:不是,是 MRO 中的下一个类;菱形继承中 super() 按 C3 顺序依次调用。
  6. 自定义异常为什么要带结构化字段而不是只传消息字符串?
    • 要点:字段可被外层程序判断(如 e.need - e.have),消息字符串要解析;异常是接口契约的一部分。
  7. except Exception: 为什么被认为是坏习惯?
    • 要点:会吞掉 KeyboardInterrupt、SystemExit 之外的所有错误,包括编程错误;应只捕获预期异常并重抛未预期的。