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

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,而非按位置硬对齐。
  • 索引可命名、可重复,重复索引在连接时会放大行数。

原理流程

  1. 数据按列装入 DataFrame,生成行索引与列标签。
  2. 选取/运算时按索引标签对齐元素。
  3. 分组、连接以索引或指定列为键。
  4. 索引质量(唯一、类型一致)决定结果是否可靠。

代码或图示

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 风格不含右端点。
  • 链式索引:先选列再选行,中间结果可能是副本,写回不生效。

原理流程

  1. 明确选取依据是标签还是位置。
  2. 标签用 loc,位置用 iloc,单列用 df["col"]。
  3. 赋值定位到单次 loc,避免多层方括号。
  4. 检查写回是否落在原数据上。

代码或图示

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):结果按分组键拼回,索引对齐。

原理流程

  1. 指定分组键(列/列表/函数)。
  2. pandas 计算每组成员索引。
  3. 对组内数据执行聚合或转换。
  4. 结果按组键合并为新 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:不做匹配,直接沿轴拼接,需索引/列对齐。

原理流程

  1. 判断需求:按键匹配连接还是直接堆叠。
  2. 连接选 merge/join,选 how 保留匹配行。
  3. 堆叠选 concat,指定轴与去重/对齐方式。
  4. 检查连接后行数与键唯一性。

代码或图示

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]:中间结果是否副本不确定,赋值行为不可靠。

原理流程

  1. 链式索引第一步选出列/行子集。
  2. 该子集视图或副本由内部规则决定。
  3. 在子集上赋值,可能写到副本,原表未变。
  4. 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) 核对。

原理流程

  1. 统计各列唯一值数量与数值范围。
  2. 低基数文本转 category。
  3. 数值列按安全范围 downcast。
  4. 对比内存占用并验证数据未失真。

代码或图示

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:只读指定列,减少解析与内存。
  • 分块聚合:每块累加统计量,不保留全量明细。

原理流程

  1. 估计文件行数与单行大小,确定块大小。
  2. 以 chunksize 迭代读取,逐块处理。
  3. 每块完成聚合/清洗后释放引用。
  4. 最终汇总各块结果。

代码或图示

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:跳过推断,按声明类型直接解析。

原理流程

  1. 读取时声明各列 dtype,避免推断扫描。
  2. 日期列按需 parse_dates 或读后 to_datetime 批量转换。
  3. 只加载必要列与必要块。
  4. 对比读取耗时与内存,确认未牺牲正确性。

代码或图示

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() 只在组内传播。

原理流程

  1. 统计各列缺失比例与类型。
  2. 按业务区分缺失原因,选择填充策略。
  3. 分组场景在组内填充,避免跨组传播。
  4. 记录填充规则,结果可复现。

代码或图示

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() 把索引转回普通列。

原理流程

  1. 检查索引是否唯一、类型是否一致。
  2. 重复索引先去重或保留规则明确化。
  3. 连接/运算按标签对齐,核对 NA 来源。
  4. 需要位置访问时用 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 函数,无法利用批量优化。

原理流程

  1. 识别循环里逐行取值计算的逻辑。
  2. 改写为列级表达式或 numpy 向量化方法。
  3. 分组统计用 groupby 聚合替代逐行累计。
  4. 对比耗时,确认结果一致。

代码或图示

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 聚合。
  • 形状转换不改数据值,只改变组织方式。

原理流程

  1. 判断下游需要长表还是宽表。
  2. 宽转长用 melt 指定保留列与展开列。
  3. 长转宽用 pivot,重复组合用 pivot_table 聚合。
  4. 检查转换后行列数与空值分布。

代码或图示

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 数量与比例。
  • 文本统计:唯一值数量、最高频值。

原理流程

  1. 按数值/文本分别 describe。
  2. 统计各列缺失比例。
  3. 用分位数或业务规则识别异常值。
  4. 形成清洗规则并在数据管道固化。

代码或图示

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 等列式存储做过滤与聚合下推。

原理流程

  1. 估算数据规模与单机内存余量。
  2. 裁剪列与行,优化类型,分块处理。
  3. 聚合结果落盘/入库,不保留全量。
  4. 超大规模迁移到外部存储与批处理框架。

代码或图示

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 下需改写。

原理流程

  1. 选取切片时共享底层数据,不立即拷贝。
  2. 对切片写入时触发按需复制。
  3. 原表与切片互不影响。
  4. 升级时检查链式赋值与视图假设。

代码或图示

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 时键重复为什么会行膨胀?

一句话结论

连接键在一侧重复时,另一侧每个匹配键会与重复行逐一配对,形成一对多笛卡尔匹配,结果行数 = 两侧重复组合数;连接前应确认键唯一性,重复键先去重或明确配对规则,否则结果行数远超预期且难排查。

概念解释

  • 一对一:行数匹配。
  • 一对多:主表一行匹配从表多行,行数放大。
  • 多对多:两侧都重复,行数按组合数膨胀。

原理流程

  1. 连接前检查两侧键是否唯一。
  2. 重复键确定保留规则(去重/最新一条/全部)。
  3. 执行 merge,核对结果行数与键组合。
  4. 膨胀结果回溯是哪一侧重复导致。

代码或图示

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 等,可多函数聚合。

原理流程

  1. 时间列转 datetime 并设为索引、排序。
  2. 定义重采样频率(D/W/M)。
  3. 对各时间窗执行聚合函数。
  4. 核对窗口边界与缺失周期。

代码或图示

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"}。

原理流程

  1. 识别含缺失的数值/布尔列。
  2. 声明可空 dtype,保留类型语义。
  3. 填充或转换后核对 dtype 与 NA 数量。
  4. 导出/入库前确认类型与下游兼容。

代码或图示

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. 比较两数组形状,从右往左逐维对齐。
  2. 维度相等或为 1 视为兼容。
  3. 1 维被广播扩展到对方大小。
  4. 不兼容维度抛出 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 机会。

原理流程

  1. 找出逐元素循环逻辑。
  2. 改写为数组间表达式或 ufunc 调用。
  3. 分组/条件用掩码、where、groupby 处理。
  4. 基准对比耗时与结果一致性。

代码或图示

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 与缓存局部性,不改变元素值。

原理流程

  1. 数组按指定 order 在内存分配连续块。
  2. 元素地址由 shape、stride 与 order 计算。
  3. 沿连续维度遍历缓存命中高。
  4. 大矩阵运算前检查布局是否匹配访问方向。

代码或图示

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 检查重叠。

原理流程

  1. 切片/reshape 尝试构造视图。
  2. 索引方式无法视图化时复制数据。
  3. 通过 base 与 may_share_memory 确认共享关系。
  4. 需要隔离显式 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:构造数组或运算时指定,锁定类型。

原理流程

  1. 参与运算的各值确定 dtype。
  2. 按提升规则选最宽类型作为结果 dtype。
  3. 元素转换到结果类型,可能丢失低位精度。
  4. 必要时构造时显式声明 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 描述,必须拷贝。
  • 副本开销:大数组花式索引产生额外内存与拷贝时间。

原理流程

  1. 索引对象为整数数组/列表,按顺序挑元素。
  2. 被选元素在内存中不连续,无法构造视图。
  3. numpy 复制选中元素到新数组。
  4. 结果与原数组独立修改。

代码或图示

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 跳跃,缓存局部性差。

原理流程

  1. 数组分配时按 dtype 计算 stride 与 shape。
  2. 切片/转置调整 stride 形成视图。
  3. 批量计算前检查连续性,非连续则复制整理。
  4. 连续数组利用缓存与向量化指令。

代码或图示

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:追加写入,不能回读或随机修改。

原理流程

  1. 评估 xlsx 行数与体积,判断是否需要流式模式。
  2. 读取用 read_only 迭代行,处理完释放。
  3. 导出用 write_only 逐行追加。
  4. 超出 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 规则处理,不要手写拼接。

原理流程

  1. 以指定编码打开文件句柄。
  2. csv.reader 逐行解析为列表,csv.writer 逐行写出。
  3. 字段特殊字符由模块转义。
  4. 处理完一行释放该行引用。

代码或图示

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:二进制容器,支持样式/公式/多表,容量与内存有限。
  • 分页导出:按批次生成文件或压缩包,控制单文件规模。

原理流程

  1. 评估导出行数、是否需要样式与公式。
  2. 纯明细大批量选 CSV 流式写出。
  3. 报表型小数据选 xlsx,保留展示能力。
  4. 超规模时分批/分文件,必要时打包下载。

代码或图示

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 不计算结果值。
  • 体积来源:样式表、共享字符串、公式缓存。

原理流程

  1. 识别必须展示样式的区域(表头、合计行)。
  2. 复用同一格式对象,避免每格新建样式。
  3. 公式单元格记录表达式,结果由打开方计算。
  4. 评估文件体积,超规模去掉冗余样式。

代码或图示

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。

原理流程

  1. 定义 Schema,声明字段类型与校验规则。
  2. 外部数据 load,逐字段转换与校验。
  3. 聚合错误,通过后返回内部结构。
  4. 内部对象 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 成功与否,错误按字段收集。
  • 适用:配置项、导入模板等字典形态数据。

原理流程

  1. 编写 schema 字典,声明字段规则。
  2. 构造 Validator 并校验文档。
  3. 失败读取 errors 定位字段与原因。
  4. 通过后数据进入业务流程。

代码或图示

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 包含子错误列表。
  • 组合:校验器可复用、嵌套到子结构。

原理流程

  1. 定义 Schema 映射字段类型与规则。
  2. 调用校验函数验证输入。
  3. 失败捕获 MultipleInvalid,遍历子错误定位字段。
  4. 通过后按类型使用数据。

代码或图示

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 框架集成、团队既有经验。

原理流程

  1. 评估框架集成(FastAPI 原生 pydantic)与类型需求。
  2. 新服务选 pydantic,注解声明字段与校验。
  3. 存量 schema 复杂、dump 定制多的场景保留 marshmallow。
  4. 校验失败统一转接口错误响应。

代码或图示

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 校验错误信息怎么聚合与本地化?

一句话结论

校验失败应按字段路径聚合错误列表(字段、原因、约束值),一次性返回全部问题而非首个错误;错误消息按语言模板本地化,技术约束值(范围、长度)与面向用户的文案分离,接口返回结构固定便于前端展示与定位。

概念解释

  • 聚合:同一输入多处错误一次收集。
  • 路径:嵌套字段用点号/数组路径定位。
  • 本地化:模板按语言渲染,参数化插入约束值。

原理流程

  1. 校验框架收集字段级错误。
  2. 汇总为统一错误结构(字段路径、消息、约束)。
  3. 按请求语言选择模板渲染文案。
  4. 接口返回错误列表,前端逐字段展示。

代码或图示

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、长度前缀等二进制规则,体积小、解析快。

原理流程

  1. 编写 proto 定义,分配稳定字段编号。
  2. 生成各语言代码,编译消息。
  3. 传输二进制,对端按 schema 解码。
  4. 演进时新增可选字段,破坏性变更开新版本。

代码或图示

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 无原生对应。

原理流程

  1. 用 msgpack 打包 Python 数据为二进制。
  2. 传输/存储二进制载荷。
  3. 对端按 msgpack 解码为结构。
  4. 需要文本 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 注册表。

原理流程

  1. 编写 Avro schema 定义字段类型与默认值。
  2. 按写 schema 序列化数据,记录 schema 版本。
  3. 读端获取对应 schema 解码。
  4. 字段演进按兼容规则新增/删除,不破坏旧读写端。

代码或图示

{
  "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:契约强度与演进治理成本。

原理流程

  1. 列出场景:调用方语言、报文大小、频率、调试需求。
  2. 对照可读性/性能/跨语言/schema 四维打分。
  3. 对外接口选 JSON,内部高频链路评估二进制。
  4. 保留格式标识与版本,便于演进替换。

代码或图示

公开 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 生成笛卡尔与子集。

原理流程

  1. 上游迭代器产出元素。
  2. itertools 工具按需转换/分组/枚举。
  3. 下游消费时才计算下一项。
  4. 结果按需收集,不一次性展开。

代码或图示

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 等。
  • 惰性原则:工具返回迭代器,消费时才计算。
  • 复用:把管道中重复的分块/窗口逻辑封装为通用工具。

原理流程

  1. 引入 more-itertools 对应工具。
  2. 上游迭代器接入工具做分块/窗口/去重。
  3. 下游按批次消费,保持流式。
  4. 需要结果列表时再显式收集。

代码或图示

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 按需产出,状态在迭代间保留。
  • 管道分段:每段接收迭代器、返回迭代器。
  • 背压:下游消费速度决定上游产出节奏。

原理流程

  1. 数据源生成器逐行/逐批产出记录。
  2. 清洗转换生成器逐项加工。
  3. 写出生成器批量落库/落盘。
  4. 任一段不保留全量引用,控制内存峰值。

代码或图示

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 脏数据清洗管道怎么设计?

一句话结论

清洗管道按“识别 → 标准化 → 校验 → 隔离”组织:先统计缺失/异常/格式问题,标准化编码、空白、日期与数值格式,规则校验后分流入库或隔离区;每步记录清洗规则与被丢弃原因,保证可追溯与可复现。

概念解释

  • 识别:缺失、重复、类型不符、范围异常、格式不规范。
  • 标准化:去空白、统一大小写/编码、日期数值归一。
  • 隔离:不合规数据进隔离区,不污染主数据集。

原理流程

  1. 抽样与全量统计数据质量问题分布。
  2. 编写标准化规则并在管道应用。
  3. 校验规则分流:合格入库,异常进隔离区并记录原因。
  4. 清洗结果复核,规则版本化保留。

代码或图示

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,显式填充。

原理流程

  1. 明确是否需要保留未出现的分组键。
  2. 聚合后按完整键 reindex/unstack 补全空组。
  3. NA 按业务规则填充,分组内隔离填充。
  4. 核对组数量、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 峰值,影响在线稳定性。
  • 离线批处理:调度任务批量加工,结果落库/落盘。
  • 导出场景:异步生成文件,前端轮询或下载链接。

原理流程

  1. 判断需求是在线查询还是离线分析。
  2. 在线接口用 SQL/缓存做过滤聚合,返回小结果集。
  3. 大数据加工走批处理任务,结果预计算。
  4. 大导出异步生成流式文件,不阻塞请求线程。

代码或图示

在线请求:DB 查询/聚合 → 小结果 JSON
离线任务:pandas/numpy 批处理 → 结果入库/文件
大导出:异步任务流式生成 CSV → 下载链接

常见误区

  • 请求里读大文件转 DataFrame:内存与延迟失控。
  • 实时报表依赖内存计算:并发一高就 OOM。
  • 同步等待大导出:请求挂起占用 worker。

追问

  • 表格库适合在线请求吗?答:不适合大数据集计算,应离线/批处理。
  • 在线聚合放哪层?答:数据库或缓存层过滤聚合。
  • 大导出怎么做?答:异步任务流式生成,提供下载链接。

04.7.20.3-045 怎么定位 pandas/numpy 性能瓶颈?

一句话结论

先用计时剖析区分耗时在读取、转换、聚合还是 IO;逐段测量各步耗时与内存占用,热点通常是逐行循环、全量拷贝、重复索引与未优化 dtype;定位后按向量化、分组聚合、分块与类型优化顺序改造,并用基准对比验证。

概念解释

  • 分段计时:read/clean/groupby/export 各段单独测量。
  • 内存剖析:峰值内存、副本数量、dtype 占用。
  • 常见热点:iterrows/apply、链式索引、花式索引拷贝、宽类型数值列。

原理流程

  1. 端到端计时,拆解各阶段耗时占比。
  2. 定位热点函数与数据规模。
  3. 检查是否逐行循环、冗余拷贝、类型未优化。
  4. 改造后回归基准,确认耗时与内存下降且结果一致。

代码或图示

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)