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

04.7.1 语言基础与内建类型

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python

覆盖范围

  • 对象模型:可变性、引用、标识、拷贝
  • 内建容器:list、tuple、dict、set 的实现与复杂度
  • 字符串、编码、bytes 与格式化
  • 数值类型、浮点精度与 Decimal
  • 切片、解包、推导式、排序

04.7.1-001 可变对象与不可变对象有什么区别?为什么它决定了大量 Python 行为?

一句话结论

不可变对象创建后内部状态不可改(int、str、tuple、frozenset、bytes),任何“修改”都会产生新对象;可变对象(list、dict、set、bytearray、自定义类实例)可以原地修改。这个区别直接决定了参数传递、默认参数、字典键、线程共享和缓存是否安全。

概念解释

  • 不可变对象可以安全共享:多个变量指向同一个 int/str 不会互相污染,因此适合做字典键、缓存键、跨线程常量。
  • 可变对象被多处引用时是“同一块内存”,任一处修改其他处都能看到,这是浅拷贝、默认参数、类属性三大坑的根源。

原理流程

  1. 不可变对象创建后,内部字段不允许重新绑定;任何“修改”操作都返回一个新对象。
  2. 可变对象在原内存上原地增删改,所有持有该引用的名字都能观察到变化。
  3. 自定义类默认可变;要造不可变类需要 __slots__ + 只读属性 + 重写 __setattr__,或用 @dataclass(frozen=True)。

代码或图示

a = [1, 2]
b = a          # b 与 a 是同一个对象
b.append(3)
print(a)       # [1, 2, 3],a 也被改了

s = "abc"
s2 = s.upper() # 生成新对象,s 仍是 "abc"
print(id(s) == id(s2))  # False

常见误区

  • 不可变 ≠ 深度不可变:tuple 本身不可变,但里面可以装 list,t[0].append(...) 依然生效。
  • “不可变”只约束对象自身,不约束引用:a = (1, [2]); a = (1, [2, 3]) 是换对象,a[1].append(3) 是改内部可变元素。

追问

  • 为什么不可变对象能做 dict 的 key?答:哈希值必须稳定。key 若可变,哈希桶位置会变,字典就再也找不到它;不可变对象保证 hash() 在生命周期内不变。
  • 字符串不可变会不会导致性能问题?答:单次拼接会复制,循环拼接是 O(n²);用 ''.join(list) 或 io.StringIO 把复制次数降到一次。
  • 函数传参是值传递还是引用传递?答:都不是,是“对象引用按值传递”:传进去的是引用的副本,形参重新绑定不影响实参,但修改可变对象的内容会被外部看到。

04.7.1-002 == 和 is 有什么区别?

一句话结论

== 比较值(调用 __eq__),is 比较身份(是否同一块内存,等价于 id(a) == id(b))。判断 None、True、False、单例、哨兵对象用 is,其余用 ==。

概念解释

  • == 是值相等判断,可被类通过 __eq__ 重载;is 是身份判断,比较两个名字是否指向同一个对象。
  • None 是单例,x is None 语义最准确,也比 x == None 快(不触发 __eq__)。

原理流程

  1. is 不可被重载,永远比较 id,O(1)。
  2. == 可以被重载,可能递归比较整个容器,成本随数据量增长。
  3. 自定义类没重写 __eq__ 时,== 退化成 is,容易误判两个内容相同的对象相等。

代码或图示

a = [1, 2]
b = [1, 2]
print(a == b)   # True
print(a is b)   # False

x = 256; y = 256
print(x is y)   # True(小整数缓存,实现细节)

常见误区

  • 小整数(-5~256)、部分字符串、空元组会被缓存/驻留,is 偶尔为 True,这是实现细节,不能当业务判断。
  • float('nan') 自己是自己,nan is nan 为 True,但 nan == nan 为 False。

追问

  • 为什么 a is b 对两个相同字符串有时 True 有时 False?答:编译期常量折叠与驻留(interning)只覆盖一部分场景,运行时拼接的字符串一般不复用。
  • is 能判断两个变量指向同一个可变对象吗?答:能,这正是它最有价值的用法:a is b 为 True 时改 a 就等于改 b。
  • 重写 __eq__ 后为什么必须重写 __hash__?答:默认 __hash__ 会被置为 None 导致不可哈希;且相等对象必须同哈希,否则 set/dict 去重失效。

04.7.1-003 深拷贝和浅拷贝有什么区别?怎么实现?

一句话结论

浅拷贝只复制最外层容器,内部元素仍是原对象的引用;深拷贝递归复制所有层级,得到完全独立的对象图。实现方式:copy.copy() / copy.deepcopy(),或 list.copy()、d.copy()、切片 [:]。

概念解释

  • 浅拷贝产生一个新的外层容器,但容器里装的仍是原对象的引用;深拷贝递归复制每一层,得到互不影响的对象图。

原理流程

  1. deepcopy 用 memo 字典记录已复制对象,能正确处理循环引用;copy 不递归,因此不会陷入死循环。
  2. deepcopy 默认复制一切,但函数、类、模块、文件句柄等会原样返回;可用 __deepcopy__ 自定义。
  3. 类实例默认浅拷贝只复制 __dict__,__slots__ 类需要自己实现 __copy__/__deepcopy__。

代码或图示

import copy
a = [[1, 2], [3, 4]]
b = copy.copy(a)        # 浅拷贝
b[0].append(9)
print(a)                # [[1, 2, 9], [3, 4]]

c = copy.deepcopy(a)    # 深拷贝
c[0].append(8)
print(a)                # 不受影响

常见误区

  • 浅拷贝后修改嵌套元素会互相影响:b = a[:] 之后 b[0].append(1) 也会改到 a[0]。
  • 深拷贝代价高:大对象图会成倍占用内存和 CPU,能靠不可变数据或结构共享就不深拷贝。

追问

  • 不可变对象需要深拷贝吗?答:一般不需要,deepcopy 对 int/str/tuple(元素都不可变)会直接复用原对象。
  • 深拷贝为什么会“卡死”在循环引用上?答:标准 deepcopy 有 memo 表能处理;自己手写递归复制才会栈溢出。
  • 什么时候必须深拷贝?答:需要独立快照(配置回滚、表单初始值、并发任务入参)且对象图里有可变嵌套时。

04.7.1-004 list 和 tuple 有什么区别?怎么选?

一句话结论

list 可变、动态扩容、支持增删改;tuple 不可变、定长、内存更紧凑、创建更快,还能做 dict key 和 set 元素。需要修改用 list,需要“固定记录/常量/哈希键/函数返回多值”用 tuple。

概念解释

  • 语义上:tuple 表达“结构固定的一条记录”,list 表达“同类元素的可变集合”,用错会让代码意图模糊。
  • namedtuple / dataclass 是对“带字段名的 tuple/类”的补充,tuple 适合位置语义。

原理流程

  1. 内存上:tuple 省一个“可扩容”指针与预留空间,元素少时更明显;大量小 tuple 的场景收益可观。
  2. tuple 的不可变是浅层的:内部元素可变仍可改。
  3. 空 tuple () 是单例,tuple() 不会新建对象;tuple([1,2]) 每次新建。

代码或图示

t = (1, 2, 3)
t[0] = 9            # TypeError: 'tuple' object does not support item assignment

d = {(1, 2): "坐标"}  # tuple 可做 key

常见误区

  • 以为 tuple 内部元素也不可改:tuple 的不可变是浅层的,内部元素可变仍可改。
  • 把 (1) 当成 tuple:它是 int;单元素 tuple 必须写 (1,)。

追问

  • 为什么 tuple 能作为 dict key?答:元素都可哈希时 tuple 可哈希,且值不变,哈希稳定。
  • 需要“不可变的列表”怎么办?答:用 tuple 或 frozenset,或在类里暴露只读视图,别只靠约定。
  • (1) 是 tuple 吗?答:不是,是 int;单元素 tuple 必须写 (1,)。

04.7.1-005 dict 的底层是怎么实现的?为什么 3.7 之后“有序”?

一句话结论

dict 是哈希表:用 hash(key) 定位槽位,冲突用开放寻址(探测)解决,而不是链地址法。CPython 3.6 起改成“紧凑字典”:一个稀疏索引数组 + 一个按插入顺序排列的 entries 数组,entries 顺序天然就是插入顺序,3.7 起把这作为语言保证。

概念解释

  • 查找平均 O(1),最坏 O(n);key 必须可哈希,且 __eq__ 与 __hash__ 必须一致。
  • 紧凑布局让内存占用下降约 20%~30%,遍历也更快(entries 连续)。

原理流程

  1. 写入时按 hash(key) 定位索引数组,再在 entries 数组末尾追加键值对。
  2. 负载因子约 2/3,超过阈值触发扩容(容量大致翻倍并重新分布),扩容是一次 O(n) 的重建。
  3. 删除是“标记为 dummy”而不是立刻压缩,大量增删后会出现 dummy 堆积,必要时重建 dict。

代码或图示

d = {"b": 1, "a": 2}
print(list(d))          # ['b', 'a'],插入顺序
print(dict(sorted(d.items())))  # 按 key 排序的新 dict

常见误区

  • 3.7+ 的“有序”是插入顺序,不是排序顺序;要排序用 sorted(d.items())。
  • 以为 dict 元素删除后空间立刻回收:删除只标记 dummy,空间不会立刻压缩。

追问

  • 为什么要求 key 可哈希?答:哈希表靠哈希值定位桶,不可哈希就无法算出稳定位置。
  • 自定义对象做 key 要注意什么?答:同时实现 __hash__ 与 __eq__,且参与哈希的字段不可变;否则会出现“存进去取不出”。
  • dict 占内存为什么比 list 大?答:每个 entry 要存 hash、key 指针、value 指针,还有稀疏索引的空槽。

04.7.1-006 为什么函数默认参数不要用可变对象?

一句话结论

默认参数在函数定义时只求值一次,并绑定在 __defaults__ 上;如果默认值是 list/dict/set,所有调用共享同一个对象,一次修改会污染后续所有调用。

概念解释

  • 典型现象:def f(x, acc=[]),第一次 f(1) 后 acc 永久带着 1。
  • 不可变默认值(int、str、tuple、None、frozenset)是安全的。

原理流程

  1. 执行 def 语句时,默认参数表达式求值一次,结果对象挂到函数的 __defaults__ 上。
  2. 每次调用不传参时,都复用这同一个对象;对可变对象做原地修改,状态会跨调用累积。
  3. 正确写法:默认值用 None 作哨兵,函数体内 if acc is None: acc = []。

代码或图示

def bad(item, bucket=[]):
    bucket.append(item)
    return bucket

print(bad(1))   # [1]
print(bad(2))   # [1, 2],污染了上一次的结果

def good(item, bucket=None):
    if bucket is None:
        bucket = []
    bucket.append(item)
    return bucket

常见误区

  • 同理适用于 dict、set、自定义可变实例、datetime.now() 这类“希望每次求值”的表达式。
  • 若确实想复用缓存,那属于有意的状态设计,应改用类属性或闭包变量并显式说明。

追问

  • 默认值什么时候求值?答:执行 def 语句时(模块导入/函数定义那一刻),不是每次调用。
  • 为什么 def f(t=datetime.now()) 也错?答:时间被冻结在定义那一刻,所有调用拿到同一时间。
  • 有没有工具能提前发现?答:ruff 的 B006、flake8-bugbear 能静态检查出可变默认参数。

04.7.1-007 字符串为什么不可变?大量拼接为什么慢?

一句话结论

str 不可变保证哈希稳定(可做 dict key)、可安全共享、切片可零拷贝视图式返回;代价是“修改”必须新建对象。循环 s += x 每次都可能复制整个前缀,复杂度 O(n²);应改用 ''.join(parts)、io.StringIO 或 f-string 一次性构造。

概念解释

  • 不可变让 str 可以安全共享、哈希稳定,也便于解释器做驻留与切片优化。
  • 需要“可修改的字符串”用 bytearray(字节)或 list[str] 累积后 join。

原理流程

  1. CPython 对 s += x 有一条就地优化:当引用计数为 1 且可扩容时会尝试原地扩展,但只在特定条件下生效,不能依赖。
  2. join 先算总长度再一次性分配,把 n 次复制变成 1 次,是拼接列表的标准写法。
  3. 格式化用 f-string:编译期转成 FORMAT_VALUE 指令,比 % 和 .format() 快,且可读性好。
  4. 大文本处理优先流式(逐行/分块),避免把整个文件读成一个大字符串再做替换。

代码或图示

parts = []
for i in range(10000):
    parts.append(str(i))
text = "".join(parts)      # O(n)

# 反例
# text = ""
# for i in range(10000):
#     text += str(i)       # 可能退化为 O(n²)

常见误区

  • 依赖 s += x 的就地优化:该优化只在引用计数为 1 等特定条件下生效,不能当作通用保证。
  • 把整个文件读成一个大字符串再做替换:大文本应流式逐行/分块处理。

追问

  • 为什么 join 要求元素都是 str?答:它按长度预分配一块连续内存并逐段拷贝,混入非 str 会破坏长度计算,故直接报 TypeError。
  • str 是不可变,那 bytearray 有什么不同?答:bytearray 是可变字节序列,支持原地追加与切片赋值,适合二进制缓冲。
  • 什么时候该用 io.StringIO?答:需要在多个函数间增量写入再统一取值时,它内部是分块缓冲,避免反复复制。

04.7.1-008 f-string 和 %、str.format 有什么区别?

一句话结论

f-string 是语法级格式化:表达式在编译期转成字节码指令,运行时直接取值拼接,速度最快、可读性最好;% 是 C 风格老写法,str.format 支持位置/名称占位但解析在运行时,更慢也更啰嗦。

概念解释

  • f-string 支持任意表达式、格式说明符({x:.2f}、{d:%Y-%m-%d})、调试写法 {x=}(3.8+)、嵌套引号(3.12 放宽)。
  • str.format 的优点是模板可以存成字符串复用(如配置文件、i18n)。

原理流程

  1. f-string 在编译期把占位表达式转成字节码指令,运行时直接取值并按格式说明符输出。
  2. % 只支持有限的类型转换,元组参数容易出错(单元素要写 (x,))。
  3. 三者都受 __format__ 协议控制,自定义类可实现它以统一输出格式。

代码或图示

name, score = "Ann", 91.5
print(f"{name} 得分 {score:.1f}")       # Ann 得分 91.5
print(f"{score=}")                       # score=91.5
print("%s 得分 %.1f" % (name, score))
print("{} 得分 {:.1f}".format(name, score))

常见误区

  • 日志场景不要用 f-string 拼好再传 logger.info,应传模板 + 参数(logger.info("x=%s", x)),否则未开启的日志级别也会付出格式化成本。
  • 把用户输入模板交给 f-string 动态构造:f-string 会执行表达式,等于代码注入风险。

追问

  • 为什么 f-string 在循环里也更省?答:它把拼接逻辑编译成指令序列,省掉运行时解析模板与多次函数调用。
  • f-string 有什么安全风险?答:它会执行表达式;若模板来自用户输入再 eval/动态构造,等于代码注入。
  • 日志为什么用 %s 占位而不是 f-string?答:延迟格式化:只有该级别开启时才执行字符串构造。

04.7.1-009 什么是小整数缓存和字符串驻留?为什么会踩坑?

一句话结论

CPython 预先创建 -5~256 的整数对象复用;字符串在编译期常量、标识符、部分短字符串会被驻留(intern)共享同一对象。因此 is 判断在这里可能“碰巧”为 True,但这是实现细节,不是语言保证。

概念解释

  • 小整数缓存范围为 -5 到 256,超出范围每次运算都可能新建对象。
  • 同一作用域内的字面量常量会被编译器合并(常量折叠),如两个 "abc" 指向同一对象。

原理流程

  1. 解释器启动时创建并复用 -5~256 的整数对象;越界整数每次运算按需新建。
  2. 编译期可确定的短字符串、标识符被驻留到全局字符串表,同一字面量复用同一对象。
  3. 运行时拼接的字符串("a" + "b" 的某些路径、input() 读入)通常不驻留;sys.intern() 可手动驻留。

代码或图示

import sys
a = 1000
b = 1000
print(a is b)          # 结果依赖上下文,不可依赖

s1 = sys.intern("hello-world-" + "x")
s2 = sys.intern("hello-world-x")
print(s1 is s2)        # True

常见误区

  • 反例:a = 1000; b = 1000 在同一模块常量里可能同对象,但在两个不同代码块/函数里可能不同。
  • 结论:值比较一律 ==,is 只用于 None/True/False/单例。

追问

  • 驻留有什么好处?答:大量重复的 key/标识符共享一份内存,字典查找也更快(指针相等可短路)。
  • 为什么 is 在小整数上为 True 却不能用于业务判断?答:缓存范围与实现版本相关,越过 256 就失效。
  • 如何关闭字符串驻留?答:无法全局关闭;用 ''.join() 动态构造或 str(x) 拷贝可避免复用。

04.7.1-010 切片的规则是什么?有哪些容易忽略的细节?

一句话结论

切片 seq[start:stop:step] 遵循“左闭右开”,三个参数都可省略、可为负;负索引从末尾倒数。切片总是返回新对象(list 是新 list,str 是新 str,但可能复用不可变对象),不修改原序列。

概念解释

  • a[::-1] 反转;a[::2] 取偶数位;a[-3:] 最后三个;a[:-1] 去掉最后一个。
  • a[:] 是浅拷贝。

原理流程

  1. 切片按 start、stop、step 计算下标序列,越界下标被裁剪到边界。
  2. step 为 0 直接 ValueError;单元素索引 a[100] 越界才报 IndexError。
  3. 切片赋值 a[1:3] = [9] 可改变长度,是原地操作,只对可变序列有效。
  4. 自定义类可实现 __getitem__ 支持切片,注意区分 int 与 slice。

代码或图示

a = [0, 1, 2, 3, 4, 5]
print(a[1:4])     # [1, 2, 3]
print(a[::-1])    # [5, 4, 3, 2, 1]
print(a[-2:])     # [4, 5]
a[1:3] = [9]      # 原地替换,长度变短

常见误区

  • 以为切片越界会报错:stop 越界被裁剪到边界,不报错;只有单元素下标越界才报 IndexError。
  • 把 NumPy 切片当拷贝:NumPy 数组的切片是视图,改视图会影响原数组,这是常见坑。

追问

  • 切片为什么越界不报错?答:设计上 stop 是“上限”而非精确下标,便于 a[:n] 在 n 超长时也安全。
  • 切片会复制内存吗?答:list/str 会(O(k));NumPy 数组的切片是视图,改视图会影响原数组,这是常见坑。
  • 如何高效取“最后 n 个”?答:a[-n:] 即可,deque 用 itertools.islice 或 maxlen。

04.7.1-011 list 常用操作的时间复杂度是多少?哪些写法会悄悄变慢?

一句话结论

按下标读写 O(1);尾部 append/pop 摊还 O(1);头部或中间 insert/pop(0)/remove O(n);in 判断 O(n);sort O(n log n)。批量头部操作用 collections.deque,成员判断用 set/dict。

概念解释

  • list 是动态数组:扩容按约 1.125 倍并留余量,尾部追加摊还 O(1)。
  • sort 是 Timsort,对部分有序数据接近 O(n);sorted 返回新列表。

原理流程

  1. append 多数只写一格,偶尔扩容复制整体,均摊到每次是常数。
  2. pop(0) 要把后面所有元素前移,循环里 pop(0) 是 O(n²)。
  3. remove(x) 先线性查找再前移,也是 O(n);重复删除考虑一次性重建。
  4. x in list 每次线性扫描;如果循环内做成员判断,改 set 能把 O(n²) 降到 O(n)。

代码或图示

from collections import deque
q = deque([1, 2, 3])
q.popleft()      # O(1)

# 反例:循环 pop(0)
# while lst: lst.pop(0)   # O(n²)

常见误区

  • 在循环里 pop(0) 或 remove:O(n²),应改用 deque 或一次性重建。
  • 在循环内对 list 做成员判断:改 set 能把 O(n²) 降到 O(n)。

追问

  • 为什么 append 是摊还 O(1)?答:大多数追加只写一格,偶尔扩容复制整体,均摊到每次是常数。
  • 为什么 list 的 in 不用哈希?答:list 保持插入顺序且允许重复与不可哈希元素,只能线性比较。
  • 需要频繁在中间插入怎么办?答:用 deque(两端快、中间仍 O(n))或跳表/树结构;多数业务场景应改成“先收集再排序”。

04.7.1-012 set 的底层原理是什么?为什么去重很快?

一句话结论

set 也是哈希表(与 dict 同源的紧凑实现),只存 key 不存 value;插入时算哈希定位槽位,命中同哈希再用 __eq__ 判等,重复则丢弃。平均 O(1),因此去重、成员判断、集合运算都很快。

概念解释

  • 元素必须可哈希;list/dict/set 不能放进去。
  • 集合运算 & | - ^ 是数学集合语义,issubset/issuperset 判断包含。

原理流程

  1. 插入元素时计算哈希并定位槽位,同哈希槽位再用 __eq__ 判等。
  2. 判等相同则丢弃重复元素,不同则留空位继续探测。
  3. 大量元素时内存开销高于 list(每槽存 hash + 指针且要留空位);元素哈希冲突严重时性能退化。

代码或图示

nums = [3, 1, 3, 2, 1]
uniq = list(dict.fromkeys(nums))   # 保序去重 → [3, 1, 2]
print(set(nums) & {1, 2})          # {1, 2}

常见误区

  • 去重不保证顺序(CPython 实现上大致按哈希分布);要保序去重,用 dict.fromkeys(seq)。
  • 用哈希质量差的字段组合做元素:冲突严重时性能退化。

追问

  • set 为什么不能放 list?答:list 可变且不可哈希,放进去后哈希变化会导致集合找不到元素。
  • 保序去重有几种写法?答:dict.fromkeys()(3.7+ 保序)、手动 seen 集合 + 结果列表、pandas.unique。
  • frozenset 有什么用?答:不可变集合,可哈希,能作为 dict key 或 set 元素。

04.7.1-013 什么是可哈希(hashable)?自定义对象如何安全地做字典键?

一句话结论

可哈希意味着对象在其生命周期内 hash() 不变且相等对象哈希相同。数字、字符串、tuple(元素可哈希)、frozenset、自定义类(默认按 id 哈希)都可哈希;list、dict、set 不可哈希。

概念解释

  • 默认 object.__hash__ 基于 id,默认 __eq__ 也是身份比较,二者一致,所以默认类可作 key。
  • 正确写法:用不可变字段组合哈希,如 hash((self.a, self.b));可变字段不要参与。

原理流程

  1. 一旦重写 __eq__,__hash__ 被置为 None,必须显式实现,否则不可哈希。
  2. 相等对象必须同哈希:a == b 时 hash(a) == hash(b),否则 dict/set 会同时存两份。
  3. 可变对象做 key 后修改内容,会“丢失”条目:哈希变了,原槽位再也找不到。

代码或图示

class Point:
    __slots__ = ("x", "y")
    def __init__(self, x, y): self.x, self.y = x, y
    def __eq__(self, other): return isinstance(other, Point) and (self.x, self.y) == (other.x, other.y)
    def __hash__(self): return hash((self.x, self.y))

常见误区

  • 重写 __eq__ 后忘记重写 __hash__:默认 __hash__ 被置为 None,对象不可哈希。
  • 让可变字段参与哈希:字段变化会改变哈希,破坏哈希表定位,出现“存进去取不出”。

追问

  • 为什么 __hash__ 要基于不可变字段?答:可变字段变化会改变哈希,破坏哈希表定位。
  • 只重写 __hash__ 不重写 __eq__ 会怎样?答:相等判断仍是身份比较,内容相同的对象会被当成不同 key。
  • dataclass(frozen=True) 能直接做 key 吗?答:能,frozen 自动生成 __hash__;eq=True, frozen=False 则 __hash__ 为 None。

04.7.1-014 列表推导式、字典推导式和生成器表达式有什么区别?

一句话结论

列表/字典/集合推导式立即求值并返回容器,占用与结果等量的内存;生成器表达式 (... for ...) 惰性求值,只保留迭代状态,适合大数据流式处理,但只能消费一次。

概念解释

  • 推导式在 CPython 中走专门的 LIST_APPEND 指令,比 for + append 快,且作用域独立(Python 3 不会泄漏循环变量)。
  • 生成器表达式可嵌套函数调用时省括号:sum(x*x for x in nums)。

原理流程

  1. 列表/字典/集合推导式在求值时把全部元素物化到容器中。
  2. 生成器表达式返回一个生成器对象,调用方每次 next 才计算一个值。
  3. 推导式可以嵌套 if 过滤与三元表达式,但 for 与 if 顺序与普通循环一致。

代码或图示

squares = [x * x for x in range(10)]
mapping = {k: len(k) for k in ["a", "bb"]}
gen = (x * x for x in range(10))
print(sum(gen))     # 40
print(sum(gen))     # 0,已耗尽

常见误区

  • 多层推导式可读性差,超过两层建议拆函数。
  • 带副作用、复杂条件、需要异常处理的逻辑不要塞进推导式。

追问

  • 生成器表达式为什么只能遍历一次?答:它是迭代器,内部游标一路向前,StopIteration 后不再复位。
  • 推导式里有异常会怎样?答:直接抛出,且此前已构建的部分结果被丢弃(列表推导不是原子操作)。
  • 什么时候用生成器表达式而不是列表?答:数据量大、只遍历一次、需要边算边用(如写入文件、聚合求和)。

04.7.1-015 a += b 和 a = a + b 有什么区别?

一句话结论

+= 调用 __iadd__,可变对象(list)会原地扩展、保持同一 id;a = a + b 调用 __add__,总是新建对象。对不可变对象(int、str、tuple)二者等价,都是新建。

概念解释

  • list 的 += 等价于 extend,是原地修改;+ 返回新列表。
  • 函数默认参数、类属性、全局常量用 += 时尤其危险。

原理流程

  1. += 优先调用对象的 __iadd__,存在则原地扩展并返回 self。
  2. 没有 __iadd__ 时退化为 __add__ + 重新绑定。
  3. 影响共享引用:b = a; a += [1] 会让 b 也看到变化;a = a + [1] 不会。

代码或图示

a = [1]
b = a
a += [2]
print(b)     # [1, 2],同一对象

a = [1]
b = a
a = a + [2]
print(b)     # [1],b 仍指向旧对象

常见误区

  • += 对 str 有就地优化但不可依赖;对 tuple 永远新建。
  • NumPy 数组的 += 是原地运算,会改到所有引用同一数组的视图。

追问

  • 为什么 a += b 有时比 a = a + b 快?答:原地扩展避免复制已有元素,尤其对长列表。
  • 什么时候必须避免 +=?答:共享引用、默认参数、缓存中的容器、多线程共享结构。
  • a *= 2 对 list 是什么效果?答:原地重复元素(浅拷贝引用),[[]] * 2 得到两个指向同一内层列表的元素,这是常见坑。

04.7.1-016 sort() 和 sorted() 有什么区别?Timsort 有什么特点?

一句话结论

list.sort() 原地排序、返回 None、只能用于 list;sorted() 接受任意可迭代对象、返回新列表。二者都用 Timsort:稳定、对部分有序数据接近 O(n)、最坏 O(n log n)。

概念解释

  • 稳定性:相等元素保持原有相对顺序,因此可以“先按 A 排,再按 B 排”实现多键排序。
  • key 只对每个元素调用一次,比 cmp 风格高效;reverse=True 不破坏稳定性(相等元素仍保序)。

原理流程

  1. Timsort 识别升序/降序 run 并归并,真实数据常有局部有序,因此实际快于随机数据。
  2. 排序 key 返回不可比较类型会 TypeError;混合 int/str 在 Python 3 中不能直接比较。
  3. 多键排序用元组 key:key=lambda x: (x.age, x.name)。

代码或图示

rows = [{"name": "b", "age": 30}, {"name": "a", "age": 30}]
rows.sort(key=lambda r: (r["age"], r["name"]))
print(rows)   # a 在前,说明元组第二位生效

常见误区

  • 写 x = lst.sort() 把列表变成 None:sort() 返回 None,原地修改。
  • 排序 key 里混入不可比较类型(如 None 与 str/int):直接 TypeError,需给缺失值兜底。

追问

  • 为什么 sort() 返回 None?答:明确“原地修改”语义,避免 x = lst.sort() 把列表变成 None 的经典错误。
  • 稳定排序有什么用?答:多轮排序可叠加:先按次要键排,再按主要键排,结果按主要键分组且组内保持次要顺序。
  • 排序大对象时怎么省内存?答:用 key 而不是把对象复制成 tuple 列表;必要时用 operator.itemgetter 取字段。

04.7.1-017 元组解包和多重赋值是怎么工作的?

一句话结论

赋值右侧先求值成一个可迭代对象,再按位置依次绑定到左侧目标;a, b = b, a 依赖“右侧先整体求值”,所以不需要临时变量。左侧可以有星号收集剩余元素(3.0+),但一个赋值里最多一个 *。

概念解释

  • a, *rest = seq 把剩余收集成 list;*rest 可以为空 list。
  • 函数返回多值实际是返回 tuple,调用处解包。

原理流程

  1. 右侧表达式先整体求值为可迭代对象。
  2. 按位置依次把元素绑定到左侧目标;有星号时把剩余元素收集成 list。
  3. 解包要求两侧数量严格一致,否则 ValueError(有 * 时除外)。

代码或图示

a, b = 1, 2
a, b = b, a
print(a, b)        # 2 1

first, *middle, last = [1, 2, 3, 4]
print(middle)      # [2, 3]

常见误区

  • a = b = [] 让两个名字指向同一个 list:应写 a, b = [], []。
  • 以为解包是原子操作:解包失败抛 ValueError 时,已绑定的变量可能已被部分修改。

追问

  • 为什么交换不需要临时变量?答:右侧 (b, a) 先构造成 tuple 再逐个绑定,语义上等价于临时变量。
  • a = b = [] 有什么坑?答:两个名字指向同一个 list,改一个另一个也变;应写 a, b = [], []。
  • 解包失败会怎样?答:抛出 ValueError,且已绑定的变量可能已被部分修改(不是原子操作)。

04.7.1-018 zip、enumerate、range 各有什么特点与坑?

一句话结论

range 是惰性整数序列,支持索引与 len,不占内存;enumerate 给可迭代对象加下标,start 可调;zip 并行迭代多个可迭代对象,长度取最短,Python 3 返回迭代器。

概念解释

  • enumerate 的 start 常用于生成 1 基序号、行号。
  • range 支持负数步长;range(0) 为空;range 对象可切片并返回新 range。

原理流程

  1. zip 每次从各输入取一个元素打包成 tuple,任一输入耗尽即停止。
  2. zip 返回迭代器,只能遍历一次;需要复用先 list(zip(...))。
  3. 遍历时修改被遍历的 list 会导致跳过元素,先复制或收集索引。

代码或图示

for i, (a, b) in enumerate(zip([1, 2, 3], ["a", "b"]), start=1):
    print(i, a, b)     # 1 1 a / 2 2 b,第三个被截断

print(list(zip([1, 2], [3, 4], strict=True)))   # 3.10+

常见误区

  • 忽略 zip 静默截断:长度不一致时丢数据,要严格等长用 zip(..., strict=True)(3.10+)。
  • 遍历 list 时 remove:删除使后续元素前移,而迭代下标继续前进,跳过了一个。

追问

  • 为什么 zip 默认不报长度不一致?答:历史上为支持无限迭代器(如 itertools.count)与流式配对而设计。
  • 怎么实现“按最长配对并补 None”?答:itertools.zip_longest(*iters, fillvalue=None)。
  • 遍历 list 时 remove 为什么会漏元素?答:删除使后续元素前移,而迭代下标继续前进,跳过了一个。

04.7.1-019 Python 中什么算“真”、什么算“假”?__bool__ 与 __len__ 如何参与?

一句话结论

假值包括 False、None、0、0.0、0j、""、[]、()、{}、set()、range(0);其余为真。判定顺序是先调 __bool__,没有则调 __len__(0 为假),都没有就恒为真。

概念解释

  • 自定义类可只实现 __len__ 参与真值判断,但语义容易误导,推荐实现 __bool__。
  • if x: 与 if x is not None: 语义不同:前者把 0、空串也判为假,容易吞掉合法值。

原理流程

  1. 真值判断先查找 __bool__,调用结果转为 bool。
  2. 没有 __bool__ 再查找 __len__,返回 0 为假、非 0 为真。
  3. 两者都没有的对象恒为真。

代码或图示

print(bool([]), bool([0]))    # False True
print(0 or "default")         # default
print([] or "default")        # default

常见误区

  • NumPy 数组的真值判断会抛 ValueError(长度大于 1 时歧义),必须显式 .any()/.all()。
  • and/or 返回的是操作数本身,不是 bool:x = a or b 在 a 为真时返回 a;bool 是 int 的子类,True == 1、False == 0,可参与算术但不应滥用。

追问

  • 为什么 if not value 会误判 0?答:0 是合法数值但为假值,业务上“未提供”应区分 None。
  • NumPy 为什么禁止隐式真值?答:多元素数组的“真”没有唯一含义,强制用户选择 any/all。
  • and 的短路有什么用?答:可用于默认值、条件取值与避免空指针式异常(obj and obj.attr)。

04.7.1-020 None 和其他“空值”有什么区别?

一句话结论

None 是唯一的 NoneType 单例,表示“没有值”;""、[]、0、False 都是具体类型的实例,只是假值。判断“是否缺失”用 is None,判断“是否为空”用 len(x) == 0 或 not x。

概念解释

  • 函数无 return 时返回 None;这也是“原地修改函数返回 None”的根源(如 list.sort)。
  • 类型注解用 Optional[X] / X | None 表达可空。

原理流程

  1. None 不能参与算术、不能下标访问,误用会 TypeError。
  2. dict.get(k) 找不到返回 None,无法区分“键不存在”与“值为 None”;需要区分用 k in d 或哨兵对象。
  3. JSON 的 null 映射为 None,但 None 序列化为 null,与其他空值不等价。

代码或图示

sentinel = object()
value = d.get("k", sentinel)
if value is sentinel:
    ...   # 键不存在

常见误区

  • 用 x == None 判断缺失:None 是单例,is 更准确、更快;自定义 __eq__ 还可能把 None 判为相等。
  • 用 dict.get 返回值区分“键不存在”与“值为 None”:需要区分用 k in d 或哨兵对象。

追问

  • 为什么 x == None 不推荐?答:None 是单例,is 更准确、更快;且自定义 __eq__ 可能把 None 判为相等。
  • None 和 NaN 一样吗?答:不一样,NaN 是 float,nan != nan,None is None。
  • 如何表示“未设置”与“显式设为空”?答:用独立哨兵对象(object() 或枚举),避免复用 None。

04.7.1-021 Python 的 int 为什么没有溢出?大整数运算有什么代价?

一句话结论

CPython 的 int 是任意精度整数(bignum),按需扩展内部数字数组,不会溢出;代价是大数运算变慢、内存变大,且与 C 扩展/数据库交互时需要转换或截断。

概念解释

  • int 没有固定位宽,所以位运算、掩码在负数上遵循补码语义但长度无限。
  • 浮点转 int 会截断小数,round 是银行家舍入(.5 取偶),金额计算不要用 float。

原理流程

  1. 小整数走缓存与单 digit 快路径,大整数按 30 位(64 位平台)分块运算,乘法是 O(n²)(有 Karatsuba 优化)。
  2. 与 C 交互(struct、numpy、数据库 BIGINT)会溢出或截断,需要在边界做校验。
  3. sys.set_int_max_str_digits 限制超长数字字符串转换(防 DoS),默认 4300 位左右。

代码或图示

print(2 ** 100)            # 1267650600228229401496703205376
print(10**1000 % 97)       # 大数取模仍可用
print(round(2.5), round(3.5))   # 2 4,银行家舍入

常见误区

  • 金额计算用 float 或直接信任浮点转 int:金额用 decimal.Decimal 或整数“分”。
  • 以为 Python int 与 C 整型边界行为一致:与 C 扩展/数据库 BIGINT 交互时会溢出或截断,需要在边界做校验。

追问

  • 为什么要限制 int 与 str 互转长度?答:超大十进制转换是超线性开销,可被用来做 DoS。
  • 金额用什么类型?答:decimal.Decimal(指定精度与舍入模式)或整数“分”,不要用 float。
  • Python 的 bool 与 int 什么关系?答:bool 继承 int,True 是 1,可参与运算,但不应作为数值滥用。

04.7.1-022 为什么 0.1 + 0.2 != 0.3?浮点数该怎么比较?

一句话结论

float 是 IEEE-754 双精度二进制浮点,0.1、0.2 无法用有限二进制精确表示,相加后得到 0.30000000000000004。比较浮点要用容差 math.isclose(a, b, rel_tol=1e-9),或用 Decimal/整数分单位。

概念解释

  • 双精度约 15~17 位有效十进制数字,超出部分的精度不可信。
  • decimal.Decimal 用十进制表示,需从字符串构造,Decimal(0.1) 仍会带入二进制误差。

原理流程

  1. 表示范围有上限(约 1.8e308),溢出为 inf;下溢为 0;inf - inf 得 nan。
  2. 累加大量小数会累积误差,金融/统计场景应使用 Decimal、Fraction 或 Kahan 求和。
  3. round(2.675, 2) 得到 2.67,因为 2.675 二进制表示略小于真值。

代码或图示

import math
from decimal import Decimal

print(0.1 + 0.2)                             # 0.30000000000000004
print(math.isclose(0.1 + 0.2, 0.3))          # True
print(Decimal("0.1") + Decimal("0.2"))      # 0.3

常见误区

  • 用 == 比较浮点:必须用容差 math.isclose。
  • 用 Decimal(0.1) 构造十进制值:先把 0.1 变成二进制近似值再转十进制,误差已存在;应从字符串构造。

追问

  • 为什么 Decimal(0.1) 不对而 Decimal("0.1") 对?答:前者先把 0.1 变成二进制近似值再转十进制,误差已存在。
  • 浮点能做 dict 的 key 吗?答:能(可哈希),但 nan 与 -0.0 的语义特殊,业务上不建议。
  • 什么时候可以用 float?答:科学计算、图形、统计等允许误差的场景;金额、计数、ID 不要用。

04.7.1-023 Decimal 和 Fraction 分别适合什么场景?

一句话结论

Decimal 是十进制定点/浮点,可指定精度与舍入模式,适合金额、税率、报表等“人类十进制语义”场景;Fraction 是有理数(分子/分母),适合精确比例运算,但分母可能膨胀。

概念解释

  • Decimal 的上下文(getcontext())控制精度、舍入、陷阱,可局部设置 localcontext()。
  • 数据库 NUMERIC/DECIMAL 字段对应 Decimal,ORM 默认也返回 Decimal。

原理流程

  1. Decimal 运算按上下文精度与舍入模式执行,可局部切换。
  2. Decimal 运算比 float 慢一个量级,不要用于大规模数值计算。
  3. Fraction 精确表示 1/3,但与 float 混合运算会退化,且大分母运算变慢;两者都可与 int 精确互转,与 float 互转需谨慎。

代码或图示

from decimal import Decimal, ROUND_HALF_UP
from fractions import Fraction

price = Decimal("19.99")
total = (price * 3).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
print(total)              # 59.97
print(Fraction(1, 3) + Fraction(1, 6))   # 1/2

常见误区

  • 用 Decimal 做大规模数值计算:比 float 慢一个量级,不要用于科学计算主循环。
  • 把数据库读出的 Decimal 直接 JSON 序列化:标准 json 不支持,需要 default=str 或转字符串/分单位整数。

追问

  • 为什么金额不用 float?答:二进制误差会导致对账差一分钱,且舍入不可控。
  • Decimal 的精度设多大?答:按业务定,金额通常 28 位上下文精度 + 2 位展示精度足够。
  • 数据库读出的 Decimal 能直接 JSON 序列化吗?答:不能,标准 json 不支持,需要 default=str 或转字符串/分单位整数。

04.7.1-024 str、bytes、bytearray 有什么区别?

一句话结论

str 是 Unicode 码点序列(不可变,人类文本);bytes 是 0~255 字节序列(不可变,磁盘/网络原始数据);bytearray 是可变的字节序列。二者转换必须显式编码/解码并指定字符集。

概念解释

  • Python 3 严格区分文本与字节,b"abc" != "abc",不能直接拼接。
  • bytes 支持切片、in、startswith,但不支持格式化。

原理流程

  1. str.encode("utf-8") 得到 bytes;bytes.decode("utf-8") 回到 str,方向搞反会报错或乱码。
  2. 文件用文本模式(open(..., encoding="utf-8"))读写 str,二进制模式读写 bytes;混用会出现 UnicodeDecodeError。
  3. bytearray 适合拼接二进制协议帧,支持 +=、extend、原地修改。

代码或图示

s = "中文"
b = s.encode("utf-8")
print(b, len(b))            # b'\xe4\xb8\xad\xe6\x96\x87' 6
print(b.decode("utf-8"))    # 中文

buf = bytearray(b"\x01")
buf.append(0x02)

常见误区

  • 文本与字节直接拼接/比较:b"abc" != "abc",混用会 TypeError。
  • 读写文件不指定编码:混用文本/二进制模式会出现 UnicodeDecodeError。

追问

  • 为什么 len("中文") 是 2 而 len(b) 是 6?答:str 按码点计数,UTF-8 每个汉字占 3 字节。
  • 网络传输为什么要 bytes?答:协议传输的是字节流,编码由应用层约定(HTTP 用 charset 声明)。
  • bytearray 能直接当 bytes 用吗?答:多数接受 bytes-like 的 API 可以,但需要不可变保证(如 dict key)时必须转 bytes。

04.7.1-025 中文/emoji 编码为什么会出问题?怎么正确处理?

一句话结论

乱码本质是“编码与解码用的字符集不一致”,或把字节当文本、把文本当字节。统一约定 UTF-8、显式指定 encoding、在边界(文件、HTTP、数据库、子进程)做转换,就能避免。

概念解释

  • Windows 默认代码页(GBK/CP936)与 UTF-8 不一致,读写文件不指定编码就会乱码。
  • str 长度按码点计,emoji 组合序列(肤色、家庭)由多个码点组成,len 会大于视觉字符数。

原理流程

  1. 文本在边界(文件、HTTP、数据库、子进程)被编码成字节,另一端按约定字符集解码。
  2. UnicodeDecodeError 可用 errors="replace"/"ignore" 容错,但会丢数据,只适合日志展示。
  3. 规范化(NFC/NFD)会影响相等比较,unicodedata.normalize 可统一形式。

代码或图示

b = "中文".encode("gbk")
print(b.decode("utf-8"))     # 乱码或报错
print(b.decode("gbk"))       # 中文

open("f.txt", "w", encoding="utf-8", newline="\n")

常见误区

  • 用 errors="ignore"/"replace" 处理业务数据:只适合日志展示,会丢数据。
  • 以为 MySQL utf8 能存 emoji:utf8 是 3 字节,需要 utf8mb4,且库/表/连接三处字符集都要确认。

追问

  • 为什么同一段中文在 Windows 记事本里正常、在程序里乱码?答:记事本按本地代码页解码,程序按 UTF-8 解码。
  • 数据库存 emoji 报错怎么排查?答:确认库/表/连接三处字符集都是 utf8mb4。
  • len 算不准用户看到的字符数怎么办?答:用 grapheme 库或按 unicodedata 组合规则切分。

04.7.1-026 常用字符串方法里有哪些易错点?

一句话结论

strip 只去两端指定字符集合(不是前缀);split 默认按任意空白切分并丢弃空串;replace 默认全替换;startswith/endswith 接受 tuple 做多前缀匹配;partition 返回三元组且不抛异常。

概念解释

  • find 找不到返回 -1,index 抛 ValueError;判断存在优先 in。
  • 大小写与排序:casefold() 比 lower() 更适合国际文本比较。

原理流程

  1. strip("abc") 会去掉两端的 a、b、c 任意字符,而不是子串 "abc";去前后缀用 removeprefix/removesuffix(3.9+)。
  2. split() 与 split(" ") 不同:前者合并连续空白并去首尾空串,后者保留空字段。
  3. format/f-string 的格式说明符依赖 __format__,: .2f 对 str 无效。

代码或图示

print("  a b  ".split())        # ['a', 'b']
print("a  b".split(" "))        # ['a', '', 'b']
print("pre-x".removeprefix("pre-"))   # x

常见误区

  • 把 strip("abc") 当子串去除:参数是字符集合,会吃掉首尾同名字符;去前后缀用 removeprefix/removesuffix。
  • 混淆 split() 与 split(" "):后者保留空字段,结果可能与预期不同。

追问

  • 为什么 str.strip 会误删正常字符?答:参数被当作字符集合而非子串,含字母时会吃掉首尾同名字符。
  • split 和 rsplit 怎么选?答:从右侧切固定段数用 rsplit(maxsplit=1),如取文件扩展名。
  • join 与 + 在空列表上有什么区别?答:"".join([]) 返回空串,+ 需要至少两个操作数。

04.7.1-027 如何做多键排序和“按外部顺序”排序?

一句话结论

多键排序用元组 key,把优先级从高到低放进元组;需要“按给定顺序”排序时,把目标顺序建成字典映射并用 key=order.get;升降序混合可多次稳定排序或对数值取负。

概念解释

  • 外部顺序:order = {v: i for i, v in enumerate(["高", "中", "低"])},再 sorted(items, key=order.get)。
  • operator.itemgetter(1, 0) 比 lambda 快,适合列表/元组下标。

原理流程

  1. key=lambda x: (x.a, -x.b) 实现 a 升序、b 降序;字符串降序需多次排序或自定义包装。
  2. 稳定排序允许“先排次要键,再排主要键”实现混合升降序。
  3. 排序 key 里有 None 会 TypeError,需给缺失值兜底((x is None, x))。

代码或图示

order = {"高": 0, "中": 1, "低": 2}
items = ["低", "高", "中"]
print(sorted(items, key=order.get))    # ['高', '中', '低']

常见误区

  • 为什么不能直接用 reverse=True 做混合升降序:它整体反转,会破坏其他键的期望方向。
  • 排序 key 里出现 None:与其他类型比较直接 TypeError,需统一哨兵值。

追问

  • 为什么不能直接用 reverse=True 做混合升降序?答:它整体反转,会破坏其他键的期望方向。
  • itemgetter 和 lambda 性能差多少?答:前者是 C 实现,避免每元素 Python 函数调用,通常快 20%~40%。
  • 排序字典列表时字段缺失怎么办?答:key=lambda d: d.get("age", 0) 或统一哨兵值。

04.7.1-028 array 和 list 有什么区别?什么时候该用 NumPy?

一句话结论

array.array 是同类型紧凑数组(如 'i' 存 int32),内存省、缓存友好,但功能少、不能装混合类型;NumPy ndarray 是带向量化运算与广播的多维数组,适合数值计算,小数据或混合类型仍用 list。

概念解释

  • list 存的是对象指针,每元素约 8 字节指针 + 对象开销;array 直接存原始数值。
  • array 支持 append/extend/frombytes/tobytes,适合二进制协议、图像缓冲。

原理流程

  1. NumPy 运算在 C 层循环并释放 GIL(部分操作),比 Python 循环快一两个数量级。
  2. NumPy 切片是视图,修改会影响原数组;copy() 才是独立副本。
  3. 小数组(几十个元素)NumPy 的固定开销可能反而更慢。

代码或图示

import array
a = array.array("i", [1, 2, 3])
print(a.itemsize, len(a))   # 4 3

import numpy as np
v = np.arange(1000)
print((v * 2).sum())

常见误区

  • 以为 NumPy 切片是拷贝:切片是视图,改视图影响原数组;需要独立副本用 copy()。
  • 小数据也上 NumPy:几十个元素时固定开销可能反而更慢。

追问

  • 为什么 array 不能放字符串?答:它要求单一 C 类型(typecode),str 是变长对象。
  • NumPy 为什么快?答:连续内存 + 向量化指令 + 避免每元素 Python 对象开销。
  • 什么场景该用 memoryview?答:需要在 bytes/array/NumPy 之间零拷贝传递时,它提供缓冲区视图。

04.7.1-029 元组的“不可变”到底约束了什么?

一句话结论

约束的是“元组自身的元素引用不可重新绑定、长度不可变”,不约束元素指向的对象。因此 t = (1, []) 里 t[1].append(1) 是允许的,元组的哈希也只在所有元素可哈希时才成立。

概念解释

  • 元组可做“轻量记录”,字段多时 namedtuple/dataclass 更可读。
  • 元组常被用作函数多返回值、字典复合 key、常量表。

原理流程

  1. t[0] = x 报 TypeError;但元素对象内部可变,改它不受限制。
  2. hash(t) 要求每个元素可哈希,含 list 的 tuple 不可哈希,不能做 key。
  3. 元组拼接 t + (x,) 生成新对象,不是原地扩展。

代码或图示

t = (1, [2])
t[1].append(3)
print(t)          # (1, [2, 3])
hash(t)           # TypeError: unhashable type: 'list'

常见误区

  • 以为 tuple 里有 list 也能做 key:哈希需要递归计算元素哈希,list 不可哈希。
  • 把 tuple 当万能性能优化:创建与索引略快、内存更省,但功能受限。

追问

  • 为什么元组里有 list 就不能当 key?答:哈希需要递归计算元素哈希,list 不可哈希。
  • 元组一定比 list 快吗?答:创建与索引略快、内存更省,但功能受限,不是万能优化。
  • 怎么造真正的深度不可变结构?答:全用不可变类型递归构造(tuple/frozenset/str/int),或使用持久化数据结构库。

04.7.1-030 字典有哪些常用操作容易踩坑?合并、更新、遍历各要注意什么?

一句话结论

遍历时不能增删 key(会 RuntimeError);d[k] 缺 key 抛 KeyError,d.get(k) 返回 None;update 原地合并,{**a, **b} / a | b 生成新字典;items() 是视图,字典变化会反映到视图上。

概念解释

  • setdefault(k, []) 可原子地“取或建”,比 if k not in d 少一次查找。
  • collections.defaultdict(list) 让缺 key 自动建值,语义更清晰。

原理流程

  1. 遍历中删除应遍历 list(d.items()) 副本或收集待删 key 后统一删。
  2. d | other(3.9+)返回新字典,右值覆盖左值;|= 原地更新。
  3. 键顺序即插入顺序;popitem() 默认弹出最后插入的项(LIFO),popitem(last=False) 是 OrderedDict 的用法。

代码或图示

d = {"a": 1, "b": 2}
for k in list(d):
    if d[k] < 2:
        del d[k]

merged = d | {"c": 3}
groups = {}
for item in data:
    groups.setdefault(item.type, []).append(item)

常见误区

  • 遍历字典时增删 key:字典大小变化让迭代器检测到版本不一致,直接 RuntimeError。
  • 把 keys/values/items 视图当快照:视图是动态的,原字典变化会立刻反映。

追问

  • 为什么遍历时删除会报错?答:字典大小变化会让迭代器检测到版本不一致,直接 RuntimeError。
  • get 和 setdefault 区别?答:前者只读不写,后者缺 key 时会插入默认值(即使你不使用返回值)。
  • 字典视图是快照吗?答:不是,keys/values/items 是动态视图,原字典变化会立刻反映。

04.7.1-031 布尔运算 and/or/not 有什么非直觉行为?

一句话结论

and/or 返回操作数本身而非 True/False,且短路求值:a and b 在 a 为假时返回 a,否则返回 b;a or b 在 a 为真时返回 a,否则返回 b。这既是默认值技巧,也是误判来源。

概念解释

  • x = a or b or c 取第一个真值,全假返回最后一个值。
  • not 永远返回 bool,可与 is 组合成 is not。

原理流程

  1. and 从左到右求值,遇到第一个假值即返回该操作数;全部为真返回最后一个。
  2. or 从左到右求值,遇到第一个真值即返回该操作数;全假返回最后一个。
  3. 短路可避免异常:obj and obj.attr、lst and lst[0]。

代码或图示

print(0 and 1)       # 0
print([] or [1])     # [1]
print("x" and "y")   # y

常见误区

  • cond and do() or do_other() 是过时三元写法,当 do() 返回假值时会误走 else 分支。
  • 位运算 & | 对 bool 不短路,适合向量化(NumPy)但不要用于条件副作用。

追问

  • 为什么 a and b or c 不能当三元表达式?答:b 为假值时结果会错误地变成 c。
  • 什么时候该用显式 if/else?答:有副作用、需要返回 bool、或可读性优先的场合。
  • NumPy 里 and 为什么报错?答:数组真值歧义,必须用 & 并加括号。

04.7.1-032 海象运算符 := 有什么用?什么时候不该用?

一句话结论

:= 在表达式内部赋值并返回该值,避免“先算一次再判断一次”的重复计算,典型用于 while (chunk := f.read(1024)):、推导式过滤、if (m := re.match(...)):。

概念解释

  • 与 = 区别:= 是语句,:= 是表达式,可用于条件、while、推导式条件。
  • 常见收益:少一次函数调用、少一次查字典、代码更紧凑。

原理流程

  1. := 对右侧表达式求值、绑定到名字、再把该值作为表达式结果返回。
  2. 作用域遵循所在代码块;推导式内使用会绑定到外层函数作用域,需注意。
  3. 与 and/or 组合时要加括号,避免优先级意外。

代码或图示

while (line := f.readline()):
    process(line)

if (m := re.search(r"\d+", text)):
    print(m.group())

常见误区

  • 在推导式里滥用 :=:变量会绑定到外层作用域,可能污染后续逻辑。
  • 省略括号导致优先级意外:while chunk := f.read() 语法上要加括号,避免与比较运算混淆。

追问

  • := 能用在函数调用参数里吗?答:可以,但可读性差,且求值顺序容易误判。
  • 为什么 while chunk := f.read() 要加括号?答:避免与比较运算优先级混淆,也是语法要求。
  • 推导式里用 := 有什么副作用?答:变量会绑定到外层作用域,可能污染后续逻辑。

04.7.1-033 三元表达式和条件赋值怎么写更清晰?

一句话结论

x = a if cond else b 是表达式,适合简单二选一;多分支用 if/elif/else 或字典映射;a and b or c 不是三元表达式,b 为假值时会出错。

概念解释

  • d.get(key, default) 常比 if key in d 更简洁。
  • 布尔到值的映射可用 {True: x, False: y}[cond],但不如三元直观。

原理流程

  1. 三元表达式先求 cond,再只对选中的分支求值(短路)。
  2. 三元表达式可嵌套但可读性迅速下降,超过一层就拆。
  3. 条件赋值不要写副作用,表达式应保持“纯计算”;f-string 内可用三元,但别塞复杂逻辑。

代码或图示

label = "通过" if score >= 60 else "不通过"
status = {"a": 1, "b": 2}.get(code, 0)

常见误区

  • 用 cond and x or y:x=0/空串等假值时会错误走到 y 分支。
  • 多层嵌套三元:可读性迅速下降,超过一层就拆成 if/elif。

追问

  • 为什么 cond and x or y 在 x=0 时出错?答:cond and 0 得 0(假),于是继续走 or y。
  • 三元表达式有短路吗?答:有,只对选中的分支求值。
  • 什么时候该用映射表代替 if 链?答:分支多、条件是离散枚举、且各分支逻辑简单时。

04.7.1-034 Python 3 与 Python 2 的关键差异有哪些?迁移时要特别小心什么?

一句话结论

Python 3 中 print 是函数、str 是 Unicode 且 bytes 独立、/ 是真除法、range 返回惰性对象、dict 视图替代 keys() 列表、异常语法 as、整数不再有 long 区分。迁移风险集中在编码、除法、迭代器语义与字节/文本边界。

概念解释

  • Python 2 的 str 是字节,unicode 才是文本;混用时隐式编码是乱码主因。
  • 字典 keys/values/items 返回视图,不能直接下标,需要 list()。

原理流程

  1. 1/2 在 Py2 得 0,Py3 得 0.5;依赖整除的地方要显式 //。
  2. map/filter/zip 在 Py3 返回迭代器,多次遍历会“空”。
  3. 相对导入在 Py3 中必须显式 .,隐式相对导入被移除。

代码或图示

print(3 / 2, 3 // 2)     # 1.5 1
print(list(map(str, [1, 2])))

常见误区

  • 迁移时忽略除法语义:依赖整除的地方要显式 //。
  • 把 Py3 迭代器当列表重复遍历:map/filter/zip 多次遍历会“空”,需要 list() 物化。

追问

  • 现在还有必要学 Python 2 差异吗?答:面试常考“为什么 Py3 要分离 str/bytes”,理解设计动机比记版本差异更有价值。
  • 迁移时最常见的事故是什么?答:编码相关(隐式 ascii 编解码),以及整数除法语义变化。
  • 2to3 工具能完全自动化吗?答:不能,语义变化(除法、迭代器、编码)需要人工判断。

04.7.1-035 为什么说“Python 里一切皆对象”?这对性能有什么影响?

一句话结论

int、函数、类、模块都是 PyObject,都带引用计数与类型指针,都能被赋值、传参、加属性(部分受限)。好处是统一、灵活、可内省;代价是每元素都有对象头开销,纯 Python 循环比 C/NumPy 慢。

概念解释

  • 变量是“名字到对象的绑定”,不是内存槽;del x 是解绑,不保证释放。
  • 函数是一等对象:可赋值、可作参数、可加属性、可被装饰。

原理流程

  1. 每个对象至少包含引用计数与类型指针,小整数也有 28 字节左右的实体。
  2. 类也是对象(type 的实例),模块也是对象(可动态导入、改属性)。
  3. 性能优化思路:减少 Python 层循环、用内建函数/C 扩展、批量处理(join、sum、NumPy)、避免不必要的对象创建。

代码或图示

import sys
print(sys.getsizeof(1), sys.getsizeof(1.0), sys.getsizeof([]))
print(type(len))       # <class 'builtin_function_or_method'>

常见误区

  • 用 sys.getsizeof(1) 当成数值占用字节:它返回对象自身字节数,包含对象头、引用计数与 digit 数组。
  • 在热循环里纯 Python 循环:应改用内建函数、C 扩展或 NumPy 批量处理。

追问

  • 为什么 sys.getsizeof(1) 不是 1?答:它返回对象自身字节数,包含对象头、引用计数与 digit 数组。
  • “一切皆对象”与 GIL 有关吗?答:引用计数需要原子更新,CPython 用 GIL 保护,这是 GIL 存在的重要原因之一。
  • 想突破对象开销该怎么做?答:用 array、NumPy、struct、Cython/C 扩展把数据放到连续原始内存。

本节高频题

  • 可变与不可变(001)
  • == 与 is(002)
  • 深浅拷贝(003)
  • dict 底层与有序(005)
  • 默认参数陷阱(006)
  • 字符串拼接性能(007)
  • 小整数缓存与 is 的坑(009)
  • 浮点精度(022)
  • 列表操作复杂度(011)
  • 可哈希与自定义 key(013)