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 不会互相污染,因此适合做字典键、缓存键、跨线程常量。
- 可变对象被多处引用时是“同一块内存”,任一处修改其他处都能看到,这是浅拷贝、默认参数、类属性三大坑的根源。
原理流程
- 不可变对象创建后,内部字段不允许重新绑定;任何“修改”操作都返回一个新对象。
- 可变对象在原内存上原地增删改,所有持有该引用的名字都能观察到变化。
- 自定义类默认可变;要造不可变类需要
__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__)。
原理流程
is不可被重载,永远比较id,O(1)。==可以被重载,可能递归比较整个容器,成本随数据量增长。- 自定义类没重写
__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()、切片 [:]。
概念解释
- 浅拷贝产生一个新的外层容器,但容器里装的仍是原对象的引用;深拷贝递归复制每一层,得到互不影响的对象图。
原理流程
deepcopy用 memo 字典记录已复制对象,能正确处理循环引用;copy不递归,因此不会陷入死循环。deepcopy默认复制一切,但函数、类、模块、文件句柄等会原样返回;可用__deepcopy__自定义。- 类实例默认浅拷贝只复制
__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 适合位置语义。
原理流程
- 内存上:tuple 省一个“可扩容”指针与预留空间,元素少时更明显;大量小 tuple 的场景收益可观。
- tuple 的不可变是浅层的:内部元素可变仍可改。
- 空 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 连续)。
原理流程
- 写入时按
hash(key)定位索引数组,再在 entries 数组末尾追加键值对。 - 负载因子约 2/3,超过阈值触发扩容(容量大致翻倍并重新分布),扩容是一次 O(n) 的重建。
- 删除是“标记为 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)是安全的。
原理流程
- 执行
def语句时,默认参数表达式求值一次,结果对象挂到函数的__defaults__上。 - 每次调用不传参时,都复用这同一个对象;对可变对象做原地修改,状态会跨调用累积。
- 正确写法:默认值用
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。
原理流程
- CPython 对
s += x有一条就地优化:当引用计数为 1 且可扩容时会尝试原地扩展,但只在特定条件下生效,不能依赖。 join先算总长度再一次性分配,把 n 次复制变成 1 次,是拼接列表的标准写法。- 格式化用 f-string:编译期转成
FORMAT_VALUE指令,比%和.format()快,且可读性好。 - 大文本处理优先流式(逐行/分块),避免把整个文件读成一个大字符串再做替换。
代码或图示
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)。
原理流程
- f-string 在编译期把占位表达式转成字节码指令,运行时直接取值并按格式说明符输出。
%只支持有限的类型转换,元组参数容易出错(单元素要写(x,))。- 三者都受
__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"指向同一对象。
原理流程
- 解释器启动时创建并复用 -5~256 的整数对象;越界整数每次运算按需新建。
- 编译期可确定的短字符串、标识符被驻留到全局字符串表,同一字面量复用同一对象。
- 运行时拼接的字符串(
"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[:]是浅拷贝。
原理流程
- 切片按
start、stop、step计算下标序列,越界下标被裁剪到边界。 - step 为 0 直接 ValueError;单元素索引
a[100]越界才报 IndexError。 - 切片赋值
a[1:3] = [9]可改变长度,是原地操作,只对可变序列有效。 - 自定义类可实现
__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返回新列表。
原理流程
append多数只写一格,偶尔扩容复制整体,均摊到每次是常数。pop(0)要把后面所有元素前移,循环里pop(0)是 O(n²)。remove(x)先线性查找再前移,也是 O(n);重复删除考虑一次性重建。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判断包含。
原理流程
- 插入元素时计算哈希并定位槽位,同哈希槽位再用
__eq__判等。 - 判等相同则丢弃重复元素,不同则留空位继续探测。
- 大量元素时内存开销高于 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));可变字段不要参与。
原理流程
- 一旦重写
__eq__,__hash__被置为 None,必须显式实现,否则不可哈希。 - 相等对象必须同哈希:
a == b时hash(a) == hash(b),否则 dict/set 会同时存两份。 - 可变对象做 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)。
原理流程
- 列表/字典/集合推导式在求值时把全部元素物化到容器中。
- 生成器表达式返回一个生成器对象,调用方每次
next才计算一个值。 - 推导式可以嵌套 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,是原地修改;+返回新列表。 - 函数默认参数、类属性、全局常量用
+=时尤其危险。
原理流程
+=优先调用对象的__iadd__,存在则原地扩展并返回 self。- 没有
__iadd__时退化为__add__+ 重新绑定。 - 影响共享引用:
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不破坏稳定性(相等元素仍保序)。
原理流程
- Timsort 识别升序/降序 run 并归并,真实数据常有局部有序,因此实际快于随机数据。
- 排序 key 返回不可比较类型会 TypeError;混合 int/str 在 Python 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,调用处解包。
原理流程
- 右侧表达式先整体求值为可迭代对象。
- 按位置依次把元素绑定到左侧目标;有星号时把剩余元素收集成 list。
- 解包要求两侧数量严格一致,否则 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。
原理流程
zip每次从各输入取一个元素打包成 tuple,任一输入耗尽即停止。zip返回迭代器,只能遍历一次;需要复用先list(zip(...))。- 遍历时修改被遍历的 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、空串也判为假,容易吞掉合法值。
原理流程
- 真值判断先查找
__bool__,调用结果转为 bool。 - 没有
__bool__再查找__len__,返回 0 为假、非 0 为真。 - 两者都没有的对象恒为真。
代码或图示
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表达可空。
原理流程
None不能参与算术、不能下标访问,误用会 TypeError。dict.get(k)找不到返回 None,无法区分“键不存在”与“值为 None”;需要区分用k in d或哨兵对象。- 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。
原理流程
- 小整数走缓存与单 digit 快路径,大整数按 30 位(64 位平台)分块运算,乘法是 O(n²)(有 Karatsuba 优化)。
- 与 C 交互(struct、numpy、数据库 BIGINT)会溢出或截断,需要在边界做校验。
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.8e308),溢出为
inf;下溢为 0;inf - inf得nan。 - 累加大量小数会累积误差,金融/统计场景应使用 Decimal、Fraction 或 Kahan 求和。
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。
原理流程
- Decimal 运算按上下文精度与舍入模式执行,可局部切换。
- Decimal 运算比 float 慢一个量级,不要用于大规模数值计算。
- 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,但不支持格式化。
原理流程
str.encode("utf-8")得到 bytes;bytes.decode("utf-8")回到 str,方向搞反会报错或乱码。- 文件用文本模式(
open(..., encoding="utf-8"))读写 str,二进制模式读写 bytes;混用会出现UnicodeDecodeError。 - 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会大于视觉字符数。
原理流程
- 文本在边界(文件、HTTP、数据库、子进程)被编码成字节,另一端按约定字符集解码。
UnicodeDecodeError可用errors="replace"/"ignore"容错,但会丢数据,只适合日志展示。- 规范化(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()更适合国际文本比较。
原理流程
strip("abc")会去掉两端的 a、b、c 任意字符,而不是子串 "abc";去前后缀用removeprefix/removesuffix(3.9+)。split()与split(" ")不同:前者合并连续空白并去首尾空串,后者保留空字段。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 快,适合列表/元组下标。
原理流程
key=lambda x: (x.a, -x.b)实现 a 升序、b 降序;字符串降序需多次排序或自定义包装。- 稳定排序允许“先排次要键,再排主要键”实现混合升降序。
- 排序 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,适合二进制协议、图像缓冲。
原理流程
- NumPy 运算在 C 层循环并释放 GIL(部分操作),比 Python 循环快一两个数量级。
- NumPy 切片是视图,修改会影响原数组;
copy()才是独立副本。 - 小数组(几十个元素)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、常量表。
原理流程
t[0] = x报 TypeError;但元素对象内部可变,改它不受限制。hash(t)要求每个元素可哈希,含 list 的 tuple 不可哈希,不能做 key。- 元组拼接
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 自动建值,语义更清晰。
原理流程
- 遍历中删除应遍历
list(d.items())副本或收集待删 key 后统一删。 d | other(3.9+)返回新字典,右值覆盖左值;|=原地更新。- 键顺序即插入顺序;
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。
原理流程
and从左到右求值,遇到第一个假值即返回该操作数;全部为真返回最后一个。or从左到右求值,遇到第一个真值即返回该操作数;全假返回最后一个。- 短路可避免异常:
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、推导式条件。 - 常见收益:少一次函数调用、少一次查字典、代码更紧凑。
原理流程
:=对右侧表达式求值、绑定到名字、再把该值作为表达式结果返回。- 作用域遵循所在代码块;推导式内使用会绑定到外层函数作用域,需注意。
- 与
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],但不如三元直观。
原理流程
- 三元表达式先求
cond,再只对选中的分支求值(短路)。 - 三元表达式可嵌套但可读性迅速下降,超过一层就拆。
- 条件赋值不要写副作用,表达式应保持“纯计算”;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/2在 Py2 得 0,Py3 得 0.5;依赖整除的地方要显式//。map/filter/zip在 Py3 返回迭代器,多次遍历会“空”。- 相对导入在 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是解绑,不保证释放。 - 函数是一等对象:可赋值、可作参数、可加属性、可被装饰。
原理流程
- 每个对象至少包含引用计数与类型指针,小整数也有 28 字节左右的实体。
- 类也是对象(type 的实例),模块也是对象(可动态导入、改属性)。
- 性能优化思路:减少 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)