04.7.8 标准库与数据处理
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python
覆盖范围
collections:Counter、defaultdict、OrderedDict、deque、ChainMapitertools与functools的实用组合re正则:贪婪、分组、性能陷阱json、datetime、pathlib、文件与 CSVsubprocess、argparse、logginghashlib、secrets、uuid、base64、struct
04.7.8-001 collections.Counter 适合做什么?most_common 有什么注意点?
一句话结论
Counter 是 dict 子类,用于计数:Counter(iterable) 统计频次,update 累加,most_common(n) 取前 n 高频,+/-/&/| 做多重集运算。注意 most_common 按计数降序,计数相同则按首次出现顺序(实现细节,不保证跨版本)。
概念解释
- 缺失键返回 0 而不是 KeyError,适合“计数 + 判断”。
- Counter 是 dict,键必须可哈希。
原理流程
- 遍历可迭代对象,逐键累加计数。
most_common(n)按计数降序取前 n。- 多重集运算逐键求和/求交并集。
代码或图示
from collections import Counter
c = Counter("abracadabra")
print(c.most_common(2)) # [('a', 5), ('b', 2)]
常见误区
most_common()不带参数返回全部,等价于排序整个计数表,大集合时注意成本;subtract会保留 0 与负数,-运算则丢弃非正项。- 统计大文本词频时配合
re.findall或生成器,避免中间列表;取前 n 用heapq.nlargest,为 O(m log n),取全部才是排序。
追问
most_common(n)是 O(n log n) 吗?答:取全部是排序;取前 n 用heapq.nlargest,为 O(m log n)。- Counter 能直接相加吗?答:能,
c1 + c2逐键求和,结果丢弃非正计数。 - 内存大时怎么统计词频?答:分片统计后合并,或用外部排序/数据库。
04.7.8-002 defaultdict 的原理是什么?有什么坑?
一句话结论
defaultdict(factory) 在访问不存在的键时调用工厂创建默认值并插入字典,行为类似 setdefault 但更简洁。坑在于“读取也会写入”:d[k] 查询不存在的键会污染字典,用 in 或 .get() 避免。
概念解释
- 工厂需是无参可调用对象:
list、dict、int、set、lambda: []。 defaultdict(list)是最常用的分组写法。
原理流程
- 访问缺失键时调用工厂生成默认值。
- 默认值插入字典后再返回。
- 因此“查询”动作也会写入字典。
代码或图示
from collections import defaultdict
groups = defaultdict(list)
for item in data:
groups[item.type].append(item)
# 坑:查询也会插入
print(groups["missing"]) # [],且字典多了这个键
常见误区
- 序列化(pickle/json)时工厂需可序列化,lambda 会失败;与普通 dict 混用时,
d[k]的行为差异容易造成隐藏 bug。 - 需要“只读不写”的默认值用
d.get(k, default);嵌套分组defaultdict(lambda: defaultdict(list)),不要用defaultdict(defaultdict(list))(共享同一个内层字典)。
追问
defaultdict和setdefault怎么选?答:频繁分组用 defaultdict,单次取值用 setdefault/get。- 为什么 lambda 工厂会导致 pickle 失败?答:lambda 没有稳定名字,无法序列化。
- 嵌套分组怎么写?答:
defaultdict(lambda: defaultdict(list)),注意别用defaultdict(defaultdict(list))(共享同一个内层字典)。
04.7.8-003 3.7 之后 OrderedDict 还有必要吗?
一句话结论
普通 dict 已保证插入顺序,多数场景不再需要 OrderedDict。它仍提供 move_to_end、popitem(last=False)、顺序敏感的相等比较(OrderedDict(a=1,b=2) != OrderedDict(b=2,a=1)),以及更明确的“顺序语义”表达。
概念解释
- dict 的
==只比较键值不看顺序;OrderedDict 的==是顺序敏感的。 - OrderedDict 内部是双向链表 + 字典,内存略高。
原理流程
- 普通 dict 自 3.6 紧凑字典实现带来顺序,3.7 写入语言规范。
- OrderedDict 额外维护双向链表支持重排与顺序比较。
- 需要“有序 + 频繁重排”时它仍有价值。
代码或图示
from collections import OrderedDict
d = OrderedDict(a=1, b=2)
d.move_to_end("a")
print(list(d)) # ['b', 'a']
常见误区
- 实现 LRU 可用
move_to_end+popitem(last=False),但functools.lru_cache更省事;旧代码/旧接口依赖其语义时可保留。 - 顺序敏感比较适合表达“顺序本身是数据语义”的场景,如配置项顺序;手写 LRU 易漏并发细节,优先
functools.lru_cache或cachetools。
追问
- 为什么普通 dict 现在也有序?答:3.6 紧凑字典实现带来顺序,3.7 将其写入语言规范。
- 顺序敏感比较有什么用?答:表达“顺序本身是数据语义”的场景,如配置项顺序。
- 实现 LRU 推荐哪种?答:
functools.lru_cache或cachetools,手写易漏并发细节。
04.7.8-004 deque 和 list 有什么区别?
一句话结论
deque 是双向链表式的块数组,两端 append/appendleft/pop/popleft 都是 O(1),中间插入仍 O(n);list 尾部操作摊还 O(1),头部 O(n)。队列、滑动窗口、BFS 用 deque。
概念解释
deque(maxlen=N)满时自动从另一端淘汰,天然滑动窗口。- 内存比 list 略高(块结构 + 指针)。
原理流程
- deque 由固定大小的块双向链接组成,两端操作直接改块指针。
- list 是连续数组,头部插入需整体前移。
- 随机访问 deque 需按块跳转,为 O(n)。
代码或图示
from collections import deque
q = deque(maxlen=3)
for x in range(5):
q.append(x)
print(q) # deque([2, 3, 4], maxlen=3)
常见误区
- deque 支持索引但随机访问是 O(n),不适合频繁随机读;线程安全:单端 append/pop 是原子的,但复合操作仍需锁。
rotate(n)可旋转,适合轮询调度;deque 不能直接切片,需itertools.islice或转 list;pop(0)在 list 上是 O(n),后面所有元素要前移一格。
追问
- 为什么
pop(0)在 list 上是 O(n)?答:后面所有元素要前移一格。 - deque 能做栈吗?答:能,
append/pop两端都 O(1)。 - deque 能切片吗?答:不能直接切片,需
itertools.islice或转 list。
04.7.8-005 ChainMap 有什么用?
一句话结论
ChainMap 把多个字典串成“只读视图”,查找按顺序穿透到第一个命中的字典;写入只作用于第一个字典。适合“多级配置叠加”(默认配置 → 环境配置 → 命令行覆盖)。
概念解释
maps属性可查看各层;new_child()在顶部加一层。- 读取不复制数据,内存友好;写入不穿透,避免污染下层。
原理流程
- 查找时按 maps 顺序逐层穿透,返回第一个命中键。
- 写入/删除只作用于第一层。
len统计去重后的键(按优先级),迭代按键的首现顺序。
代码或图示
from collections import ChainMap
cfg = ChainMap({"debug": False}, {"debug": True, "port": 8000})
print(cfg["debug"], cfg["port"]) # True 8000
常见误区
- ChainMap 是动态视图,字典合并
{**a, **b}的值是快照;修改 ChainMap 不会影响下层,写只落第一层。 - 它适合进程内多层默认值,不适合动态热更新与分布式配置;需要写回各层时不适合用 ChainMap。
追问
- ChainMap 和字典合并
{**a, **b}的区别?答:前者是动态视图,后者的值是快照。 - 修改 ChainMap 会影响下层吗?答:不会,写只落第一层。
- 适合做配置中心吗?答:适合进程内多层默认值,不适合动态热更新与分布式配置。
04.7.8-006 namedtuple 和 dataclass 怎么选?
一句话结论
namedtuple 是不可变、轻量、可哈希、可解包的“带字段名元组”,适合小记录、返回值、字典键;dataclass 支持默认值、类型注解、方法、可变性控制、继承,适合业务模型。要内存极致与不可变用 namedtuple,要可读性与扩展用 dataclass。
概念解释
- namedtuple 字段不可变,
_replace返回新实例。 - dataclass 支持
frozen、slots、order、__post_init__。
原理流程
- namedtuple 继承 tuple,字段名映射到位置,实例轻量。
- dataclass 由装饰器生成
__init__/__repr__/__eq__等方法。 - 大量实例时 namedtuple 内存更省。
代码或图示
from collections import namedtuple
Point = namedtuple("Point", "x y")
p = Point(1, 2)
print(p.x, p._replace(x=3))
常见误区
- namedtuple 与普通 tuple 完全兼容(可解包、可比较);
_asdict()转 dict(3.8+ 返回普通 dict)。 - namedtuple 可加方法(继承 namedtuple 或设置
__dict__),但不推荐,应改用 dataclass;_replace不是原地修改,返回新实例;元素可哈希时整体可哈希,能做 dict key。
追问
- namedtuple 能做 dict key 吗?答:能,元素可哈希时整体可哈希。
- 为什么 namedtuple 不能加方法?答:可以加(继承 namedtuple 或设置
__dict__),但不推荐,应改用 dataclass。 _replace是原地修改吗?答:不是,返回新实例。
04.7.8-007 itertools.groupby 为什么经常“分组不对”?
一句话结论
groupby 只合并“相邻的相同键”,不会全局聚合。数据必须先按同一 key 排序,否则相同键会被拆成多组。这是最常见的使用错误。
概念解释
- 返回
(key, group_iterator),group 是迭代器,必须在进入下一组前消费完。 groupby适合“已排序的日志/时间序列”。
原理流程
- 遍历输入,把相邻同键元素归入同一 group。
- 遇到不同键就结束当前 group、开新 group。
- 未排序时相同键分散在不同位置,被拆成多组。
代码或图示
from itertools import groupby
data = sorted(rows, key=lambda r: r.type)
for key, group in groupby(data, key=lambda r: r.type):
print(key, list(group))
常见误区
- 按多个字段分组:
key=lambda x: (x.a, x.b),排序也用同一 key;大数据时排序成本高,可改用字典聚合(defaultdict(list))。 - group 迭代器共享底层,延迟消费会拿到错误数据;groupby 与 SQL GROUP BY 不同,后者全局聚合,前者只合并相邻。
追问
- 不排序会怎样?答:相同键被拆成多个组,结果数量变多。
- 为什么 group 必须立刻消费?答:迭代到下一组时底层迭代器已前进。
- groupby 和 SQL GROUP BY 的区别?答:后者全局聚合,前者只合并相邻。
04.7.8-008 itertools 里最常用的几个工具怎么用?
一句话结论
chain 串联多个可迭代对象;islice 切片迭代器;product/permutations/combinations 做组合枚举;tee 把一个迭代器复制多份;count/cycle/repeat 造无限序列;zip_longest 补齐长度。
概念解释
chain.from_iterable展开一层嵌套。accumulate做前缀和/累积运算,可传自定义函数。
原理流程
- 各工具以迭代器方式惰性产出元素,不物化全量。
- 组合枚举工具按笛卡尔积/排列/组合规则生成。
tee内部缓冲已产出元素供多份迭代器消费。
代码或图示
from itertools import chain, islice, product, accumulate
print(list(chain([1], [2, 3]))) # [1, 2, 3]
print(list(islice(iter(range(10)), 2, 5)))
print(list(accumulate([1, 2, 3]))) # [1, 3, 6]
常见误区
islice(it, start, stop, step)不支持负索引;product等价多重循环,组合数爆炸时注意。tee内部缓冲,慢消费者会导致内存增长,不适合无限流;list 直接切片比islice更快;product是迭代器,嵌套推导式可读性更好且可物化成列表。
追问
islice能用在 list 上吗?答:能,但 list 直接切片更快。tee适合无限流吗?答:不适合,缓冲会无限增长。product和嵌套推导式的区别?答:前者是迭代器,后者可读性更好且可物化成列表。
04.7.8-009 functools.cache 和 lru_cache 有什么区别?
一句话结论
functools.cache(3.9+)是 lru_cache(maxsize=None) 的简写,无界缓存、无淘汰;lru_cache 可设容量并按 LRU 淘汰。生产环境有长尾参数时应使用有界 lru_cache,避免内存无限增长。
概念解释
- 两者都要求参数可哈希。
- 都能
cache_clear()、cache_info()。
原理流程
- 缓存键由函数名 + 参数生成。
- 命中直接返回缓存值,未命中执行后写入。
lru_cache超容量时淘汰最久未用条目;cache永不淘汰。
代码或图示
from functools import cache
@cache
def fib(n): return n if n < 2 else fib(n - 1) + fib(n - 2)
常见误区
cache无界,参数空间大时会 OOM;实例方法上使用都会强引用 self;需要 TTL 用cachetools.TTLCache。lru_cache(maxsize=0)不缓存,等价于禁用;缓存不能跨进程,进程内内存,跨进程用 Redis。
追问
- 为什么
cache危险?答:无界,参数空间大时会 OOM。 lru_cache(maxsize=0)是什么效果?答:不缓存,等价于禁用。- 缓存能跨进程吗?答:不能,进程内内存;跨进程用 Redis。
04.7.8-010 正则的贪婪、非贪婪和占有量词有什么区别?
一句话结论
贪婪 * 尽量多匹配,失败才回溯;非贪婪 *? 尽量少匹配,逐步扩张;占有量词 *+(3.11+)匹配后不回退,能避免回溯但可能匹配失败。理解回溯是写好正则的关键。
概念解释
- 字符类比
.更精确,也更少回溯。 - 锚点
^...$能显著减少无效尝试。
原理流程
- 贪婪量词先吃掉尽量多字符,后续模式失败再逐字符回退。
- 非贪婪量词从最少字符开始,逐步扩张直到匹配。
- 占有量词吃掉后不回退,后续无字符可用则直接失败。
代码或图示
import re
print(re.findall(r"<(.+?)>", "<a><b>")) # ['a', 'b']
print(re.findall(r"<(.+)>", "<a><b>")) # ['a><b']
常见误区
re.DOTALL让.匹配换行,re.MULTILINE让^/$匹配行首尾;用re.fullmatch强制整串匹配,避免“部分匹配”误判。- 非贪婪不一定更快,取决于失败位置,但仍比大范围回溯可控;解析嵌套结构(HTML/JSON)应使用专用解析器,避免正则。
追问
- 非贪婪一定更快吗?答:不一定,取决于失败位置,但仍比大范围回溯可控。
*+为什么可能匹配失败?答:不回退,后续模式无字符可用时直接失败。- 什么时候该避免正则?答:解析嵌套结构(HTML/JSON)应使用专用解析器。
04.7.8-011 正则应该预编译吗?
一句话结论
re 模块内部有缓存(默认 512 个模式),同一模式字符串重复使用通常无需手动预编译;在高频循环或大量不同模式时,预编译能省去查缓存与解析开销,也便于复用 flags。
概念解释
re.compile(pattern, flags)返回 Pattern 对象,提供match/search/findall/sub。- 编译本身有成本,一次性使用不必预编译。
原理流程
- 未预编译时,
re按模式 + flags 查内部缓存。 - 未命中则解析模式生成 Pattern 对象。
- 预编译在模块加载时完成,高频调用直接复用对象。
代码或图示
EMAIL = re.compile(r"^[^@]+@[^@]+\.[^@]+$")
if EMAIL.match(value): ...
常见误区
- 缓存按模式 + flags 键,模式过多会频繁淘汰;预编译对象可提前在模块加载时构建,失败早暴露。
- 缓存命中仍有一次字典查找与 flags 规范化;预编译高频小模式通常提升 10%~30%,不是数量级;flags 放编译时,避免每次调用重复解析。
追问
- 缓存命中会有开销吗?答:有一次字典查找与 flags 规范化。
- 预编译能提升多少?答:高频小模式通常 10%~30%,不是数量级提升。
- flags 应该放编译还是调用时?答:放编译时,避免每次调用重复解析。
04.7.8-012 什么是灾难性回溯(ReDoS)?怎么防?
一句话结论
嵌套量词(如 (a+)+、(a|aa)+)在长的不匹配输入上会产生指数级回溯,CPU 被打满。防御:避免嵌套量词、用字符类与锚点约束、限制输入长度、设置超时(regex 库或子进程隔离)、必要时改用解析器。
概念解释
- 典型危险模式:
(.*)*、(a+)+b、多个可选分支重叠。 - Python 标准
re不支持超时;第三方regex支持timeout。
原理流程
- 嵌套量词对同一文本有多种切分方式。
- 不匹配时引擎逐种尝试,组合数随长度指数增长。
- 长输入上 CPU 被回溯占满,形成拒绝服务。
代码或图示
# 危险
re.match(r"(a+)+b", "a" * 30)
# 安全
re.match(r"a+b", "a" * 30)
常见误区
- 输入越长越糟,攻击者可构造特定字符串;服务端应对用户提供的正则做白名单或沙箱;复杂校验优先用逻辑代码而非正则。
- 有超时也不能放心:超时前仍可能占满 CPU,需限流与隔离;检测危险正则靠静态分析工具、代码评审、压测异常输入。
追问
- 为什么嵌套量词会指数回溯?答:每个
a+的切分方式组合爆炸。 - 怎么检测危险正则?答:静态分析工具、代码评审、压测异常输入。
- 有超时就能放心吗?答:不能,超时前仍可能占满 CPU,需限流与隔离。
04.7.8-013 正则的分组、命名分组和替换怎么用?
一句话结论
(...) 是捕获组,(?:...) 是非捕获组,(?P<name>...) 是命名组;group(n)/group("name") 取值,groups() 取全部;re.sub 的替换字符串可用 \1 或 \g<name> 引用。
概念解释
match.groupdict()返回命名组字典,便于结构化解析。- 命名组让复杂正则更可维护,也便于日志排查。
原理流程
- 捕获组按出现顺序编号,命名组同时绑定名字。
- 匹配后通过编号或名字取值。
re.sub替换串按引用回填分组,也可传函数动态生成。
代码或图示
m = re.match(r"(?P<y>\d{4})-(?P<m>\d{2})", "2026-11")
print(m.groupdict()) # {'y': '2026', 'm': '11'}
re.sub(r"\d+", "#", "a1b22")
常见误区
- 非捕获组减少内存与编号干扰,性能略好;
count限制替换次数,flags控制大小写与多行。 group(0)是整个匹配的字符串;替换里命名组用\g<name>,避免与数字歧义;不需要引用时优先非捕获组,减少开销与编号混乱。
追问
group(0)是什么?答:整个匹配的字符串。- 替换里能用命名组吗?答:用
\g<name>,避免与数字歧义。 - 为什么优先非捕获组?答:不需要引用时减少开销与编号混乱。
04.7.8-014 json 模块有哪些限制?怎么处理常见类型?
一句话结论
标准 json 只支持 dict/list/str/int/float/bool/None;datetime、Decimal、set、自定义对象、bytes 都不能直接序列化,需要 default= 转换或自定义 JSONEncoder。反序列化同理需要 object_hook。
概念解释
default只在遇到不支持类型时调用,返回可序列化对象。- 大文件用流式(
ijson)或分块,不要一次性load。
原理流程
- 序列化时遇到不支持类型,调用
default转换。 - 转换结果再递归序列化。
- 反序列化用
object_hook把 dict 转回业务对象。
代码或图示
import json
from decimal import Decimal
json.dumps({"p": Decimal("1.20")}, default=str, ensure_ascii=False)
常见误区
ensure_ascii=False输出中文原文,否则转\uXXXX;sort_keys=True便于对比与签名,但会改变键顺序;allow_nan=False可避免输出非法 JSON 的NaN/Infinity。- Decimal 用
str而不是float:float 会丢精度,金额必须保持十进制字符串;JSON 不能存循环引用,会 ValueError/无限递归。
追问
- 为什么
Decimal用str而不是float?答:float 会丢精度,金额必须保持十进制字符串。 object_hook什么时候用?答:反序列化时把 dict 转成业务对象/日期。- JSON 能存循环引用吗?答:不能,会 ValueError/无限递归。
04.7.8-015 大 JSON 文件怎么处理?
一句话结论
不要一次性 json.load 整个文件(内存为文件大小的数倍)。用流式解析(ijson 的 items/parse)、按行 JSON(JSON Lines 逐行 json.loads)、或分片处理;生成端也应考虑 NDJSON 格式。
概念解释
- JSON Lines(每行一个对象)天然支持逐行读取与并行处理。
- 压缩传输(gzip)可显著减少 IO,但 CPU 换 IO。
原理流程
- 流式解析器按事件逐项产出对象,不物化全量。
- NDJSON 逐行
json.loads,内存只保留当前行。 - 写大 JSON 用
json.dump到文件对象,避免先dumps成字符串。
代码或图示
import json
with open("data.ndjson", encoding="utf-8") as f:
for line in f:
obj = json.loads(line)
常见误区
json.load比文件大很多:解析后的 Python 对象远大于文本;NDJSON 不能有跨行结构,单行不能是数组。- 需要随机访问时转存数据库/Parquet;流式解析可切分文件块(需按行边界),再分进程处理。
追问
- 为什么
json.load比文件大很多?答:解析后的 Python 对象远大于文本。 - NDJSON 有什么限制?答:不能有跨行结构,单行不能是数组。
- 流式解析能并行吗?答:可切分文件块(需按行边界),再分进程处理。
04.7.8-016 datetime 的时区怎么正确处理?
一句话结论
用“带时区的时间”(aware datetime)表示绝对时刻,用 zoneinfo.ZoneInfo("Asia/Shanghai") 绑定;存储统一 UTC,展示按用户时区转换。naive datetime(无时区)只适合“本地日历时间”语义,不要跨时区传递。
概念解释
datetime.now(tz)得到 aware;datetime.utcnow()已弃用(返回 naive),用datetime.now(timezone.utc)。zoneinfo是标准库(3.9+),依赖系统 tzdata;容器需安装 tzdata。
原理流程
- 生成时刻时绑定时区,得到 aware datetime。
- 存储统一转为 UTC。
- 展示用
astimezone()转换到目标时区。
代码或图示
from datetime import datetime, timezone
from zoneinfo import ZoneInfo
now = datetime.now(timezone.utc)
local = now.astimezone(ZoneInfo("Asia/Shanghai"))
常见误区
replace(tzinfo=...)是“强行贴标签”,不等于转换,只改标签不换算时刻,会产生错误时间;astimezone()才转换时区。- DST(夏令时)切换时,同一本地时间可能对应两个时刻,需用 UTC 规避歧义;数据库统一存 UTC,读出来再转本地;新代码用
zoneinfo,pytz的localize语义不同,混用易错。
追问
replace(tzinfo=...)为什么危险?答:它只改标签不换算时刻,会产生错误时间。- 为什么推荐存 UTC?答:避免 DST 与时区变更带来的歧义,便于跨系统比较。
pytz还需要吗?答:新代码用zoneinfo;pytz的localize语义不同,混用易错。
04.7.8-017 时间字符串与时间戳怎么互转?有什么性能坑?
一句话结论
strftime/strptime 做格式化与解析,timestamp()/fromtimestamp() 做时间戳转换。strptime 很慢(纯 Python 解析),高频场景用固定格式解析库(dateutil、ciso8601)或缓存格式对象。
概念解释
- 时间戳是 UTC 秒数(float),
fromtimestamp默认按本地时区解释,需显式传 tz。 - ISO 8601 用
fromisoformat(3.11 起支持更多格式,以官方文档为准)。
原理流程
strptime逐字段匹配格式串生成 datetime。timestamp()把 aware datetime 换算为 UTC 秒数。fromtimestamp(ts, tz)按指定时区还原 datetime。
代码或图示
dt = datetime.fromisoformat("2026-11-19T10:00:00+08:00")
print(dt.timestamp())
常见误区
strftime依赖 locale,月份/星期名可能随环境变化,跨语言输出需固定 locale 或用 ISO 格式;%z解析时区偏移,%Z依赖系统时区名,容易踩坑。- 大量解析时先做格式校验再解析,避免异常开销;float 秒级可表示微秒,但极大年份会丢精度,需用整数纳秒;跨时区比较都转 UTC aware 后比较,不要比较 naive。
追问
- 为什么
strptime慢?答:每次都要解析格式串并逐个字段匹配。 - 时间戳精度够吗?答:float 秒级可表示微秒,但极大年份会丢精度,需用整数纳秒。
- 跨时区比较怎么做?答:都转 UTC aware 后比较,不要比较 naive。
04.7.8-018 pathlib 和 os.path 怎么选?
一句话结论
新代码优先 pathlib:面向对象、跨平台、链式操作、读写便捷;os.path 适合与旧代码/第三方接口交互,或需要字符串路径的 C 扩展。两者可互转(str(p)、Path(s))。
概念解释
Path / "sub" / "f.txt"拼接,p.parent、p.suffix、p.stem取部件。glob/rglob支持模式匹配,iterdir()遍历目录。
原理流程
- Path 对象封装路径部件与平台分隔符。
- 链式
/拼接路径,方法完成存在性、读写、遍历。 - 需要字符串接口时
str(p)转换。
代码或图示
from pathlib import Path
root = Path("data")
for f in root.rglob("*.csv"):
print(f.name, f.stat().st_size)
常见误区
- 路径长度、特殊字符、Windows 盘符差异由 pathlib 处理,减少手写字符串错误;
open接受 path-like 对象,Path 可直接传入。 - 字符串拼接路径容易错:分隔符、结尾斜杠、Windows 反斜杠转义;
resolve()解析为绝对路径并消解符号链接与..。
追问
Path能直接传给open吗?答:能,open接受 path-like 对象。- 为什么字符串拼接路径容易错?答:分隔符、结尾斜杠、Windows 反斜杠转义。
resolve()有什么用?答:解析为绝对路径并消解符号链接与..。
04.7.8-019 文件读写的编码与换行有哪些坑?
一句话结论
文本模式必须显式 encoding="utf-8",否则依赖平台默认(Windows 为 GBK);换行默认做平台转换(newline=None 会把 \r\n 统一成 \n),需要精确控制时用 newline="" 或二进制模式。
概念解释
- 读取二进制文件用
"rb",不要用文本模式解码。 errors="strict"默认,容错用replace/ignore/surrogateescape。
原理流程
- 文本模式按指定编码解码字节,换行参数控制转换。
- 未指定编码时回退平台默认,跨环境不一致。
- 二进制模式不做解码与换行转换。
代码或图示
with open("out.csv", "w", encoding="utf-8", newline="") as f:
writer = csv.writer(f)
writer.writerow(["a", "b"])
常见误区
- 写入 CSV 时用
newline=""防止出现空行;大文件不要read()全量,按行或分块。 - Windows 下 CSV 多空行:文本模式把
\n转成\r\n,csv 自身又写\r\n,形成双换行;不要open(..., "w")不写 encoding,平台默认编码不一致,跨环境必乱码;原子写:同目录临时文件 +os.replace(同盘原子)。
追问
- 为什么 Windows 下 CSV 会多空行?答:文本模式把
\n转成\r\n,csv 自身又写\r\n,形成双换行。 - 为什么不要用
open(..., "w")不写 encoding?答:平台默认编码不一致,跨环境必乱码。 - 原子写怎么做?答:同目录临时文件 +
os.replace(同盘原子)。
04.7.8-020 csv 模块有哪些注意点?
一句话结论
csv.reader/writer 处理引号、转义、分隔符,但不懂编码(需自己指定)与类型(全部返回字符串)。写文件用 newline="",读大文件逐行迭代,不要 list(reader) 全量载入。
概念解释
DictReader/DictWriter按表头读写,字段顺序问题更少。- 含 BOM 的 UTF-8 文件用
encoding="utf-8-sig"。
原理流程
- csv 模块按方言解析引号、转义与分隔符。
- 逐行迭代产出字符串列表/字典。
- 类型转换与空值区分由调用方处理。
代码或图示
import csv
with open("in.csv", encoding="utf-8-sig", newline="") as f:
for row in csv.DictReader(f):
print(row["name"])
常见误区
delimiter、quotechar、quoting控制格式;sniff可探测方言(不可靠);数值/日期需手动转换,空字符串与缺失值要区分。- 不能用
line.split(","):引号内的逗号、换行会被错误切分;复杂 CSV(多行字段、嵌套引号)仍可用 csv 模块正确处理;utf-8-sig解决 Excel 导出 BOM 头导致首列名带\ufeff;大 CSV 按行分块(注意引号跨行),或改用 Parquet/数据库。
追问
- 为什么不能用
line.split(",")?答:引号内的逗号、换行会被错误切分。 utf-8-sig解决什么?答:Excel 导出的 BOM 头会导致首列名带\ufeff。- 大 CSV 怎么并行?答:按行分块(注意引号跨行),或改用 Parquet/数据库。
04.7.8-021 如何安全地写临时文件与做原子替换?
一句话结论
用 tempfile.NamedTemporaryFile/TemporaryDirectory 在系统临时目录创建,或 mkstemp 指定目录;写完后 os.replace 原子替换目标文件。避免自己拼 /tmp/xxx(竞态与权限问题)。
概念解释
NamedTemporaryFile(delete=False)可保留文件供后续替换。- 需要清理用上下文管理器或
TemporaryDirectory。
原理流程
- 临时文件名由系统随机生成,避免可预测竞态。
- 写入后
flush+os.fsync(按需)再替换。 - 同文件系统内
os.replace原子完成目标替换。
代码或图示
import os, tempfile
fd, tmp = tempfile.mkstemp(dir=".", suffix=".json")
with os.fdopen(fd, "w", encoding="utf-8") as f:
f.write(payload)
os.replace(tmp, "config.json")
常见误区
- 直接覆盖写中途失败会留下半个文件,读者可能读到损坏内容;跨盘
os.replace会失败,必须同目录替换。 mkstemp返回文件描述符,需os.fdopen包装;NamedTemporaryFile默认关闭即删,delete=False需手动清理;临时文件名随机,避免符号链接攻击。
追问
- 为什么不能直接覆盖写?答:中途失败会留下半个文件,读者可能读到损坏内容。
mkstemp返回的是文件描述符?答:是,需os.fdopen包装。- 临时文件会自己删除吗?答:
NamedTemporaryFile默认关闭即删,delete=False需手动清理。
04.7.8-022 subprocess 怎么用才安全?
一句话结论
优先 subprocess.run(list_args, check=True, timeout=...),参数用列表形式避免 shell 解释;不要用 shell=True 拼接用户输入(命令注入)。捕获输出用 capture_output=True,需要流式用 Popen。
概念解释
check=True在非零返回码时抛CalledProcessError。Popen+communicate()避免管道缓冲区满导致死锁。
原理流程
- 列表参数直接交给可执行文件,不经 shell 解析。
timeout超时会 kill 子进程并抛TimeoutExpired。communicate()读取输出并等待结束,避免管道满互等。
代码或图示
subprocess.run(["git", "status", "--short"], check=True, text=True, capture_output=True)
常见误区
shell=True字符串交给 shell 解析,;、$()、反引号可注入;text=True自动解码输出,需注意编码。- 敏感参数用环境变量/临时凭据文件,避免出现在命令行(
ps可见);大量调用用批处理或原生库,进程创建开销大;管道缓冲区满而父进程未读会双方互等死锁。
追问
shell=True的风险是什么?答:字符串交给 shell 解析,;、$()、反引号可注入。- 为什么
Popen会死锁?答:管道缓冲区满而父进程未读,双方互等。 - 怎么传密码等敏感参数?答:用环境变量/临时凭据文件,避免出现在命令行(
ps可见)。
04.7.8-023 argparse 和 click 怎么选?
一句话结论
标准库 argparse 零依赖、够用,适合简单脚本;click/typer 提供装饰器式声明、子命令、类型校验、自动补全与更好的帮助输出,适合多命令 CLI 工具。
概念解释
- argparse 的
add_argument支持类型、默认值、choices、nargs。 - CLI 也要写测试:用
CliRunner或直接调用入口函数。
原理流程
- argparse 程序化声明参数与子命令,解析
sys.argv。 - click/typer 用装饰器或类型注解生成参数定义。
- 解析结果做格式校验,语义校验交业务层。
代码或图示
import argparse
p = argparse.ArgumentParser()
p.add_argument("--limit", type=int, default=10)
args = p.parse_args()
常见误区
- 不用
sys.argv手撸:缺少校验、帮助、错误提示,易出边界 bug;子命令用add_subparsers,组织复杂时较啰嗦。 - CLI 做格式校验,业务层做语义校验;typer 基于类型注解生成 CLI,代码最简洁;环境变量默认值:argparse 用
default=os.getenv(...),click 用envvar=。
追问
- 为什么不用
sys.argv手撸?答:缺少校验、帮助、错误提示,易出边界 bug。 - 参数校验放在 CLI 还是业务层?答:CLI 做格式校验,业务层做语义校验。
- 怎么支持环境变量默认值?答:argparse 用
default=os.getenv(...),click 用envvar=。
04.7.8-024 logging 的核心模型是什么?
一句话结论
四层结构:Logger(按名字层级组织,a.b 继承 a 的配置)→ Handler(输出到文件/控制台/网络)→ Formatter(格式)→ Filter(过滤)。日志级别 DEBUG < INFO < WARNING < ERROR < CRITICAL,只有不低于 logger 与 handler 级别的记录才会输出。
概念解释
logging.getLogger(__name__)是标准写法,天然按模块分层。logger.exception在 except 块内记录 traceback。
原理流程
- 代码调用 logger 的级别方法。
- 级别过滤通过后,记录向上传播到父 logger。
- 各 handler 经格式器输出,filter 做额外过滤。
代码或图示
logger = logging.getLogger(__name__)
logger.info("user %s created", uid)
常见误区
- 根 logger 用
basicConfig配置,库不应调用它(会污染宿主应用);传播(propagate)默认开启,父 logger 的 handler 也会处理,易重复输出。 - 用
%s占位而不是 f-string:延迟格式化,级别未开启时不做字符串拼接;多进程写文件需QueueHandler/QueueListener;库代码只getLogger(__name__),不配置 handler,交给应用决定。
追问
- 为什么用
%s占位而不是 f-string?答:延迟格式化,级别未开启时不做字符串拼接。 - 为什么日志会重复打印?答:子 logger 与根 logger 都挂了 handler 且 propagate 为 True。
- 库代码该怎么打日志?答:只
getLogger(__name__),不配置 handler,交给应用决定。
04.7.8-025 密码应该怎么存?hashlib 够吗?
一句话结论
不能用 MD5/SHA1/SHA256 直接存密码:它们是快速哈希,可被 GPU 暴力破解与彩虹表攻击。应使用专用密码哈希:bcrypt、scrypt、argon2(带盐、可调成本),并保证每个用户独立盐值。
概念解释
hashlib.scrypt是标准库可用的 KDF,参数需按硬件调优。- 校验用常量时间比较(
hmac.compare_digest),防时序攻击。
原理流程
- 注册时生成独立盐,用慢哈希计算密码摘要。
- 存储格式包含算法与参数(如
$argon2id$v=19$m=...),便于迁移。 - 校验时按同参数重算,常量时间比较。
代码或图示
import bcrypt
h = bcrypt.hashpw(pw.encode(), bcrypt.gensalt(rounds=12))
bcrypt.checkpw(pw.encode(), h)
常见误区
- 加盐能防彩虹表,但无法防单密码暴力破解,需慢哈希;不能自己写
sha256(salt+pw):迭代次数不足,GPU 每秒可试上亿次。 bcrypt自带盐与成本因子,输出含参数便于升级;argon2是当前推荐,内存硬,抗 GPU;成本因子以单次校验 50~100ms 为目标,随硬件升级提高;存储格式应包含算法与参数。
追问
- 加盐能防彩虹表吗?答:能,但无法防单密码暴力破解,需慢哈希。
- 为什么不能自己写
sha256(salt+pw)?答:迭代次数不足,GPU 每秒可试上亿次。 - 成本因子怎么定?答:以单次校验 50~100ms 为目标,随硬件升级提高。
04.7.8-026 random 和 secrets 有什么区别?
一句话结论
random 是伪随机(Mersenne Twister),可复现、快,适合模拟/抽样/游戏;secrets 使用系统加密安全随机源,适合令牌、密码、验证码、密钥。安全场景绝不能用 random。
概念解释
secrets.token_urlsafe(n)生成 URL 安全令牌,token_hex生成十六进制。uuid4基于随机数,适合标识但不应作为安全令牌。
原理流程
random由种子驱动确定性伪随机序列。secrets读取操作系统加密安全随机源。- 安全场景用
secrets保证不可预测。
代码或图示
import secrets
token = secrets.token_urlsafe(32)
code = "".join(str(secrets.randbelow(10)) for _ in range(6))
常见误区
random.seed()可复现序列,测试里有用,但也可被预测;random.sample是无放回抽样,仍需注意偏差。uuid4可作标识,但安全令牌应用secrets并保证足够熵;验证码要防暴力枚举、时序攻击、重放,需限速与一次性消费。
追问
- 为什么
random不能生成密码?答:种子可预测,输出可被推断。 uuid4能做会话 ID 吗?答:可作标识,但安全令牌应用secrets并保证足够熵。- 验证码要防什么?答:暴力枚举、时序攻击、重放,需限速与一次性消费。
04.7.8-027 uuid 有哪几个版本?怎么选?
一句话结论
uuid1 基于时间 + MAC(可能泄露硬件信息),uuid3/5 基于命名空间 + 哈希(确定性),uuid4 纯随机(最常用),uuid7(3.14 起标准库支持,之前用第三方)时间有序、适合数据库主键。
概念解释
- uuid1 的 MAC 可被提取,隐私敏感场景避免。
- uuid5 适合“由 URL/名称稳定派生 ID”。
原理流程
- uuid1 按时间戳 + MAC 生成;uuid3/5 由命名空间名哈希生成。
- uuid4 填充随机位;uuid7 前 48 位是毫秒时间戳,近似有序。
- 存储用
uuid类型或 BINARY(16)/CHAR(36),按需权衡。
代码或图示
import uuid
print(uuid.uuid4())
print(uuid.uuid5(uuid.NAMESPACE_URL, "https://example.com"))
常见误区
- uuid4 有 122 位随机性,碰撞概率极低,但无序,作主键会导致索引随机写;随机分布导致 B+ 树频繁分裂与缓存失效。
- uuid7 时间戳可推断生成时间,且需注意时钟回拨;截断 uuid 会降低唯一性,截断长度需按碰撞概率评估。
追问
- 为什么 uuid4 做主键性能差?答:随机分布导致 B+ 树频繁分裂与缓存失效。
- uuid7 有什么代价?答:时间戳可推断生成时间,且需注意时钟回拨。
- 能截断 uuid 吗?答:会降低唯一性,截断长度需按碰撞概率评估。
04.7.8-028 base64 和 struct 分别解决什么问题?
一句话结论
base64 把二进制转成可打印 ASCII(用于 JSON/邮件/URL 传输),不是加密;struct 按格式在 Python 值与 C 结构体/二进制协议字段之间打包解包,适合协议解析与文件格式。
概念解释
- base64 会膨胀约 33%,URL 场景用
urlsafe_b64encode。 - 字节序用
</>/=明确,跨平台必须指定。
原理流程
- base64 每 3 字节编码为 4 个可打印字符。
- struct 按格式串把 Python 值映射为固定长度字节序列。
- 解析侧按同一格式串解包。
代码或图示
import base64, struct
print(base64.b64encode(b"hi"))
print(struct.pack("<IH", 1, 2))
常见误区
- base64 只是编码,任何人可解码,不能当加密;解码要处理缺失填充与非法字符。
- struct 格式串如
"<IH"(小端、uint32、uint16),calcsize算长度;单字段用int.to_bytes,多字段结构用 struct;解析不可信二进制要做长度校验、边界检查,避免越界与超大分配。
追问
- base64 能当加密吗?答:不能,只是编码,任何人可解码。
- struct 和
int.to_bytes怎么选?答:单字段用to_bytes,多字段结构用 struct。 - 解析不可信二进制要注意什么?答:长度校验、边界检查,避免越界与超大分配。
04.7.8-029 如何做“带重试的 HTTP 请求”而不引入额外依赖?
一句话结论
标准库 urllib.request 可用但繁琐(无连接池、无重试、超时需显式设置);工程上推荐 httpx/requests(同步)或 httpx/aiohttp(异步),配合重试库(tenacity)实现退避。只用标准库时应显式设超时、限制重定向、捕获 URLError/HTTPError。
概念解释
HTTPError是URLError子类,需分别处理 4xx/5xx。- 生产应统一封装客户端(超时、重试、UA、代理、日志)。
原理流程
urlopen显式设置连接/读超时。- 按错误类型判断是否可重试。
- 可重试错误配合退避与次数上限,不可重试直接失败。
代码或图示
from urllib.request import urlopen
with urlopen("https://example.com", timeout=5) as r:
body = r.read()
常见误区
urlopen(timeout=...)必须设置,否则可能永久挂起;重定向默认跟随,需限制次数防循环;无连接池时每次请求新建连接,性能差。- 标准库无异步、无连接池、阻塞调用,不适合高并发;重试只重试幂等请求与可恢复错误,配合退避与上限;超时分连接超时、读超时、总超时分别设置。
追问
- 为什么标准库不适合高并发?答:无异步、无连接池、阻塞调用。
- 重试要注意什么?答:只重试幂等请求与可恢复错误,配合退避与上限。
- 超时应该设几层?答:连接超时、读超时、总超时分别设置。
04.7.8-030 数据聚合时 sum/min/max/any/all 与 statistics 怎么选?
一句话结论
基础聚合用内建函数(C 实现,快):sum、min/max(可带 key)、any/all(短路);需要均值/中位数/方差/分位数用 statistics(纯 Python,较慢)或 NumPy/Pandas(大数据快)。注意空序列的边界:sum 返回 0、min/max 抛 ValueError、any/all 返回 False/True。
概念解释
min/max带key与default(空序列返回默认值,3.4+)。statistics.mean支持Fraction/Decimal精确计算。
原理流程
- 内建函数在 C 层遍历聚合,短路工具提前终止。
- statistics 在纯 Python 层计算统计量。
- 大数据优先向量化(NumPy/Pandas),避免 Python 循环。
代码或图示
import statistics, math
print(sum([0.1] * 10), math.fsum([0.1] * 10))
print(min([], default=None))
print(statistics.median([1, 3, 5]))
常见误区
sum对 float 有累积误差,精确求和使用math.fsum;any/all短路,适合“存在/全部满足”判断。statistics不能处理缺失值,需先过滤/填充;数据量大、需要分组聚合与向量化运算时上 Pandas;空序列边界:sum返回 0、min/max抛 ValueError、any/all返回 False/True。
追问
- 为什么
sum有浮点误差?答:逐次相加累积舍入误差,fsum用补偿算法。 statistics能处理缺失值吗?答:不能,需先过滤/填充。- 什么时候该上 Pandas?答:数据量大、需要分组聚合与向量化运算时。
本节高频题
- Counter 与 most_common(001)
- defaultdict 的“读也写”(002)
- OrderedDict(003)
- deque(004)
- namedtuple vs dataclass(006)
- groupby 必须先排序(007)
- itertools 常用工具(008)
cache与lru_cache(009)- 正则贪婪/回溯/ReDoS(010、012)
- json 限制与流式(014、015)
- datetime 时区(016)
- pathlib 与文件编码(018、019)
- csv 与 newline(020)
- logging 模型(024)
- 密码哈希(025)
- random vs secrets(026)