---
tags: [AI, python, pandas, 数据清洗]
阶段: 02-Python与数据处理
难度: ★★☆
created: 2026-10-18
related: "[[NumPy向量化]], [[数据工程入门]], [[模型评估与交叉验证]]"
---

# Pandas数据清洗

## 定义

**数据清洗**是在保留数据语义约束的前提下，将原始表格转换为类型明确、键唯一、缺失值与异常值均有显式处理、且变换过程可复核的表格的过程。清洗不改变观测的物理含义，只消除表示层与录入层的缺陷。

设原始表有 $n$ 行、$m$ 列，记作 $X\in\mathbb{R}^{n\times m}$ 的数值部分与 $C=\{c_1,\dots,c_m\}$ 的列名部分。本文使用以下对象与符号。

- **Series**：一维带标签数组，由值向量 $v\in\mathbb{R}^{n}$、索引 $I=(i_1,\dots,i_n)$、类型 $d$ 三元组构成，记作 $s=(v,I,d)$。索引标签可重复，但重复标签会使按标签取值返回多行。
- **DataFrame**：列名到 Series 的映射 $D=\{c_j\mapsto s_j\}_{j=1}^{m}$，所有 $s_j$ 共享同一索引 $I$。因此 DataFrame 的每一列有独立 dtype，行由索引标签标识。
- **索引**（index）：不可变的标签序列，其中每个标签可哈希。索引本身不可原地修改，改名须用 `rename` 生成新对象。
- **标签**（label）与**位置**（position）：标签是索引中的值，位置是 $0$ 到 $n-1$ 的整数偏移。二者在整数索引下可能数值相同而语义不同。
- **缺失值**：浮点列的 `NaN`、可空类型列的 `pd.NA`、对象列的 `None`，统一由 `isna` 识别。
- **清洗后的表**须满足：主键唯一；每列 dtype 与语义一致；缺失值要么被删除、要么被填充并留下指示列；异常值要么被修正、要么被标记；每一步的行列数变化可复算。

## 为什么重要

原始业务表通常同时含有重复、缺失、类型错位与录入异常四类缺陷，它们沿数据流向下游放大，且多数不会报错。

- 重复行若同时进入训练集与测试集，测试集就包含训练时已见过的样本，模型对其预测接近记忆结果，离线指标被高估，线上表现回落。这是数据泄漏中最隐蔽的一类。
- 用均值填充缺失会压缩方差。设缺失比例为 $p$、原变量标准差为 $\sigma$，均值填充后标准差约为 $\sqrt{1-p}\,\sigma$；相关系数与标准化系数按 $\sqrt{1-p}$ 缩小，距离度量随之失真。
- 类型错位使排序、比较、聚合返回错误结果。同一列混入字符串 `"19.9"` 后 dtype 退化为 `object`，排序按字典序而非数值序，`sum` 等聚合抛出 `TypeError`，内存也从紧凑数组变为指针数组。
- 多对多合并会按笛卡尔积放大行数，使某些样本在训练中被重复加权，模型实际优化的是被扭曲的分布。
- 清洗步骤若不可复算，同一份原始数据在不同时间会产出不同训练集，实验无法复现。

在本书结构中，本篇承接 [[NumPy向量化]] 的数组语义，向下为 [[数据工程入门]] 的管道与版本管理提供单机实现，为 [[模型评估与交叉验证]] 的划分纪律提供前置约束。

## 原理与推导

### 1 Series、DataFrame 与索引

DataFrame 在内存中按列分块存储，每列一块同构数组，因而列内 dtype 一致、列间可以不同。这一布局带来三个后果：按列选取是零拷贝或轻拷贝；跨列运算需要逐列对齐；新增一行可能触发整块类型提升。

设两个 Series $s^{(1)}=(v^{(1)},I^{(1)},d)$、$s^{(2)}=(v^{(2)},I^{(2)},d)$。二元运算不按位置配对，而按标签配对：

$$
I=I^{(1)}\cup I^{(2)},\qquad
r_i=\begin{cases}
v^{(1)}_i\oplus v^{(2)}_i, & i\in I^{(1)}\cap I^{(2)}\\
\text{NaN}, & \text{否则}
\end{cases}
$$

上式是后文所有对齐行为的统一来源。若索引重复，按标签对齐无法唯一确定配对关系，pandas 在多数算术与 `reindex` 操作中直接抛出 `ValueError: cannot reindex on an axis with duplicate labels`，因此清洗阶段应先保证索引唯一。

### 2 四种索引器与链式赋值

| 索引器 | 选择依据 | 切片端点 | 返回 | 典型用途 |
| --- | --- | --- | --- | --- |
| `loc` | 标签 | 两端闭区间 | 行/列/标量 | 按条件与列名赋值 |
| `iloc` | 整数位置 | 左闭右开 | 行/列/标量 | 按行列序号取数 |
| `at` | 标签 | 不支持切片 | 标量 | 单点快速读写 |
| `iat` | 整数位置 | 不支持切片 | 标量 | 单点快速读写 |

`loc` 的切片包含右端点，`iloc` 的切片不包含右端点，这一点在按行切片时最易混淆。`at` 与 `iat` 只接受单个标签或位置，省去索引器解析开销。

链式赋值指把取值与赋值拆成两次 `__getitem__` 调用：

```python
df[df["qty"] > 1]["unit_price"] = 0.0
```

它等价于

```python
tmp = df[df["qty"] > 1]   # 第一次 __getitem__，返回新对象
tmp.__setitem__("unit_price", 0.0)  # 第二次调用，写入 tmp
```

`tmp` 是视图还是副本由内部块布局决定，调用方无法保证。pandas 2.x 在 `tmp` 上记录弱引用 `_is_copy`，赋值时发出 `SettingWithCopyWarning`，但可能写入、也可能不写入；pandas 3.0 默认启用 Copy-on-Write，`tmp` 始终表现为独立副本，链式赋值发出 `ChainedAssignmentError` 警告且不写回原表。两种版本的共同结论是：链式赋值不可依赖。

正确写法是单次 `loc` 调用，把行选择与列选择放进同一个索引器：

```python
df.loc[df["qty"] > 1, "unit_price"] = 0.0
```

若确实需要一个独立子表，应显式 `df.loc[mask].copy()`，让副本语义显式化。`inplace=True` 不能修复链式赋值，它只把返回值改为 `None`，并妨碍方法链。

### 3 索引对齐

对齐规则由第 1 节的和式给出。设 $s_1$ 的索引为 `["a","b","c"]`，$s_2$ 的索引为 `["b","c"]`，则 $s_1+s_2$ 的结果索引为两者的并集，`a` 位置为 `NaN`，`b`、`c` 位置相加。`Series.align(other, join="inner")` 可显式取交集并同时返回两个对齐后的对象。

赋值同样对齐。执行 `df["new"] = series` 时，pandas 按标签把 `series` 映射到 `df.index`：`df` 中出现在 `series.index` 的标签取对应值，其余标签写 `NaN`，`series` 中多余的标签被丢弃。若 `series` 来自另一次过滤且索引已错位，结果不会报错，只会产生大面积缺失。

广播需要指定轴。`df` 与 `Series` 做算术时，默认沿列轴对齐；要按行广播，须写 `df.div(series, axis="index")` 或 `df.sub(series, axis=0)`。写错轴的典型症状是结果全为 `NaN`。

### 4 缺失值：机制、检测与处理

按缺失机制分三类。设 $M_{ij}=1$ 表示第 $i$ 行第 $j$ 列缺失。

- **完全随机缺失**（MCAR）：$P(M_{ij}=1)$ 与任何变量无关。删除完整行不引入偏差，只损失样本量。
- **随机缺失**（MAR）：$P(M_{ij}=1)$ 依赖于已观测变量，不依赖于缺失值本身。按已观测变量分组填充可减小偏差。
- **非随机缺失**（MNAR）：$P(M_{ij}=1)$ 依赖于缺失值本身。例如高收入者更不愿填写收入。任何基于观测值的填充通常都有偏，只能做敏感性分析。

检测用 `df.isna().mean()` 得到每列缺失率，用 `df.isna().sum()` 得到计数。删除用 `dropna(how="any"|"all", thresh=k, subset=[...])`；填充用 `fillna(value|dict|Series, method="ffill"|"bfill", limit=k)` 或 `interpolate`。按列字典填充时，字典键是列名；按 Series 填充时，Series 的索引是列名，二者都走对齐语义。

均值填充对方差的影响可以精确写出。设 $X$ 的缺失完全随机、缺失比例为 $p$，用观测均值 $\mu$ 填充，得到 $X'$。则

$$
\mathbb{E}[X'^2]=(1-p)\mathbb{E}[X^2]+p\mu^2,\qquad
\operatorname{Var}(X')=(1-p)\sigma^2
$$

因此 $\operatorname{SD}(X')=\sqrt{1-p}\,\sigma$。又因 $\operatorname{Cov}(X',Y)=(1-p)\operatorname{Cov}(X,Y)$，相关系数满足

$$
\rho(X',Y)=\frac{(1-p)\operatorname{Cov}(X,Y)}{\sqrt{1-p}\,\sigma\cdot\sigma_Y}
=\sqrt{1-p}\,\rho(X,Y)
$$

当 $p=0.2$ 时相关系数被压缩到原值的 $0.894$ 倍，$R^2$ 被压缩到 $0.8$ 倍。若缺失与目标相关（MAR 或 MNAR），偏差方向由缺失机制决定，不能由该式推出。

处理策略须与下游模型匹配。线性模型、神经网络、距离度量要求输入为数值且无缺失，必须填充或删除；树模型可按缺失方向分裂，XGBoost、LightGBM、`HistGradientBoosting` 可原生接收 `NaN`，此时填充反而破坏信息。类别列可把缺失作为一个独立类别；连续列在填充的同时应增加缺失指示列 $M_j$，让模型区分“值为 0”与“未知”。

### 5 类型、category 与内存

常见 dtype 的容量与缺失能力如下。

| dtype | 典型字节/元素 | 可表示缺失 | 适用场景 |
| --- | --- | --- | --- |
| `int64` | 8 | 否 | 无缺失的计数、ID |
| `Int64` | 8 | 是（`pd.NA`） | 有缺失的计数 |
| `float64` | 8 | 是（`NaN`） | 连续值、含缺失的整数 |
| `str` | 变长 | 是 | 文本（pandas 3.0 默认） |
| `category` | 1–4 + 字典 | 是 | 低基数类别 |
| `bool` / `boolean` | 1 | 否 / 是 | 标记列 |

`int64` 无法表示 `NaN`，一旦插入缺失值，整列会被提升为 `float64`；需要保留整数语义时使用可空 `Int64`。类型转换优先用 `pd.to_numeric(..., errors="coerce")`、`pd.to_datetime(..., errors="coerce")` 并统计被强制转换的个数，`astype` 遇到非法值会直接抛出异常。

`category` 用整数编码加一张类别字典存储：值数组存放 `int8`/`int16`/`int32` 编码，字典存放去重后的类别字符串。设基数 $k$、编码宽度 $b$ 字节，值部分占 $n\cdot b$ 字节，与字符串长度无关。实测 $10^6$ 个四类地区字符串占约 $5.35\times10^7$ 字节，转为 `category` 后约占 $1.00\times10^6$ 字节，编码类型为 `int8`。类别基数接近样本量时字典与编码开销超过收益，不应转换。

`category` 参与 `groupby` 时须注意 `observed` 参数。pandas 2.x 默认 `observed=False`，会对类别字典的笛卡尔积分组，未出现的类别也产生一行零值，多列类别交叉时行数按类别数乘积膨胀；pandas 3.0 默认改为 `True`。跨版本代码应显式写 `observed=True`。

### 6 去重与字符串

去重的关键是先定义主键。`duplicated(subset=[...], keep="first"|"last"|False)` 返回布尔掩码，`keep=False` 标记全部重复行，适合先统计再删除。`drop_duplicates` 是同一逻辑的删除版本。若同一主键对应不同属性值，属于冲突重复而非完全重复，应单独输出冲突表人工裁决，不能简单保留第一条。

字符串操作通过 `.str` 访问器向量化执行。常用链为 `str.strip().str.lower().str.replace(...)`；`str.contains(pat, regex=True, na=False)` 的正则默认开启，`na=False` 决定缺失位置返回 `False` 而非 `NA`；`str.extract(r"(\d+)", expand=True)` 抽取捕获组；`str.split(sep, expand=True)` 拆分为多列。缺失值在 `.str` 运算后仍为缺失，不会变成空字符串。

去重应在规范化之后执行。`"East"`、`" east "`、`"EAST"` 在规范化前是三个不同值，先 `strip` 与 `title` 再 `drop_duplicates` 才能合并。

### 7 groupby 的拆分—应用—合并

`groupby` 按以下三步执行：按键把行划分为互不相交的组；对每组独立应用函数；把结果按组键重新组装。设分组键 $g(i)$ 把 $n$ 行划为 $K$ 组，第 $k$ 组行数为 $n_k$，$\sum_k n_k=n$。

四种应用方式的输出形状不同，混用会导致后续合并错位。

| 方法 | 每组输入 | 每组输出 | 总输出长度 | 用途 |
| --- | --- | --- | --- | --- |
| `agg` | 子表 | 标量或标量元组 | $K$（或 $K\times$ 聚合数） | 汇总统计 |
| `transform` | 子表 | 与组等长的序列 | $n$ | 组内标准化、组内填充 |
| `filter` | 子表 | 布尔标量 | 满足条件的行数 | 按组筛选原始行 |
| `apply` | 子表 | 任意对象 | 由返回结构决定 | 复杂自定义逻辑 |

`transform` 的对齐性质来自它按原索引返回。设第 $k$ 组的均值为 $\bar{x}_k$、标准差为 $s_k$，则

$$
z_i=\frac{x_i-\bar{x}_{g(i)}}{s_{g(i)}}
$$

可由 `df.groupby(key)[col].transform(lambda s: (s - s.mean()) / s.std())` 得到，结果长度恒为 $n$，可直接赋回原表。`agg` 的结果长度为 $K$，若直接赋回原表会因长度不符或索引不匹配产生 `NaN`。

命名聚合 `agg(total=("amount", "sum"), n=("order_id", "nunique"))` 可避免多级列名。`as_index=False` 把组键还原为普通列。默认 `dropna=True` 会丢弃键为 `NaN` 的组，类别键的缺失需要先填充为独立类别。

### 8 merge 与形状变换

`merge` 支持 `inner`、`left`、`right`、`outer`、`cross` 五种连接。设左表在键 $k$ 上的行数为 $n_L(k)$，右表为 $n_R(k)$，则内连接的结果行数为

$$
N_{\text{inner}}=\sum_{k\in K_L\cap K_R} n_L(k)\,n_R(k)
$$

左连接在此基础上加上左表未匹配行数，外连接再加上右表未匹配行数。当两侧键都不唯一时，$n_L(k)n_R(k)$ 使结果按乘积膨胀，即多对多连接。

防御手段有三项：合并前用 `duplicated(subset=key).sum()` 检查键唯一性；合并时用 `validate="one_to_one"|"one_to_many"|"many_to_one"|"many_to_many"` 声明预期关系，违反时抛 `MergeError`；合并后用 `indicator=True` 生成 `_merge` 列，统计 `both`、`left_only`、`right_only` 的行数。若必须多对多，应预先聚合到目标粒度，或明确把膨胀视为加权。

形状变换是 merge 的补充。`pivot_table(index, columns, values, aggfunc, fill_value, margins)` 把长表转为宽表，默认聚合函数为均值，重复的 (index, columns) 组合按 `aggfunc` 合并；`melt(id_vars, value_vars, var_name, value_name)` 把宽表转回长表。无重复组合且不做聚合时二者互为逆变换；存在重复组合时 `pivot_table` 会聚合，原始信息不能完全还原。

### 9 时间序列、方法链与分块读取

`resample(rule)` 要求 `DatetimeIndex`，先 `set_index` 再重采样。它按时间窗口重新分组并聚合，`closed` 与 `label` 决定窗口端点归属与结果标签位置；`asfreq()` 只改变频率、不聚合，用于补齐空档。周频率 `"W"` 默认以周日为标签，月频率在 pandas 2.2 起用 `"ME"` 取代 `"M"`。

方法链把每一步写成返回新对象的表达式，配合 `assign`、`query`、`loc`、`pipe` 使用。`pipe(func, *args)` 把当前对象作为 `func` 的第一个参数传入，适合封装无法用内置方法表达的多步逻辑。链式风格的前提是所有步骤都返回新对象，因此不应在链中使用 `inplace=True`。

内存优化有两条路径。其一是压缩 dtype：`int64` 降为 `int32` 需先确认取值范围，`float64` 降为 `float32` 只保留约 7 位十进制有效数字（`float64` 约 15–16 位），转换前需确认精度要求，`object` 文本降为 `category` 适用于低基数列。其二是分块读取：`pd.read_csv(path, usecols=[...], dtype={...}, chunksize=10**6)` 返回迭代器，每块独立清洗后聚合。分块聚合只适用于可结合的函数（求和、计数、最值），中位数与分位数需要近似算法或两遍扫描。

## 关键直觉

> [!tip]
> 把 DataFrame 视为“共享同一标签轴的列向量集合”，则取值、赋值、算术、聚合都由标签决定而非由位置决定；链式赋值的失败、索引对齐产生的 `NaN`、`groupby.transform` 能赋回原表，都是这一条的直接推论。清洗的任务就是把原本隐含的标签、类型与缺失约定写成显式列与显式规则。

## 例子与代码

以下示例在 pandas 3.0.1、NumPy 2.3.5 下运行。数据包含 13 行原始记录，其中 1 行重复订单、5 处缺失、1 个非法价格、1 个统计离群金额。每个阶段打印前后形状。

```python
import numpy as np
import pandas as pd

raw = pd.DataFrame({
    "order_id": [1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1002, 1011, 1012],
    "order_date": ["2025-01-03", "2025-01-03", "2025-01-04", "2025-01-05", "2025-01-05",
                   "2025-01-06", "2025-01-07", "2025-01-08", "2025-01-08", "2025-01-09",
                   "2025-01-03", "2025-01-10", "2025-01-11"],
    "region": ["East", "east", "West", "North", "East", "West", "North", "South", "East",
               "West", "east", "North", None],
    "channel": ["web", "app", "web", "app", "web", "app", "web", "app", "web", "web", "app", "web", "app"],
    "qty": [2, 1, 3, np.nan, 40, 2, 1, 4, np.nan, 3, 1, 2, 1],
    "unit_price": [19.9, 19.9, 15.0, 15.0, 15.0, 25.0, 25.0, 19.9, 19.9, np.nan, 19.9, 999.0, 25.0],
    "customer_id": [" c001", "c002", "c003", "c004", "c005", "c006", None, "c008", "c009",
                    "c010", "c002", "c011", "c012"],
})
print("S0 原始", raw.shape)                       # (13, 7)
print("缺失计数", raw.isna().sum().to_dict())

# S1 规范化字符串：统一大小写与空白，使后续去重能识别同一实体
df = raw.copy()
df["region"] = df["region"].str.strip().str.title()
df["channel"] = df["channel"].str.strip().str.lower()
df["customer_id"] = df["customer_id"].str.strip().str.lower()
print("S1 规范化", df.shape)                       # (13, 7)

# S2 去重：订单号是主键，保留首次出现
print("重复订单号", int(df.duplicated(subset=["order_id"], keep=False).sum()))  # 2
df = df.drop_duplicates(subset=["order_id"], keep="first").reset_index(drop=True)
print("S2 去重", df.shape)                         # (12, 7)

# S3 类型转换：日期、可空整数、浮点、类别
df["order_date"] = pd.to_datetime(df["order_date"], format="%Y-%m-%d")
df["qty"] = pd.to_numeric(df["qty"], errors="coerce").astype("Int64")
df["unit_price"] = pd.to_numeric(df["unit_price"], errors="coerce")
df["region"] = df["region"].astype("category")
print("S3 类型转换", df.shape)                     # (12, 7)

# S4 业务规则：数量 1–50、单价 (0, 500]，违规值置为缺失并留下标记
df["qty_invalid"] = ((df["qty"] < 1) | (df["qty"] > 50)).fillna(False).astype("int8")
df["price_invalid"] = ((df["unit_price"] <= 0) | (df["unit_price"] > 500)).astype("int8")
df.loc[df["qty_invalid"] == 1, "qty"] = pd.NA
df.loc[df["price_invalid"] == 1, "unit_price"] = np.nan
print("S4 业务规则", df.shape, int(df["qty_invalid"].sum()), int(df["price_invalid"].sum()))  # (12, 9) 0 1

# S5 缺失填补：类别补独立水平，数值用组内中位数（避免均值被离群值拉动）
df["region"] = df["region"].cat.add_categories(["Unknown"]).fillna("Unknown")
qty_med = df.groupby("region", observed=True)["qty"].transform("median")
df["qty"] = df["qty"].astype("Float64").fillna(qty_med).round().astype("Int64")
price_med = df.groupby("channel", observed=True)["unit_price"].transform("median")
df["unit_price"] = df["unit_price"].fillna(price_med)
print("S5 缺失填补", df.shape)                     # (12, 9)

# S6 金额与 IQR 离群标记：保留原值，另建清洗后列，处理决策可追溯
df["amount"] = df["qty"].astype("float64") * df["unit_price"]
q1, q3 = df["amount"].quantile([0.25, 0.75])
upper = q3 + 1.5 * (q3 - q1)
df["amount_outlier"] = (df["amount"] > upper).astype("int8")
df["amount_clean"] = df["amount"].clip(upper=upper)
print("S6 金额与离群", df.shape, round(q1, 2), round(q3, 2), round(upper, 2))  # (12, 12) 28.75 52.42 87.94
show_cols = ["order_id", "qty", "unit_price", "amount", "amount_clean"]
print(df[show_cols].round(2).to_string(index=False))

# S7 聚合：每个日期一行，订单数、清洗后营收、均价
daily = (df.groupby("order_date", as_index=False)
           .agg(orders=("order_id", "nunique"),
                revenue=("amount_clean", "sum"),
                avg_price=("unit_price", "mean")))
print("S7 日聚合", daily.shape)                    # (9, 4)
print(daily.to_string(index=False,
      formatters={"revenue": "{:.2f}".format, "avg_price": "{:.2f}".format}))

# S8 transform：组内营收占比，输出与 df 等长，可直接赋回
df["region_share"] = (df["amount_clean"] /
                      df.groupby("region", observed=True)["amount_clean"].transform("sum"))
print("S8 组内占比", df.shape)                     # (12, 13)

# S9 重采样：按周汇总，标签为周日
weekly = df.set_index("order_date").resample("W")["amount_clean"].sum()
print("S9 周汇总", weekly.shape)                   # (2,)
print(weekly.round(2))
```

关键输出如下。S2 中 `keep=False` 把重复的两行都标记，因此计数为 2，删除后保留 12 行。S4 检出 1 个非法单价，即 999 被置为缺失；数量均在 1–50 内，故违规数为 0。S5 后 `qty` 与 `unit_price` 的缺失数均为 0。

```text
S0 原始 (13, 7)
S1 规范化 (13, 7)
S2 去重 (12, 7)
S3 类型转换 (12, 7)
S4 业务规则 (12, 9) 0 1
S5 缺失填补 (12, 9)
S6 金额与离群 (12, 12) 28.75 52.42 87.94
 order_id  qty  unit_price  amount  amount_clean
     1001    2        19.9    39.8         39.80
     1002    1        19.9    19.9         19.90
     1003    3        15.0    45.0         45.00
     1004    2        15.0    30.0         30.00
     1005   40        15.0   600.0         87.94
     1006    2        25.0    50.0         50.00
     1007    1        25.0    25.0         25.00
     1008    4        19.9    79.6         79.60
     1009    2        19.9    39.8         39.80
     1010    3        19.9    59.7         59.70
     1011    2        19.9    39.8         39.80
     1012    1        25.0    25.0         25.00

order_date  orders  revenue  avg_price
2025-01-03       2    59.70      19.90
2025-01-04       1    45.00      15.00
2025-01-05       2   117.94      15.00
2025-01-06       1    50.00      25.00
2025-01-07       1    25.00      25.00
2025-01-08       2   119.40      19.90
2025-01-09       1    59.70      19.90
2025-01-10       1    39.80      19.90
2025-01-11       1    25.00      25.00

order_date
2025-01-05    222.64
2025-01-12    318.90
Freq: W-SUN, Name: amount_clean, dtype: float64
```

第 1005 行数量为 40，金额 600，超过 IQR 上界 87.9375，被标记为离群并截断到上界。截断只作用于 `amount_clean`，`amount` 保留原值，因此可以同时训练稳健模型与复核异常。周汇总首周（1 月 3 日至 5 日）营收 222.64，次周（1 月 6 日至 11 日）营收 318.90。

语义核对可另用小表验证，输出以注释给出。

```python
df.loc[df["qty"] > 1, "unit_price"] = 0.0   # 单次调用，写回原表
df.iloc[0, 3]                               # 第 0 行第 3 列，按位置
df.at[0, "region"]                          # 行标签 0、列标签 region，按标签

left = pd.DataFrame({"k": ["x", "x", "y"], "v": [1, 2, 3]})
right = pd.DataFrame({"k": ["x", "x", "z"], "w": [10, 20, 30]})
print(left.merge(right, on="k", how="inner").shape)   # (4, 3)，x 键 2×2 膨胀

s1 = pd.Series([1, 2, 3], index=["a", "b", "c"])
s2 = pd.Series([10, 20], index=["b", "c"])
print((s1 + s2).to_dict())                  # {'a': nan, 'b': 12.0, 'c': 23.0}
```

## 易错点

> [!warning]
> - 用 `df[mask]["col"] = v` 赋值。pandas 2.x 只发 `SettingWithCopyWarning` 且写入结果不确定，pandas 3.0 发 `ChainedAssignmentError` 且必然不写入；应改为 `df.loc[mask, "col"] = v`。
> - 对可空 `Int64` 列做比较后直接 `.astype("int8")`。比较结果含有 `pd.NA`，转换会抛 `ValueError: cannot convert NA to integer`；应先 `.fillna(False)` 再转布尔或整数。
> - 忽略索引对齐。`df["new"] = series` 在索引不一致时静默写入 `NaN`；`df.sub(series)` 默认按列轴对齐，按行广播须显式写 `axis="index"`。
> - 合并前不检查键唯一性。多对多连接按 $\sum_k n_L(k)n_R(k)$ 放大行数，训练样本被重复加权；应先用 `duplicated` 检查，再用 `validate` 声明关系。
> - 在划分训练集与测试集之前，用全量数据计算填充值或标准化参数。验证集统计量因此进入训练过程，评估偏乐观；填充与缩放参数必须只在训练折上拟合。
> - 对 `category` 列使用 `groupby` 而不指定 `observed=True`。pandas 2.x 默认输出类别字典的笛卡尔积，未出现的组合也会产生零值行。

## 关联笔记

- [[NumPy向量化]]：前置。广播、视图与副本、dtype 宽度是理解 Pandas 对齐与内存行为的基础。
- [[数据工程入门]]：后续。本篇的单机清洗在工程侧扩展为可调度、可版本化的 ETL 管道。
- [[数据集质量控制]]：后续。缺失率、重复率、标签一致性在本篇中被检测，在该篇中被组织为验收规则。
- [[模型评估与交叉验证]]：后续。划分纪律决定填充与去重必须在折内完成，否则产生泄漏。
- [[Matplotlib可视化]]：对照。清洗后的分布、缺失模式与离群值需要图形核对，图形接口见该篇。

## 达标检测

- [ ] 能写出 DataFrame 与 Series 的构成，并解释为何两列 dtype 可以不同而同一列内部必须相同。
- [ ] 能说明重复标签对 `loc` 取值与 `reindex` 的影响，以及为何含重复标签的算术对齐会抛出异常。
- [ ] 能说明 `df[mask]["col"] = v` 在 pandas 2.x 与 3.0 下分别发生什么，并给出单次 `loc` 的等价写法。
- [ ] 能由缺失比例 $p$ 计算均值填充后的标准差与相关系数缩放因子，并说明该结论仅在哪一种缺失机制下成立。
- [ ] 能对一份含重复键的左右表，先用公式算出多对多连接的行数，再用 `validate` 与 `indicator` 验证。
- [ ] 能写出 `agg`、`transform`、`filter` 三者的输出长度，并把组内标准化结果正确赋回原表。

## 参考来源

- pandas User Guide, *Indexing and selecting data* —— 对应本篇第 2 节 `loc`/`iloc`/`at`/`iat` 的语义与切片端点差异。
- pandas User Guide, *Copy-on-Write* —— 对应第 2 节链式赋值、`ChainedAssignmentError` 与副本语义。
- pandas User Guide, *Working with missing data* —— 对应第 4 节缺失检测、填充、删除与可空 dtype。
- pandas User Guide, *Group by: split-apply-combine* —— 对应第 7 节 `agg`/`transform`/`filter` 的输出形状与分组参数。
- pandas User Guide, *Merge, join, concatenate and compare* —— 对应第 8 节连接类型、`validate` 与多对多膨胀。
- Wes McKinney, *Python for Data Analysis*, 3rd ed., 2022, 第 5、7、8、10、11 章 —— 对应索引、清洗、合并聚合与时间序列的完整示例。
