04.7.20.3 数据处理与校验库
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python / 04.7.20 Python 常用第三方库
覆盖范围
- pandas:索引与切片、
groupby/merge/join、SettingWithCopyWarning成因、dtype 内存优化、read_csv分块与chunksize - numpy:广播与向量化、
ndarray内存布局、视图与副本、dtype 类型提升 - openpyxl 与 csv:大文件流式读写、Excel 公式与样式代价
- 校验:marshmallow/cerberus/voluptuous 对比,错误聚合与本地化
- 序列化格式:protobuf/msgpack/avro 选型与 schema 演进;itertools 与 more-itertools 组合工具
04.7.20.3-001 Series 与 DataFrame 的索引结构是什么?
一句话结论
Series 是带索引的一维数组,DataFrame 是按列组织的二维表,每列共享行索引、各列有列标签;索引决定对齐、选取与连接行为,索引重复、类型不一致会直接影响后续 join 与分组结果。
概念解释
- 行索引:
index,标签或位置;列索引:columns。 - 对齐:运算按索引标签匹配,缺失处补 NA,而非按位置硬对齐。
- 索引可命名、可重复,重复索引在连接时会放大行数。
原理流程
- 数据按列装入 DataFrame,生成行索引与列标签。
- 选取/运算时按索引标签对齐元素。
- 分组、连接以索引或指定列为键。
- 索引质量(唯一、类型一致)决定结果是否可靠。
代码或图示
import pandas as pd
df = pd.DataFrame({"name": ["Ann", "Bob"], "age": [30, 25]}, index=[10, 20])
print(df.index, df.columns)
常见误区
- 把索引当普通列:索引参与对齐,行为与列不同。
- 索引重复还做连接:一对多匹配导致行数膨胀。
- 索引类型混用(字符串/数字):对齐时匹配不上产生 NA。
追问
- DataFrame 行与列分别用什么索引?答:
index行索引、columns列标签。 - 运算是按位置还是标签对齐?答:按索引标签对齐,缺失补 NA。
- 重复索引有什么风险?答:连接/匹配时一对多放大行数。
04.7.20.3-002 loc、iloc 与方括号切片有什么区别?
一句话结论
loc 按标签选取,iloc 按整数位置选取,直接 df[列] 取列;链式索引 df[a][b] 可能产生视图或副本歧义,修改时触发 SettingWithCopyWarning,赋值应避免链式写法,用单次 loc 定位。
概念解释
loc:标签行/列切片,含右端点。iloc:位置切片,Python 风格不含右端点。- 链式索引:先选列再选行,中间结果可能是副本,写回不生效。
原理流程
- 明确选取依据是标签还是位置。
- 标签用
loc,位置用iloc,单列用df["col"]。 - 赋值定位到单次
loc,避免多层方括号。 - 检查写回是否落在原数据上。
代码或图示
import pandas as pd
df = pd.DataFrame({"a": [1, 2], "b": [3, 4]}, index=["x", "y"])
df.loc["x", "a"] = 10 # 标签
df.iloc[0, 1] = 20 # 位置
常见误区
- loc/iloc 混用:标签与位置混淆取错行。
- 链式赋值
df["a"][df.x > 1] = 0:写回可能不生效。 - 切片右端点理解错:loc 含端点,iloc 不含。
追问
- loc 与 iloc 区别?答:loc 按标签含端点,iloc 按位置不含端点。
- 链式索引为什么危险?答:中间可能是副本,写回原表不生效并告警。
- 赋值推荐写法?答:单次
df.loc[条件, 列] = 值。
04.7.20.3-003 groupby 的拆分-应用-合并怎么工作?
一句话结论
groupby 按键分组,把数据拆成多个组,每组独立应用聚合/转换/过滤函数,结果再按索引合并;分组键可以是单列、多列或映射,聚合返回压缩结果,转换返回与原表对齐的形状。
概念解释
- 拆分(split):按键把行分到各组。
- 应用(apply):聚合
agg、转换transform、过滤filter。 - 合并(combine):结果按分组键拼回,索引对齐。
原理流程
- 指定分组键(列/列表/函数)。
- pandas 计算每组成员索引。
- 对组内数据执行聚合或转换。
- 结果按组键合并为新 Series/DataFrame。
代码或图示
import pandas as pd
df = pd.DataFrame({"city": ["CN", "CN", "US"], "amount": [10, 20, 30]})
result = df.groupby("city")["amount"].agg(["sum", "mean", "count"])
常见误区
- 把 transform 当 agg 用:形状与索引对齐方式不同。
- 分组键含 NA:NA 组默认被排除,需确认业务预期。
- 组内再用 Python 循环:放弃向量化,性能差。
追问
- groupby 三步是什么?答:拆分、应用、合并。
- agg 与 transform 区别?答:agg 压缩成组级结果,transform 返回与原表对齐形状。
- 分组键 NA 怎么处理?答:默认排除 NA 组,需按业务确认。
04.7.20.3-004 merge、join、concat 有什么区别?
一句话结论
merge 按列键做表连接(内/左/右/外),join 是按索引连接的便捷封装,concat 沿轴堆叠(纵向拼行或横向拼列);连接类型决定不匹配行保留还是丢弃,键重复会导致行数膨胀。
概念解释
- merge:指定
on/left_on/right_on,how控制连接方式。 - join:默认按索引连接,等价于 merge 基于索引。
- concat:不做匹配,直接沿轴拼接,需索引/列对齐。
原理流程
- 判断需求:按键匹配连接还是直接堆叠。
- 连接选 merge/join,选
how保留匹配行。 - 堆叠选 concat,指定轴与去重/对齐方式。
- 检查连接后行数与键唯一性。
代码或图示
import pandas as pd
left = pd.DataFrame({"uid": [1, 2], "name": ["Ann", "Bob"]})
right = pd.DataFrame({"uid": [1, 3], "city": ["CN", "US"]})
merged = left.merge(right, on="uid", how="left")
常见误区
- 键有重复还做 merge:一对多匹配,行数成倍膨胀。
- 把 concat 当连接用:不匹配行被并排保留,产生大量 NA。
- 连接后不校验行数:重复键问题被掩盖。
追问
- merge 与 join 区别?答:merge 按列键,join 默认按索引。
- concat 做匹配吗?答:不做,沿轴直接堆叠。
- 连接不匹配行怎么保留?答:
how选 left/right/outer。
04.7.20.3-005 SettingWithCopyWarning 是怎么产生的?
一句话结论
链式索引先选出的切片可能是视图也可能是副本(取决于 pandas 内部复制规则),对这个不确定对象赋值时,写回可能不作用于原表;pandas 抛出告警提示“你在副本上修改”,根因是链式索引与视图/副本歧义,而非单纯警告可忽略。
概念解释
- 视图:共享底层数据,修改反映到原表。
- 副本:独立拷贝,修改不影响原表。
- 链式
df[x][y]:中间结果是否副本不确定,赋值行为不可靠。
原理流程
- 链式索引第一步选出列/行子集。
- 该子集视图或副本由内部规则决定。
- 在子集上赋值,可能写到副本,原表未变。
- pandas 检测到歧义链路并告警。
代码或图示
import pandas as pd
df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
# 危险:链式赋值
# df[df.a > 1]["b"] = 0
# 安全:单次 loc 定位
df.loc[df.a > 1, "b"] = 0
常见误区
- 直接忽略告警:写回静默失效,数据没更新。
- 继续用多层方括号:歧义链路没消除。
- 把告警当性能提示:它是正确性问题。
追问
- 告警根因是什么?答:链式索引下视图/副本不确定,赋值可能不回写原表。
- 怎么消除?答:用单次
loc同时定位行与列赋值。 - 视图和副本区别?答:视图共享底层数据,副本独立拷贝。
04.7.20.3-006 dtype 内存优化有哪些手段?
一句话结论
低基数文本列转 category,数值列按范围 downcast 到更小整型/浮点,布尔与日期用对应 dtype;优化后内存显著下降,代价是分类值不可随意新增、downcast 需确认不丢精度。
概念解释
- category:文本用整数编码 + 类别表,适合取值少的列。
- downcast:
integer/float把宽数值缩到能容纳的最小类型。 - 内存对比:优化前后用
df.memory_usage(deep=True)核对。
原理流程
- 统计各列唯一值数量与数值范围。
- 低基数文本转 category。
- 数值列按安全范围 downcast。
- 对比内存占用并验证数据未失真。
代码或图示
import pandas as pd
df = pd.DataFrame({"city": ["CN", "US", "CN"] * 100, "age": [30] * 300})
df["city"] = df["city"].astype("category")
df["age"] = pd.to_numeric(df["age"], downcast="integer")
print(df.memory_usage(deep=True).sum())
常见误区
- 高基数列也转 category:类别表膨胀,收益反转。
- downcast 不检查范围:数值截断丢精度。
- 优化后不核对结果:类型转换引入隐性错误。
追问
- category 适合什么列?答:唯一值少、重复度高的文本列。
- downcast 做什么?答:把数值缩到可容纳的最小整型/浮点类型。
- 怎么核对内存?答:
memory_usage(deep=True)对比优化前后。
04.7.20.3-007 read_csv 分块与 chunksize 怎么用?
一句话结论
大 CSV 一次性读入内存会 OOM,read_csv(chunksize=n) 返回迭代器,每次读 n 行组成 DataFrame,逐条处理或聚合后释放;配合 usecols 只读需要的列,进一步降低内存占用。
概念解释
- chunksize:每块行数,迭代产出 DataFrame。
- usecols:只读指定列,减少解析与内存。
- 分块聚合:每块累加统计量,不保留全量明细。
原理流程
- 估计文件行数与单行大小,确定块大小。
- 以 chunksize 迭代读取,逐块处理。
- 每块完成聚合/清洗后释放引用。
- 最终汇总各块结果。
代码或图示
import pandas as pd
total = 0
for chunk in pd.read_csv("big.csv", chunksize=10_000, usecols=["amount"]):
total += chunk["amount"].sum()
常见误区
- 把所有块 append 到列表:全量仍进内存,分块失去意义。
- 块大小过大:单块内存峰值仍高。
- 忽略列选择:不需要的列也被解析加载。
追问
- chunksize 返回什么?答:按块迭代的 DataFrame 迭代器。
- 怎么减少读取列?答:
usecols指定需要的列。 - 分块后结果怎么汇总?答:逐块累加统计量,不保留全量明细。
04.7.20.3-008 日期解析与 dtype 推断为什么会慢?
一句话结论
read_csv 默认逐列推断 dtype、解析日期,大文件上类型探测与日期正则解析开销明显;显式指定 dtype 与 parse_dates、延迟类型推断,可加快读取;日期列在读取后用 to_datetime 批量转换,比逐行解析可控。
概念解释
- 类型推断:扫描样本判断列类型,大文件重复扫描成本高。
- 日期解析:字符串转时间是 CPU 密集,逐行正则开销大。
- 显式 dtype:跳过推断,按声明类型直接解析。
原理流程
- 读取时声明各列 dtype,避免推断扫描。
- 日期列按需
parse_dates或读后to_datetime批量转换。 - 只加载必要列与必要块。
- 对比读取耗时与内存,确认未牺牲正确性。
代码或图示
import pandas as pd
df = pd.read_csv(
"data.csv",
dtype={"uid": "int64", "status": "category"},
parse_dates=["created_at"],
)
常见误区
- 依赖自动推断:列类型随数据漂移,结果不稳定。
- 大文件逐行
datetime.strptime:解析极慢,应批量to_datetime。 - 读取后才发现类型错:清洗返工成本高。
追问
- 怎么加快 CSV 读取?答:显式 dtype、指定 parse_dates、只取必要列。
- 日期批量转换用什么?答:
pd.to_datetime,比逐行解析快。 - 自动推断有什么问题?答:类型随样本漂移,结果不确定。
04.7.20.3-009 缺失值处理与填充传播要注意什么?
一句话结论
缺失值由 NaN/None/NA 表示,填充分向前/向后/常量/插值;ffill/bfill 会沿索引传播,分组内填充必须按组隔离,否则跨组补齐污染数据;填充策略要区分“真缺失”与“零值/空字符串”。
概念解释
- 识别:
isna()统计缺失,空字符串需单独判断。 - 填充:常量、前向、后向、时间插值。
- 分组填充:
groupby(...).ffill()只在组内传播。
原理流程
- 统计各列缺失比例与类型。
- 按业务区分缺失原因,选择填充策略。
- 分组场景在组内填充,避免跨组传播。
- 记录填充规则,结果可复现。
代码或图示
import pandas as pd
df = pd.DataFrame({
"city": ["A", "A", "B", "B"],
"price": [10, None, None, 30],
})
df["price"] = df.groupby("city")["price"].ffill()
常见误区
- 全局 ffill 跨组补齐:把其他组的值填进来。
- 把空字符串当非缺失:统计缺失比例失真。
- 插值不看时间间隔:等距插值套用到不规则时间序列出错。
追问
- 缺失值怎么识别?答:
isna(),空字符串需额外判断。 - 分组填充怎么做?答:
groupby(键)[列].ffill/bfill,组内传播。 - 插值适用什么数据?答:连续且间隔规则的序列。
04.7.20.3-010 重复索引与索引对齐会造成什么问题?
一句话结论
索引重复时,按标签选取返回多行,连接与匹配一对多放大结果;运算对齐按标签进行,两表索引不一致会产生 NA。操作前应检查索引唯一性,必要时重置索引或去重,避免隐式膨胀。
概念解释
- 重复索引:同一标签对应多行,选取结果非唯一。
- 对齐缺失:标签只在一侧出现,运算结果补 NA。
- 重置索引:
reset_index()把索引转回普通列。
原理流程
- 检查索引是否唯一、类型是否一致。
- 重复索引先去重或保留规则明确化。
- 连接/运算按标签对齐,核对 NA 来源。
- 需要位置访问时用
iloc或重置索引。
代码或图示
import pandas as pd
df = pd.DataFrame({"v": [1, 2]}, index=["x", "x"])
print(df.index.is_unique) # False
df = df.reset_index()
常见误区
- 重复索引直接 join:行数超出预期且难定位。
- 两表索引类型不同:标签看似相同实则匹配不上。
- 忽略对齐产生的 NA:把缺失当业务数据分析。
追问
- 怎么检查索引唯一?答:
index.is_unique。 - 对齐缺失会怎样?答:单侧标签补 NA。
- 索引怎么转回列?答:
reset_index()。
04.7.20.3-011 向量化与 iterrows/apply 性能差在哪?
一句话结论
向量化在底层批量操作整列数组,iterrows 逐行构造 Series、apply 逐行调用 Python 函数,都走 Python 层循环,数据量大时慢一到两个数量级;热点路径应优先用列运算、numpy 方法或 groupby 聚合,避免逐行迭代。
概念解释
- 向量化:操作下沉到 C/numpy 层,一次处理整块数据。
- iterrows:每行生成 Series 对象,对象开销大。
- apply:逐行回调 Python 函数,无法利用批量优化。
原理流程
- 识别循环里逐行取值计算的逻辑。
- 改写为列级表达式或 numpy 向量化方法。
- 分组统计用 groupby 聚合替代逐行累计。
- 对比耗时,确认结果一致。
代码或图示
import pandas as pd
df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
# 慢:逐行
# df["c"] = df.apply(lambda r: r.a * r.b, axis=1)
# 快:向量化
df["c"] = df["a"] * df["b"]
常见误区
- 把 apply 当 Pandas 惯用写法:逐行回调在大数据量下是性能瓶颈。
- iterrows 里再索引列:双重对象开销。
- 为小数据集纠结向量化:数据量小时代码可读性优先。
追问
- 为什么 iterrows 慢?答:每行构造 Series,Python 层对象开销大。
- 向量化快在哪?答:批量下沉到 C/numpy 层,避免逐行 Python 调用。
- 分组统计怎么替代逐行?答:groupby 聚合函数。
04.7.20.3-012 宽表与长表怎么用 melt/pivot 转换?
一句话结论
melt 把宽表列 unpivot 成长表(列名变变量、值变观测),pivot/pivot_table 把长表转回宽表;数据分析与绘图常需要长表,报表展示需要宽表,转换时注意重复键在 pivot 时需聚合。
概念解释
- melt:
id_vars保留列,其余列展开为variable/value两列。 - pivot:行/列/值三要素,重复组合用
pivot_table聚合。 - 形状转换不改数据值,只改变组织方式。
原理流程
- 判断下游需要长表还是宽表。
- 宽转长用 melt 指定保留列与展开列。
- 长转宽用 pivot,重复组合用 pivot_table 聚合。
- 检查转换后行列数与空值分布。
代码或图示
import pandas as pd
wide = pd.DataFrame({"uid": [1, 2], "q1": [10, 20], "q2": [15, 25]})
long = wide.melt(id_vars="uid", var_name="quarter", value_name="amount")
back = long.pivot_table(index="uid", columns="quarter", values="amount")
常见误区
- pivot 遇到重复组合直接报错:应先用 pivot_table 指定聚合。
- melt 漏选 id_vars:标识列也被展开成长值。
- 转换后不校验行数:误丢或重复观测。
追问
- melt 做什么?答:宽表 unpivot 为长表。
- pivot 重复组合怎么办?答:用
pivot_table加聚合函数。 - 什么场景用长表?答:分组绘图、聚合统计等按变量遍历的场景。
04.7.20.3-013 缺失与异常值怎么用 describe 统计?
一句话结论
describe() 给出数值列计数、均值、分位数与极值,配合 isna().sum() 看缺失;文本列用 describe(include="object") 看唯一值与众数;异常值通过分位数/IQR 或业务阈值识别,统计结果先理解分布再定清洗规则。
概念解释
- 数值统计:count/mean/std/min/分位数/max。
- 缺失统计:每列 NA 数量与比例。
- 文本统计:唯一值数量、最高频值。
原理流程
- 按数值/文本分别 describe。
- 统计各列缺失比例。
- 用分位数或业务规则识别异常值。
- 形成清洗规则并在数据管道固化。
代码或图示
import pandas as pd
df = pd.DataFrame({"a": [1, 2, None, 100], "b": ["x", "y", "x", "x"]})
print(df.describe(include="all"))
print(df.isna().sum())
常见误区
- 只看均值不看分位数:极端值把均值带偏。
- 异常值直接删除:先确认是错误还是业务极值。
- 缺失比例高的列直接丢弃:可能仍有分析价值。
追问
- describe 数值列包含什么?答:计数、均值、标准差、分位数、极值。
- 缺失怎么统计?答:
isna().sum()算每列 NA 数量。 - 文本列怎么看分布?答:
describe(include="object")看唯一值与众数。
04.7.20.3-014 内存超限怎么处理?
一句话结论
数据超过内存时分块读取、只取必要列、优化 dtype、按需聚合;仍超限则外置存储(数据库/列式文件)分批查询,不在单机内存里堆全量明细。Web 请求内不应加载大数据集,离线分析走批处理。
概念解释
- 降内存:列裁剪、dtype 优化、分类编码。
- 分块:chunksize 迭代,逐块聚合。
- 外置:数据库/Parquet 等列式存储做过滤与聚合下推。
原理流程
- 估算数据规模与单机内存余量。
- 裁剪列与行,优化类型,分块处理。
- 聚合结果落盘/入库,不保留全量。
- 超大规模迁移到外部存储与批处理框架。
代码或图示
import pandas as pd
agg = {}
for chunk in pd.read_csv("big.csv", chunksize=20_000, usecols=["city", "amount"]):
part = chunk.groupby("city")["amount"].sum()
agg = part.add(pd.Series(agg), fill_value=0)
常见误区
- 分块结果又 append 全量:内存没降下来。
- 在 Web 请求里读大文件:请求内存与响应时间不可控。
- 不做列裁剪:用不到的列白占内存。
追问
- 单机内存不够第一步做什么?答:裁列、优化 dtype、分块聚合。
- 全量明细放哪?答:数据库或列式文件,按需下推过滤聚合。
- 请求内适合跑大数据分析吗?答:不适合,应走离线批处理。
04.7.20.3-015 pandas 2.x 的 copy-on-write 规则是什么?
一句话结论
pandas 2.x 推进 copy-on-write(CoW):切片默认不立即复制,只有发生写入时才按需复制底层数据;这改变了“视图/副本”的判断规则,SettingWithCopyWarning 相关行为随之简化,升级旧代码要核对链式赋值与视图依赖。
概念解释
- CoW:读共享底层,写时复制,减少无谓拷贝。
- 旧规则:视图与副本由内部规则决定,歧义多。
- 兼容:依赖旧视图行为的代码在 CoW 下需改写。
原理流程
- 选取切片时共享底层数据,不立即拷贝。
- 对切片写入时触发按需复制。
- 原表与切片互不影响。
- 升级时检查链式赋值与视图假设。
代码或图示
import pandas as pd
df = pd.DataFrame({"a": [1, 2, 3]})
sub = df.loc[df.a > 1] # CoW 下共享底层
sub["a"] = 0 # 写入时按需复制
常见误区
- 按旧版本经验判断切片是否副本:CoW 语义已变。
- 链式赋值旧习惯不改:仍建议单次 loc 定位。
- 升级前不回归测试:视图依赖导致结果不一致。
追问
- CoW 核心思想?答:读共享、写时复制,减少无谓拷贝。
- 切片何时复制?答:发生写入时按需复制底层。
- 升级要检查什么?答:链式赋值与旧视图依赖代码。
04.7.20.3-016 merge 时键重复为什么会行膨胀?
一句话结论
连接键在一侧重复时,另一侧每个匹配键会与重复行逐一配对,形成一对多笛卡尔匹配,结果行数 = 两侧重复组合数;连接前应确认键唯一性,重复键先去重或明确配对规则,否则结果行数远超预期且难排查。
概念解释
- 一对一:行数匹配。
- 一对多:主表一行匹配从表多行,行数放大。
- 多对多:两侧都重复,行数按组合数膨胀。
原理流程
- 连接前检查两侧键是否唯一。
- 重复键确定保留规则(去重/最新一条/全部)。
- 执行 merge,核对结果行数与键组合。
- 膨胀结果回溯是哪一侧重复导致。
代码或图示
import pandas as pd
a = pd.DataFrame({"uid": [1, 1], "name": ["Ann", "Anna"]})
b = pd.DataFrame({"uid": [1, 1], "city": ["CN", "US"]})
# 多对多:4 行配对
merged = a.merge(b, on="uid")
常见误区
- 假设键天然唯一:业务重复数据没清洗。
- 连接后不核对行数:重复配对被当作正常结果。
- 去重不指定保留规则:随机保留一条丢数据。
追问
- 行膨胀怎么产生?答:重复键一对多/多对多逐一配对。
- 连接前先检查什么?答:两侧连接键唯一性。
- 重复键怎么处理?答:按业务去重或明确配对规则。
04.7.20.3-017 时间序列 resample 怎么做重采样?
一句话结论
resample 按时间规则聚合时序数据(按日/周/月均值、求和),类似时间维度的 groupby;需要先把时间列设为索引并排序,聚合规则匹配业务周期,注意时区与节假日边界。
概念解释
- 重采样:降采样聚合或升采样补全。
- 前提:索引为 datetime 且已排序。
- 聚合:
mean/sum/count等,可多函数聚合。
原理流程
- 时间列转 datetime 并设为索引、排序。
- 定义重采样频率(D/W/M)。
- 对各时间窗执行聚合函数。
- 核对窗口边界与缺失周期。
代码或图示
import pandas as pd
df = pd.DataFrame(
{"value": [1, 2, 3, 4]},
index=pd.to_datetime(["2026-11-16", "2026-11-17", "2026-11-18", "2026-11-19"]),
)
daily = df.resample("D").sum()
常见误区
- 时间索引未排序:resample 窗口计算错误。
- 升采样直接填充:缺失周期需按业务决定补值。
- 忽略时区:跨时区窗口边界偏移。
追问
- resample 类比什么?答:时间维度的 groupby 聚合。
- 使用前提?答:时间索引且已排序。
- 降采样常用聚合?答:sum、mean、count、max 等。
04.7.20.3-018 缺失 dtype 与可空整型怎么处理?
一句话结论
普通 int 列遇 NA 会被提升为 float,丢失整型语义;pandas 提供可空整型(Int64 等)保留整数与 NA,布尔缺失用可空布尔类型;读取与清洗时显式声明可空 dtype,避免数值列被静默转成浮点。
概念解释
- 类型提升:int 含 NA → float64;bool 含 NA → object/float。
- 可空类型:
Int64、boolean大写标记,支持 NA 且不转浮点。 - 读取时指定:
dtype={"uid": "Int64"}。
原理流程
- 识别含缺失的数值/布尔列。
- 声明可空 dtype,保留类型语义。
- 填充或转换后核对 dtype 与 NA 数量。
- 导出/入库前确认类型与下游兼容。
代码或图示
import pandas as pd
s = pd.Series([1, None, 3], dtype="Int64")
print(s.dtype, s.isna().sum())
常见误区
- 整型列变浮点后再转 int:NA 无法转整型报错。
- 用 float 存计数:精度与语义都不对。
- 不检查 dtype:下游接口类型不一致。
追问
- int 列有 NA 会怎样?答:被提升为 float64。
- 可空整型怎么写?答:
Int64(大写 I),支持 NA。 - 可空布尔类型?答:
boolean,区别于普通 bool。
04.7.20.3-019 numpy 广播规则与维度怎么对齐?
一句话结论
广播按维度从右往左对齐:维度相等或其中一方为 1 即可运算;形状不匹配且没有 1 维度则抛错;理解广播规则能判断数组运算是否按预期扩展,避免错误地按位置复制。
概念解释
- 对齐方向:从最后一维向前比较。
- 兼容条件:维度相等,或其一为 1。
- 扩展:1 维度沿该轴复制到匹配形状。
原理流程
- 比较两数组形状,从右往左逐维对齐。
- 维度相等或为 1 视为兼容。
- 1 维被广播扩展到对方大小。
- 不兼容维度抛出
ValueError。
代码或图示
import numpy as np
a = np.ones((3, 4))
b = np.array([1, 2, 3, 4]) # 形状 (4,) 广播到 (3, 4)
print(a + b)
常见误区
- 以为按行/列顺序硬对齐:广播按维度规则扩展。
- 形状差一维未补轴:对齐到错误维度。
- 广播结果不核对形状:静默得到错误数组。
追问
- 广播从哪个维度对齐?答:从最后一维(右)往左比较。
- 什么条件可广播?答:维度相等或其一为 1。
- 不兼容会怎样?答:抛形状不匹配错误。
04.7.20.3-020 向量化运算为什么要避免 Python 层循环?
一句话结论
numpy/pandas 向量化把计算下沉到连续内存上的批量操作,Python 层循环逐元素解释执行,循环开销与对象开销累积;热点路径用数组表达式、ufunc 与聚合方法,确需逐元素逻辑时再考虑 np.vectorize 或分组处理。
概念解释
- ufunc:逐元素内置函数,C 层批量执行。
- Python 循环:每次迭代解释调度,对象装箱拆箱。
- 连续内存:批量运算利用缓存与 SIMD 机会。
原理流程
- 找出逐元素循环逻辑。
- 改写为数组间表达式或 ufunc 调用。
- 分组/条件用掩码、where、groupby 处理。
- 基准对比耗时与结果一致性。
代码或图示
import numpy as np
x = np.arange(1_000_000)
y = np.arange(1_000_000)
# 快:向量化
z = x * y + np.sqrt(x)
常见误区
np.vectorize当加速手段:它仍是 Python 层循环封装。- 循环内频繁装箱取值:对象开销放大。
- 为可读性在大数据量上保留逐行写法:应先优化再抽象。
追问
- 向量化快的底层原因?答:批量下沉 C 层,连续内存减少装箱开销。
- np.vectorize 是向量化吗?答:不是,内部仍是 Python 循环。
- 条件逐元素怎么向量化?答:掩码、
np.where、布尔索引。
04.7.20.3-021 ndarray 内存布局 C/F order 有什么区别?
一句话结论
C order(行优先)按行连续存放,F order(列优先)按列连续存放;同一形状数组布局不同,连续维度的访问缓存命中率不同,大批量数值计算应匹配计算方向选择布局,ndarray.flags 可查看当前顺序。
概念解释
- 行优先:最后一维相邻,一行内元素连续。
- 列优先:第一维相邻,一列内元素连续。
- 布局影响 stride 与缓存局部性,不改变元素值。
原理流程
- 数组按指定 order 在内存分配连续块。
- 元素地址由 shape、stride 与 order 计算。
- 沿连续维度遍历缓存命中高。
- 大矩阵运算前检查布局是否匹配访问方向。
代码或图示
import numpy as np
a = np.arange(6).reshape((2, 3), order="C")
print(a.flags["C_CONTIGUOUS"], a.flags["F_CONTIGUOUS"])
常见误区
- 跨 order 频繁转置:非连续数组产生拷贝或低效访问。
- 忽略布局只看形状:性能差异在大矩阵上才明显。
- 假设数组一定连续:切片/转置后可能是非连续视图。
追问
- C 与 F order 分别怎么存?答:C 行优先,F 列优先。
- 布局影响什么?答:stride 与缓存命中,进而影响访问性能。
- 怎么查数组连续性?答:
flags.C_CONTIGUOUS/F_CONTIGUOUS。
04.7.20.3-022 视图与副本怎么区分?
一句话结论
切片、reshape(可行时)通常返回视图,共享底层数据;布尔索引、花式索引、copy() 产生副本;改视图影响原数组,改副本不影响。判断是否共享数据看 base 属性与 np.may_share_memory,赋值前不要假设。
概念解释
- 视图:同一数据块多个别名,修改互相影响。
- 副本:独立数据块,修改隔离。
- 共享判断:
base指向底层数组,may_share_memory检查重叠。
原理流程
- 切片/reshape 尝试构造视图。
- 索引方式无法视图化时复制数据。
- 通过
base与may_share_memory确认共享关系。 - 需要隔离显式
copy(),需要节省内存用视图。
代码或图示
import numpy as np
a = np.arange(6)
v = a[1:4] # 视图
c = a[[1, 3, 5]] # 副本
v[0] = 99
print(np.may_share_memory(a, v)) # True
常见误区
- 切片赋值后发现原表被改:以为是副本。
- 花式索引结果当视图:它总是副本。
- 依赖
base is None判断:非所有场景都可靠,配合 may_share_memory。
追问
- 哪些操作返回副本?答:花式索引、布尔索引、显式
copy()。 - 视图修改影响原数组吗?答:影响,共享底层数据。
- 怎么检查内存共享?答:
np.may_share_memory与base属性。
04.7.20.3-023 dtype 与类型提升规则是什么?
一句话结论
数组 dtype 决定元素存储类型,混合类型运算按 numpy 类型提升规则向更宽类型转换(如 int + float → float);提升结果可能超出预期位数,精度敏感场景要显式指定 dtype,避免静默升级到浮点或大类型。
概念解释
- 类型层级:bool < int < uint < float < complex,按宽者提升。
- 标量与数组运算:标量按规则参与提升。
- 显式 dtype:构造数组或运算时指定,锁定类型。
原理流程
- 参与运算的各值确定 dtype。
- 按提升规则选最宽类型作为结果 dtype。
- 元素转换到结果类型,可能丢失低位精度。
- 必要时构造时显式声明 dtype 并核对结果。
代码或图示
import numpy as np
x = np.array([1, 2, 3], dtype=np.int64)
y = np.array([1.5, 2.5, 3.5])
z = x + y
print(z.dtype) # float64
常见误区
- 整数运算结果变浮点:计数/序号语义被破坏。
- 大 int 提升后溢出:提升不解决范围溢出问题。
- 不显式指定 dtype:默认平台类型随环境变化。
追问
- 类型提升按什么方向?答:向更宽类型(int→float→complex)。
- int 加 float 结果是什么?答:float 数组。
- 怎么锁定类型?答:构造或运算时显式
dtype=。
04.7.20.3-024 花式索引为什么产生副本?
一句话结论
花式索引(整数数组/列表索引)按任意顺序取元素,结果位置与原数组不构成规则视图,因此总是返回副本;布尔索引同样按掩码挑选,结果也是副本。需要反复取值又想省内存时,应确认能否用切片替代。
概念解释
- 规则视图:连续/等步长切片可共享底层。
- 任意顺序选取:元素分散,无法用 stride 描述,必须拷贝。
- 副本开销:大数组花式索引产生额外内存与拷贝时间。
原理流程
- 索引对象为整数数组/列表,按顺序挑元素。
- 被选元素在内存中不连续,无法构造视图。
- numpy 复制选中元素到新数组。
- 结果与原数组独立修改。
代码或图示
import numpy as np
a = np.arange(10)
idx = [0, 3, 5, 8]
b = a[idx] # 副本
b[0] = -1
print(a[0]) # 不受影响
常见误区
- 大数组反复花式索引:拷贝开销累积,内存上涨。
- 把花式索引结果当视图赋值回原数组:隔离关系导致误解。
- 能用切片却用列表索引:放弃视图优化。
追问
- 花式索引返回视图还是副本?答:总是副本。
- 布尔索引呢?答:同样是副本。
- 省内存的替代?答:规则连续切片可返回视图。
04.7.20.3-025 数组连续内存与 stride 有什么关系?
一句话结论
stride 是每一维跨度的字节数,连续数组的 stride 与 shape、dtype 自洽;非连续视图(转置、切片)stride 不规则,访问效率低,必要时 np.ascontiguousarray 复制成连续布局再做批量计算。
概念解释
- stride:沿某维前进一个元素跳过的字节数。
- 连续:内存中元素按 order 紧密排列。
- 非连续:视图 stride 跳跃,缓存局部性差。
原理流程
- 数组分配时按 dtype 计算 stride 与 shape。
- 切片/转置调整 stride 形成视图。
- 批量计算前检查连续性,非连续则复制整理。
- 连续数组利用缓存与向量化指令。
代码或图示
import numpy as np
a = np.arange(12).reshape(3, 4)
print(a.strides)
b = a.T # 转置视图,stride 交换
c = np.ascontiguousarray(b)
常见误区
- 大矩阵转置后直接运算:非连续访问慢。
- 忽略 stride 猜测内存占用:视图可能不占新数据但访问低效。
- 盲目
ascontiguousarray:小数据拷贝成本可忽略,大数据才需要。
追问
- stride 是什么?答:每一维前进一元素的字节跨度。
- 非连续数组怎么整理?答:
np.ascontiguousarray复制成连续布局。 - 连续性影响什么?答:缓存命中与向量化访问效率。
04.7.20.3-026 openpyxl 处理大 xlsx 有什么内存问题?
一句话结论
openpyxl 默认把工作簿对象模型全载入内存,大文件行数多时内存暴涨;read_only=True 流式读取、write_only=True 只写模式可降低内存,样式与公式在只写模式下受限,超大表格优先考虑 CSV 或数据库导出。
概念解释
- 常规模式:单元格、样式、图表对象全部驻留内存。
- read_only:迭代行读取,不保留完整模型。
- write_only:追加写入,不能回读或随机修改。
原理流程
- 评估 xlsx 行数与体积,判断是否需要流式模式。
- 读取用 read_only 迭代行,处理完释放。
- 导出用 write_only 逐行追加。
- 超出 Excel 行/体积上限时改用 CSV/列式文件。
代码或图示
from openpyxl import load_workbook, Workbook
wb = load_workbook("big.xlsx", read_only=True)
ws = wb.active
for row in ws.iter_rows(values_only=True):
process(row)
out = Workbook(write_only=True)
ws2 = out.create_sheet("data")
ws2.append(["a", "b"])
常见误区
- 大文件用常规模式加载:内存 OOM。
- write_only 模式回读单元格:不支持随机访问。
- 把 Excel 当数据库存明细:行数与体积都有上限。
追问
- 大 xlsx 读取模式?答:
read_only=True流式迭代。 - 只写模式限制?答:不能回读/随机改,样式支持受限。
- 超大明细推荐什么格式?答:CSV 或列式/数据库存储。
04.7.20.3-027 csv 模块怎么做流式读写与编码?
一句话结论
标准库 csv 基于文件句柄逐行读写,reader/writer 迭代行记录,内存只保留当前行;打开文件必须指定 encoding="utf-8",处理中文/Excel 兼容编码按场景选择,字段含逗号、引号、换行由模块自动转义。
概念解释
- 流式:句柄迭代,不把整文件读入内存。
- 编码:读写两端一致,Excel 打开中文常用
utf-8-sig带 BOM。 - 转义:分隔符、引号、换行按 RFC 规则处理,不要手写拼接。
原理流程
- 以指定编码打开文件句柄。
csv.reader逐行解析为列表,csv.writer逐行写出。- 字段特殊字符由模块转义。
- 处理完一行释放该行引用。
代码或图示
import csv
with open("data.csv", "r", encoding="utf-8") as f:
for row in csv.reader(f):
process(row)
with open("out.csv", "w", encoding="utf-8-sig", newline="") as f:
w = csv.writer(f)
w.writerow(["name", "amount"])
常见误区
- 打开文件不指定编码:中文按系统默认解码乱码。
- 手写字符串拼 CSV:逗号/引号/换行破坏格式。
- 写文件漏
newline="":Windows 下出现空行。
追问
- csv 是整文件读入吗?答:不是,按句柄逐行流式读写。
- 中文 Excel 兼容用什么编码?答:
utf-8-sig带 BOM。 - 字段含逗号怎么办?答:csv 模块自动引号转义,不要手动拼。
04.7.20.3-028 大文件导出 CSV 与 xlsx 怎么选?
一句话结论
大批量明细导出优先 CSV:流式、体积小、兼容性广;xlsx 适合带样式、公式、多工作表的中小报表,受行列上限与内存限制。需要 Excel 打开的大数据量可 CSV 交付,或分页/分文件导出,不在单文件内堆全量。
概念解释
- CSV:纯文本流式,无样式,体积小,工具链通用。
- xlsx:二进制容器,支持样式/公式/多表,容量与内存有限。
- 分页导出:按批次生成文件或压缩包,控制单文件规模。
原理流程
- 评估导出行数、是否需要样式与公式。
- 纯明细大批量选 CSV 流式写出。
- 报表型小数据选 xlsx,保留展示能力。
- 超规模时分批/分文件,必要时打包下载。
代码或图示
import csv
with open("export.csv", "w", encoding="utf-8-sig", newline="") as f:
w = csv.writer(f)
w.writerow(["uid", "amount"])
for batch in iter_batches():
w.writerows(batch)
常见误区
- 十万行级数据导 xlsx:内存与文件体积超限。
- 先在内存拼全量再写文件:内存峰值等于全量明细。
- 给 CSV 套复杂样式需求:CSV 不支持,应改报表方案。
追问
- 大批量明细选什么?答:CSV,流式小体积。
- xlsx 适合什么?答:带样式公式的中小报表。
- 导出内存怎么控?答:分批写出,不保留全量明细。
04.7.20.3-029 Excel 公式与样式有什么代价?
一句话结论
样式(字体、填充、边框、数字格式)与公式随单元格存储,openpyxl 中每个样式对象占用内存,公式需要 Excel 打开后才计算;大表逐单元格套样式会显著增加文件体积与内存,导出报表应只在必要区域应用样式,避免整表格式化。
概念解释
- 样式存储:单元格级属性,重复样式应复用样式对象。
- 公式:写入的是表达式,openpyxl 不计算结果值。
- 体积来源:样式表、共享字符串、公式缓存。
原理流程
- 识别必须展示样式的区域(表头、合计行)。
- 复用同一格式对象,避免每格新建样式。
- 公式单元格记录表达式,结果由打开方计算。
- 评估文件体积,超规模去掉冗余样式。
代码或图示
from openpyxl import Workbook
from openpyxl.styles import Font
wb = Workbook(write_only=True)
ws = wb.create_sheet("data")
header_font = Font(bold=True)
# write_only 下样式支持有限,复杂报表用常规模式并复用样式对象
常见误区
- 逐格新建 Font/Fill 对象:样式对象重复占用内存。
- 以为 openpyxl 算出公式结果:读回的是公式字符串。
- 整表套边框颜色:文件体积无谓膨胀。
追问
- 样式代价在哪?答:单元格级样式对象占内存,增加文件体积。
- openpyxl 会计算公式吗?答:不会,结果由 Excel 打开后计算。
- 怎么降低样式成本?答:复用样式对象,只在必要区域应用。
04.7.20.3-030 marshmallow 的 schema 怎么做序列化与校验?
一句话结论
marshmallow 用 Schema 类声明字段与校验规则,load 把外部数据校验/转换为内部对象,dump 把内部对象序列化为输出字典;字段类型、必填、范围与自定义校验在 schema 集中声明,错误信息按字段聚合返回。
概念解释
- load:反序列化 + 校验,失败抛
ValidationError。 - dump:序列化输出,可控制字段子集。
- 字段:类型、必填、加载/序列化参数、嵌套 schema。
原理流程
- 定义 Schema,声明字段类型与校验规则。
- 外部数据
load,逐字段转换与校验。 - 聚合错误,通过后返回内部结构。
- 内部对象
dump生成对外字典。
代码或图示
from marshmallow import Schema, fields, ValidationError, validate
class UserSchema(Schema):
name = fields.Str(required=True, validate=validate.Length(min=1))
age = fields.Int(validate=validate.Range(min=0, max=150))
schema = UserSchema()
try:
data = schema.load({"name": "Ann", "age": 30})
except ValidationError as e:
print(e.messages)
常见误区
- 把业务规则塞进字段校验:复杂规则留服务层。
- dump 与 load 字段不一致:对外输出与内部模型脱节。
- 不聚合错误就中断:第一个错误返回,排查成本高。
追问
- load 与 dump 分别做什么?答:load 校验转换入参,dump 序列化输出。
- 校验错误怎么返回?答:
ValidationError.messages按字段聚合。 - 嵌套对象怎么声明?答:
fields.Nested(其他Schema)。
04.7.20.3-031 cerberus 字典式校验怎么用?
一句话结论
cerberus 用纯字典描述校验规则(类型、必填、范围、正则、依赖),validator.validate(document, schema) 返回布尔值,错误在 validator.errors;规则声明是数据结构而非类,适合配置字典、半结构化数据校验,类型表达能力弱于类 schema 库。
概念解释
- 规则字典:键名对应文档字段,值为规则映射。
- 校验结果:
validate成功与否,错误按字段收集。 - 适用:配置项、导入模板等字典形态数据。
原理流程
- 编写 schema 字典,声明字段规则。
- 构造 Validator 并校验文档。
- 失败读取
errors定位字段与原因。 - 通过后数据进入业务流程。
代码或图示
from cerberus import Validator
schema = {
"name": {"type": "string", "required": True, "minlength": 1},
"age": {"type": "integer", "min": 0, "max": 150},
}
v = Validator(schema)
if not v.validate({"name": "Ann", "age": 30}):
print(v.errors)
常见误区
- 用 cerberus 做复杂嵌套模型:类 schema 库更结构化。
- 校验失败不读 errors:只知道被拒,不知道原因。
- 规则字典里写业务逻辑:校验框架只做数据规则。
追问
- cerberus 规则用什么形式?答:纯字典映射,非类声明。
- 错误从哪里取?答:
validator.errors,按字段聚合。 - 适合什么数据?答:配置字典、半结构化导入数据。
04.7.20.3-032 voluptuous 类型化校验怎么用?
一句话结论
voluptuous 用 Python 类型与校验器组合声明 schema(Schema({字段: 类型/校验链})),校验失败抛 MultipleInvalid,消息含字段路径;它把规则写成可组合的 Python 表达式,介于字典规则与类模型之间,错误可逐级定位。
概念解释
- Schema 定义:字典 + 类型 + 校验函数链。
- 异常聚合:
MultipleInvalid包含子错误列表。 - 组合:校验器可复用、嵌套到子结构。
原理流程
- 定义 Schema 映射字段类型与规则。
- 调用校验函数验证输入。
- 失败捕获
MultipleInvalid,遍历子错误定位字段。 - 通过后按类型使用数据。
代码或图示
from voluptuous import Schema, MultipleInvalid, Range, Required
schema = Schema({
Required("name"): str,
Required("age"): int,
})
try:
schema({"name": "Ann", "age": 30})
except MultipleInvalid as e:
for err in e.errors:
print(err.path, err.msg)
常见误区
- 只抓异常不遍历子错误:字段定位信息丢失。
- 把 schema 当运行时类型模型:它只做校验转换。
- 校验链顺序混乱:先类型后规则更易定位错误。
追问
- voluptuous 错误异常类型?答:
MultipleInvalid,含子错误列表。 - 规则怎么组合?答:类型与校验器链式嵌套到 Schema 字典。
- 与 cerberus 区别?答:规则是 Python 表达式组合,非纯数据字典。
04.7.20.3-033 pydantic 2.x 与 marshmallow 怎么选型?
一句话结论
pydantic 2.x 基于类型注解做运行时校验与序列化,模型即类型,IDE/类型检查友好,FastAPI 等生态原生集成;marshmallow 显式 Schema 类,load/dump 分离,生态成熟、配置灵活。新项目与异步 Web 服务优先 pydantic,存量 marshmallow 集成可沿用。
概念解释
- pydantic:注解驱动,模型实例即校验后对象,v2 用
model_config/field_validator。 - marshmallow:Schema 与数据模型分离,load/dump 双向显式。
- 选型因素:类型生态、Web 框架集成、团队既有经验。
原理流程
- 评估框架集成(FastAPI 原生 pydantic)与类型需求。
- 新服务选 pydantic,注解声明字段与校验。
- 存量 schema 复杂、dump 定制多的场景保留 marshmallow。
- 校验失败统一转接口错误响应。
代码或图示
from pydantic import BaseModel, Field, field_validator
class User(BaseModel):
name: str = Field(min_length=1)
age: int = Field(ge=0, le=150)
@field_validator("name")
@classmethod
def strip_name(cls, v: str) -> str:
return v.strip()
常见误区
- pydantic v1 写法套到 v2:
Config内部类改为model_config。 - 校验规则全堆模型里:跨实体业务规则留服务层。
- 两库混用同一接口:数据模型与出口格式割裂。
追问
- pydantic v2 配置怎么写?答:
model_config,校验器用field_validator。 - marshmallow 优势?答:Schema 与模型分离,load/dump 定制灵活。
- FastAPI 用哪个?答:原生集成 pydantic。
04.7.20.3-034 校验错误信息怎么聚合与本地化?
一句话结论
校验失败应按字段路径聚合错误列表(字段、原因、约束值),一次性返回全部问题而非首个错误;错误消息按语言模板本地化,技术约束值(范围、长度)与面向用户的文案分离,接口返回结构固定便于前端展示与定位。
概念解释
- 聚合:同一输入多处错误一次收集。
- 路径:嵌套字段用点号/数组路径定位。
- 本地化:模板按语言渲染,参数化插入约束值。
原理流程
- 校验框架收集字段级错误。
- 汇总为统一错误结构(字段路径、消息、约束)。
- 按请求语言选择模板渲染文案。
- 接口返回错误列表,前端逐字段展示。
代码或图示
errors = [
{"field": "age", "msg": "年龄须在 0-150 之间", "constraint": {"min": 0, "max": 150}},
{"field": "name", "msg": "姓名不能为空"},
]
常见误区
- 遇到第一个错误就返回:用户要反复提交修正。
- 错误消息硬编码语言:多语言场景无法切换。
- 把内部异常栈直接返回前端:信息泄漏且不可读。
追问
- 错误为什么要聚合?答:一次性暴露全部问题,减少反复提交。
- 字段路径怎么表达?答:嵌套用点号或数组路径定位。
- 本地化怎么做?答:消息模板按语言渲染,约束值参数化插入。
04.7.20.3-035 protobuf 的 schema、版本兼容与编码特点是什么?
一句话结论
protobuf 用 .proto 定义消息结构与字段编号,编码为紧凑二进制,字段编号用于向后/向前兼容;新增字段带默认值不破坏旧端,删除/改类型需谨慎。性能与跨语言强,但不可读、需生成代码,调试成本高于 JSON。
概念解释
- 字段编号:序列化身份标识,不能随意复用或改号。
- 兼容规则:新端读旧消息忽略未知字段,旧端读新消息保留默认值。
- 编码:varint、长度前缀等二进制规则,体积小、解析快。
原理流程
- 编写 proto 定义,分配稳定字段编号。
- 生成各语言代码,编译消息。
- 传输二进制,对端按 schema 解码。
- 演进时新增可选字段,破坏性变更开新版本。
代码或图示
syntax = "proto3";
message Order {
string order_id = 1;
int64 amount = 2;
repeated string tags = 3;
}
常见误区
- 复用已删除字段编号:新旧数据解析错位。
- 字段类型随意改:兼容破坏,旧端解码出错。
- 用 protobuf 做对外公开 API:不可读、需提供 schema 与生成代码。
追问
- 字段编号作用?答:二进制中的身份标识,兼容演进的依据。
- 新增字段怎么保持兼容?答:可选/带默认值,旧端忽略未知。
- protobuf 缺点?答:不可读、需生成代码、调试成本高。
04.7.20.3-036 msgpack 二进制键值与 JSON 怎么互转?
一句话结论
msgpack 是二进制 KV 格式,结构类似 JSON(字符串、数值、数组、映射),体积与解析速度优于文本 JSON;两边可按结构互转,但类型表示与 JSON 非标准部分有差异,跨语言消费时需确认类型映射,调试时需工具解码。
概念解释
- 结构兼容:map/array/str/int/float/bool/nil 与 JSON 对应。
- 二进制:字段名不重复存储文本,体积更小。
- 差异:部分类型(二进制、扩展类型)JSON 无原生对应。
原理流程
- 用 msgpack 打包 Python 数据为二进制。
- 传输/存储二进制载荷。
- 对端按 msgpack 解码为结构。
- 需要文本 JSON 时再序列化为 JSON 字符串。
代码或图示
import msgpack
data = {"order_id": "O-1", "amount": 100, "tags": ["a", "b"]}
raw = msgpack.packb(data)
restored = msgpack.unpackb(raw, raw=False)
常见误区
- 假设 msgpack 与 JSON 类型完全等价:二进制/扩展类型需额外处理。
- 裸二进制直接给浏览器:需先转 JSON 或 Base64。
- 不记录格式:对端无法选择解包器。
追问
- msgpack 结构像什么?答:类似 JSON 的二进制键值结构。
- 相比 JSON 优势?答:体积更小、解析更快。
- 与 JSON 互转注意什么?答:类型映射差异与不可读调试。
04.7.20.3-037 avro 的 schema 演进与 JSON 差异是什么?
一句话结论
Apache Avro 用独立 schema 描述数据结构,数据与 schema 分离存储/传输,依赖 schema 解析;schema 演进有明确的兼容规则(新增/删除字段带默认值),常用于大数据序列化与消息存储;相比 JSON,Avro 二进制紧凑但需 schema registry 与解析工具。
概念解释
- schema 分离:数据不含字段名重复,schema 单独管理。
- 演进兼容:读 schema 与写 schema 匹配,可演化字段。
- 生态:大数据、流消息场景常用,配合 schema 注册表。
原理流程
- 编写 Avro schema 定义字段类型与默认值。
- 按写 schema 序列化数据,记录 schema 版本。
- 读端获取对应 schema 解码。
- 字段演进按兼容规则新增/删除,不破坏旧读写端。
代码或图示
{
"type": "record",
"name": "Order",
"fields": [
{"name": "order_id", "type": "string"},
{"name": "amount", "type": "long"},
{"name": "tags", "type": {"type": "array", "items": "string"}, "default": []}
]
}
常见误区
- 数据不带 schema 版本信息:读端无法选择解析规则。
- 删除字段不留默认值:旧写新读兼容破坏。
- 小服务引入 Avro:schema 管理成本高于收益。
追问
- Avro schema 存哪里?答:与数据分离,常由 schema 注册表管理。
- 兼容演进规则?答:新增/删除字段带默认值,读写字段可匹配。
- 适用什么场景?答:大数据、流消息等批量二进制序列化。
04.7.20.3-038 序列化格式选型矩阵怎么比?
一句话结论
选型按四个维度:可读性(JSON/文本优先)、性能与体积(二进制 protobuf/msgpack/Avro)、跨语言与生态、schema 强度(强 schema vs 动态字典)。对外公开接口用 JSON,内部高频 RPC 用二进制强 schema,调试与兼容优先文本。
概念解释
- 可读性:文本 JSON 可直接查看,二进制需工具解码。
- 性能:编码体积、编解码耗时、CPU 占用。
- schema:契约强度与演进治理成本。
原理流程
- 列出场景:调用方语言、报文大小、频率、调试需求。
- 对照可读性/性能/跨语言/schema 四维打分。
- 对外接口选 JSON,内部高频链路评估二进制。
- 保留格式标识与版本,便于演进替换。
代码或图示
公开 API / 浏览器直连 → JSON
内部高频 RPC / 强契约 → protobuf
轻量二进制键值 → msgpack
大数据批量存储 → Avro
常见误区
- 只压性能基准选格式:忽略可读性与调试成本。
- 对外接口用二进制:调用方接入门槛高。
- 格式混用不标识:对端无法选择解包方式。
追问
- 选型比哪四维?答:可读性、性能体积、跨语言生态、schema 强度。
- 公开接口推荐什么?答:JSON,可读且工具链通用。
- 内部高频 RPC 选什么?答:protobuf 等二进制强 schema 格式。
04.7.20.3-039 itertools 常用组合工具有哪些?
一句话结论
itertools 提供惰性迭代工具:chain 拼接迭代器、groupby 相邻分组、islice 切片、product 笛卡尔积、combinations/permutations 排列组合;全部惰性产出,不在内存建全量列表,适合管道处理与组合枚举。
概念解释
- 惰性:逐个产出元素,内存与迭代长度解耦。
- groupby 注意:仅对相邻相同元素分组,需先排序。
- 组合枚举:product/combinations/permutations 生成笛卡尔与子集。
原理流程
- 上游迭代器产出元素。
- itertools 工具按需转换/分组/枚举。
- 下游消费时才计算下一项。
- 结果按需收集,不一次性展开。
代码或图示
from itertools import chain, groupby, islice, product
combined = chain([1, 2], [3, 4])
groups = [(k, list(g)) for k, g in groupby("aabbcc")]
head = list(islice(range(100), 5))
pairs = list(product(["a", "b"], [1, 2]))
常见误区
- groupby 未排序:不相邻的相同元素被分成多组。
- 把迭代器多次遍历:耗尽后为空,需重新生成。
- 组合数量过大不设限:笛卡尔积枚举爆炸。
追问
- itertools 产出是惰性吗?答:是,按需逐个产出。
- groupby 前置条件?答:元素需先排序,只分相邻相同组。
- 笛卡尔积用哪个?答:
product。
04.7.20.3-040 more-itertools 扩展了什么,惰性怎么保持?
一句话结论
more-itertools 在 itertools 基础上提供分片、分块、窗口、批量消费、重复扫描等扩展工具;同样保持惰性迭代,除明确收集为列表外不在内存展开全量,适合复杂数据管道复用通用迭代逻辑。
概念解释
- 扩展能力:
chunked、windowed、batched、distinct、interleave等。 - 惰性原则:工具返回迭代器,消费时才计算。
- 复用:把管道中重复的分块/窗口逻辑封装为通用工具。
原理流程
- 引入 more-itertools 对应工具。
- 上游迭代器接入工具做分块/窗口/去重。
- 下游按批次消费,保持流式。
- 需要结果列表时再显式收集。
代码或图示
from more_itertools import chunked, windowed, batched
for batch in chunked(range(100), 10):
process(batch)
for triple in windowed(range(10), 3):
process(triple)
常见误区
- 工具结果直接
list()收集:惰性优势丢失,内存上涨。 - 迭代器被消费两次:第二次为空。
- 为简单循环引入重依赖:标准 itertools 已够时不必加库。
追问
- more-itertools 补哪些能力?答:分块、窗口、批量、去重、交错等。
- 它保持惰性吗?答:保持,除非显式收集为列表。
- 什么时候不必引入?答:标准 itertools 能覆盖的简单场景。
04.7.20.3-041 生成器怎么构建内存友好的数据管道?
一句话结论
用生成器函数/表达式逐级传递迭代器:读取 → 清洗 → 转换 → 写出,每级只保留当前批次/元素,内存不随全量数据增长;管道各段解耦,可单独测试与复用,大数据集避免一次性载入列表。
概念解释
- 生成器:
yield按需产出,状态在迭代间保留。 - 管道分段:每段接收迭代器、返回迭代器。
- 背压:下游消费速度决定上游产出节奏。
原理流程
- 数据源生成器逐行/逐批产出记录。
- 清洗转换生成器逐项加工。
- 写出生成器批量落库/落盘。
- 任一段不保留全量引用,控制内存峰值。
代码或图示
def read_rows(path):
with open(path, encoding="utf-8") as f:
for line in f:
yield parse(line)
def clean(rows):
for row in rows:
if valid(row):
yield normalize(row)
for row in clean(read_rows("data.csv")):
save(row)
常见误区
- 管道中段
list()收全量:内存峰值回到全量大小。 - 生成器内做重阻塞 IO:拖慢整条管道。
- 不处理异常:一段中断后下游静默停止。
追问
- 生成器为什么省内存?答:按需 yield,不保留全量元素。
- 管道怎么分段?答:每段接收迭代器、返回迭代器,逐级加工。
- 背压怎么体现?答:下游消费慢,上游产出被节奏限制。
04.7.20.3-042 脏数据清洗管道怎么设计?
一句话结论
清洗管道按“识别 → 标准化 → 校验 → 隔离”组织:先统计缺失/异常/格式问题,标准化编码、空白、日期与数值格式,规则校验后分流入库或隔离区;每步记录清洗规则与被丢弃原因,保证可追溯与可复现。
概念解释
- 识别:缺失、重复、类型不符、范围异常、格式不规范。
- 标准化:去空白、统一大小写/编码、日期数值归一。
- 隔离:不合规数据进隔离区,不污染主数据集。
原理流程
- 抽样与全量统计数据质量问题分布。
- 编写标准化规则并在管道应用。
- 校验规则分流:合格入库,异常进隔离区并记录原因。
- 清洗结果复核,规则版本化保留。
代码或图示
def normalize(row):
row["name"] = str(row["name"]).strip().title()
row["email"] = str(row["email"]).lower()
return row
def clean_pipeline(rows):
for row in rows:
row = normalize(row)
if valid(row):
yield ("ok", row)
else:
yield ("reject", row)
常见误区
- 清洗规则散落在业务代码:不可复用、难追溯。
- 静默丢弃异常数据:没有原因记录,无法回溯。
- 先入库再清洗:脏数据污染下游分析与接口。
追问
- 清洗分哪几步?答:识别、标准化、校验、隔离。
- 不合规数据放哪?答:隔离区并记录拒绝原因。
- 规则怎么保留?答:版本化管道脚本与清洗日志。
04.7.20.3-043 分组聚合中的空组与 NA 怎么处理?
一句话结论
分组时未出现在数据中的键不会自动成组,聚合结果对 NA 列默认跳过;需要保留全部分组键时用 reindex/unstack 补全,NA 填充按业务约定(0、前值、标记缺失),分组内填充不能跨组传播。
概念解释
- 空组:键无成员,groupby 结果不含该组。
- NA 聚合:数值聚合默认跳过 NA,计数需区分计数与非空计数。
- 补全:按完整键索引 reindex,显式填充。
原理流程
- 明确是否需要保留未出现的分组键。
- 聚合后按完整键 reindex/unstack 补全空组。
- NA 按业务规则填充,分组内隔离填充。
- 核对组数量、NA 数量与预期一致。
代码或图示
import pandas as pd
df = pd.DataFrame({"city": ["A", "A"], "amount": [10, None]})
agg = df.groupby("city")["amount"].sum()
all_cities = ["A", "B"]
agg = agg.reindex(all_cities, fill_value=0)
常见误区
- 以为 groupby 列出所有可能键:未出现的组被省略。
- 全局填充跨组补齐:污染其他分组数据。
- 计数把 NA 计入:
count是非空计数,需与行数区分。
追问
- 未出现的分组键会成组吗?答:不会,需 reindex 补全。
- NA 聚合默认行为?答:数值聚合跳过 NA,count 只计非空。
- 分组填充边界?答:只在组内传播,不能跨组补齐。
04.7.20.3-044 表格库在 Web 服务中怎么定位?
一句话结论
pandas/numpy 适合离线分析、批处理与数据加工,不建议在请求内做大数据集计算:请求内存、延迟与并发都不可控。Web 接口应在数据库/缓存层过滤聚合,只返回结构化小结果;报表导出走异步任务与流式文件。
概念解释
- 请求内计算:并发放大内存与 CPU 峰值,影响在线稳定性。
- 离线批处理:调度任务批量加工,结果落库/落盘。
- 导出场景:异步生成文件,前端轮询或下载链接。
原理流程
- 判断需求是在线查询还是离线分析。
- 在线接口用 SQL/缓存做过滤聚合,返回小结果集。
- 大数据加工走批处理任务,结果预计算。
- 大导出异步生成流式文件,不阻塞请求线程。
代码或图示
在线请求:DB 查询/聚合 → 小结果 JSON
离线任务:pandas/numpy 批处理 → 结果入库/文件
大导出:异步任务流式生成 CSV → 下载链接
常见误区
- 请求里读大文件转 DataFrame:内存与延迟失控。
- 实时报表依赖内存计算:并发一高就 OOM。
- 同步等待大导出:请求挂起占用 worker。
追问
- 表格库适合在线请求吗?答:不适合大数据集计算,应离线/批处理。
- 在线聚合放哪层?答:数据库或缓存层过滤聚合。
- 大导出怎么做?答:异步任务流式生成,提供下载链接。
04.7.20.3-045 怎么定位 pandas/numpy 性能瓶颈?
一句话结论
先用计时剖析区分耗时在读取、转换、聚合还是 IO;逐段测量各步耗时与内存占用,热点通常是逐行循环、全量拷贝、重复索引与未优化 dtype;定位后按向量化、分组聚合、分块与类型优化顺序改造,并用基准对比验证。
概念解释
- 分段计时:read/clean/groupby/export 各段单独测量。
- 内存剖析:峰值内存、副本数量、dtype 占用。
- 常见热点:iterrows/apply、链式索引、花式索引拷贝、宽类型数值列。
原理流程
- 端到端计时,拆解各阶段耗时占比。
- 定位热点函数与数据规模。
- 检查是否逐行循环、冗余拷贝、类型未优化。
- 改造后回归基准,确认耗时与内存下降且结果一致。
代码或图示
import time
start = time.perf_counter()
df = pd.read_csv("data.csv")
t_read = time.perf_counter() - start
start = time.perf_counter()
result = df.groupby("city")["amount"].sum()
t_agg = time.perf_counter() - start
print(f"read={t_read:.3f}s agg={t_agg:.3f}s")
常见误区
- 凭感觉优化:没有分段计时就改代码。
- 只看耗时不看内存:拷贝导致的内存增长被忽略。
- 优化后不校验结果:速度上去了数据出错。
追问
- 第一步怎么定位?答:分段计时,拆解各阶段耗时占比。
- 常见热点有哪些?答:逐行循环、冗余拷贝、链式索引、宽 dtype。
- 优化顺序?答:向量化 → 分组聚合 → 分块 → 类型优化,基准验证。
本节高频题
- 索引/切片与链式索引(001、002)
- groupby 拆分应用合并(003)
- merge/join/concat 与键重复膨胀(004、016)
- SettingWithCopyWarning 成因(005)
- dtype 内存优化与分块读取(006、007、014)
- 可空 dtype 与类型提升(018、023)
- 向量化与 Python 循环(011、020)
- 视图/副本与内存布局(021、022、024、025)
- openpyxl/csv 流式读写(026、027、028)
- marshmallow/cerberus/voluptuous/pydantic 选型(030、031、032、033)
- protobuf/msgpack/avro 选型(035、036、037、038)
- itertools/more-itertools 与生成器管道(039、040、041)
- 在线请求 vs 离线批处理定位(044)