Pandas数据清洗10步实战：从脏数据到可信任数据-嵌云网-嵌入式AI开发资源站

Pandas数据清洗10步实战：从脏数据到可信任数据

里小咸·2026-09-24·阅读 22 GEO检测（免费）

pandas数据清洗Python

|难度：普通|阅读约 48 分钟

做数据分析的人应该都有这种经历：跑到手的CSV或者Excel，打开一看，列名带空格、价格列里混着"元"字、日期格式五花八门、明明按订单导出的表却有三分之一的重复行。我早期处理这类脏数据，用的还是Excel的查找替换，处理到一半经常把原表改坏，最后只能重新导。后来正经用Pandas做数据清洗，把流程固定成一套标准步骤，效率翻了好几倍。这篇就用一个模拟的真实业务数据，完整串一遍Pandas数据清洗的10个步骤，从加载到导出，每一步都给可直接跑的代码，并把我踩过的坑和判断逻辑一并讲清楚。无论你是刚入门Python还是已经写了段时间pandas，这篇都能帮你把"数据能用"变成"数据敢用"。

1. 项目背景：为什么"数据清洗"值得用Pandas正经做一遍

1.1 我看到的流量现象：完整代码才是真正需求

点开各方平台的数据搜索热词，会发现"pandas 数据清洗"、"python 安装"、"pandas中文手册"这类的搜索频率一直居高不下。针对特定行业场景的搜索也很集中，比如校园大数据、网约车订单数据清洗、农产品价格数据清洗，还有"替换多个怎么写函数"。这说明大家在真实项目里遇到的问题高度相似：不是不会导入数据，而是拿到数据后不知道下一步该干嘛，尤其是字符串替换、类型转换、去重规则这类细节，网上教程经常只讲半截。

"完整代码"是这个需求的痛点。写数据清洗的代码并不难，难的是有一套能应对多种脏数据的完整流程。我在实际项目中总结下来，Pandas数据清洗应该被当成一条流水线来设计，而不是今天补一个空值、明天改一下格式。这篇的思路就是把清洗拆成10个独立步骤，每一步只做好一件事，最后合并成一个可复用的管道。

1.2 数据清洗到底洗的是什么

用一句话说清楚数据清洗的本质：把"部分单元格内容无法被程序正确理解"的表格，变成"每一行、每一列都能被统计模型直接信任"的表格。可信数据集通常有四个特征。

列名规范、没有重复列、没有无效字符
每一列的数据类型和实际内容一致
缺失值已被删除或填充，异常值已被识别或修正
没有重复行，索引连续且有序

我们做的所有清洗动作，本质上都是在往这四个特征上靠。Pandas之所以适合做这件事，是因为DataFrame天然支持向量化操作，对一个十列五十万行的表格做字符串替换、类型批量转换、缺失值统计，都是基础语法级别的事情，不需要写循环。而Excel做同样的操作得靠筛选、公式、宏，SQL虽然有powerful的聚合能力，但处理文本格式和异常值时的灵活性远不如pandas的一整套字符串方法。所以我个人认为，只要数据的量和复杂度超过了"手动操作会出错"的阈值，就应该把它拉进Pandas流程里。

1.3 10步路线图与环境准备

下面是我自己固定下来的10个清洗步骤，也是这篇文章的主干。

加载数据：正确处理编码、分隔符、表头
初步体检：通过info()、describe()、head()快速掌握全貌
列名标准化：统一格式、去空格、去特殊字符
重复行去重：按业务主键或全字段判断重复
缺失值处理：按缺失比例决定删除、填充还是保位
数据类型转换：把字符串日期转为datetime，把数字字符串转为数值
文本字段清洗：去首尾空格、统一大小写、正则替换
异常值处理：用IQR分位数或业务规则识别并修正
索引重置与排序：清洗后恢复连续索引，便于后续分组和透视
数据导出：用合适的编码和格式输出最终数据集

这个顺序是我经过多个项目调整后的版本。比如列名标准化我放在了前三步，是因为列名不先理顺，后续所有通过名字取值和合并的操作都会变得混乱。异常值处理放在文本清洗后面，是因为有些异常值本质上是文本造成的，比如"1000元"这种字符串，必须先把"元"去掉转成数字，才能进入异常值判断。

开发环境方面，我用的是Python 3.10，Pandas 2.0以上的版本。如果你的pandas版本是1.x，大部分代码也兼容，只是to_datetime对某些时间格式的处理略有差异。安装很简单，用 pip install pandas 或者 pip install pandas -i 国内镜像源 加速即可。

1.4 造一份能复现练习的脏数据

网上很多教程用天生干净的数据集演示，看完觉得自己会了，回到自己的数据就傻眼。所以我这里手动构造一份"脏得很真实"的销售订单表，你在本地可以直接生成出来，后面所有代码都针对这份数据跑。

python复制import pandas as pd
import numpy as np

data = {
    " 订单号 ": ["A001", "A002", "A002", " A001 ", "B001", None, "B002", "C003"],
    "商品名称": ["苹果", "香蕉", "香蕉", "苹果", "鸭梨", "桔子", "苹果", "香蕉"],
    "销售数量": ["3", "5", "5", "2", "8", "1", None, "4"],
    "单价(元)": ["5.0", "2.5", "2.5", "5.0", "3.8", "4.2", "3.9", "???"],
    "销售额": [15, 12.5, 12.5, 10, 30.4, 4.2, None, "16.0"],
    "订单日期": ["2024/1/3", "2024-01-05", "2024-01-05", "2024/1/3", "20240108", "2024-01-09", "2024/01/11", "2024-1-12"],
    "是否发货": ["是", "是", "是", "是", "否", "否", "是", "未知"],
}

df = pd.DataFrame(data)
df.to_csv("sales_dirty.csv", index=False, encoding="utf-8-sig")
print(df)

这份数据有七处典型问题：列名带特殊字符和空格、订单号列里有行内空格甚至大小写不一致、重复行、缺失值、销售数量是字符串、单价里有"???"、日期三种格式混合、销售额和销售数量对不上。接下来的步骤就围绕把这些坑一个个填平展开。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 第1-2步：读取前侦察与全表体检

2.1 第一步：加载数据，处理编码与分隔符

数据清洗的第一行代码通常是 pd.read_csv()，但就这么一个函数，注意点非常多。

最常见的问题是编码。我用utf-8-sig导出CSV，是因为这个编码带了BOM头，能被Excel正确识别中文。但如果你手里是别人给的文件，可能是gbk、gb2312，甚至latin1。加载时遇到 UnicodeDecodeError，不要急着用errors='ignore'，那是把乱码风险转嫁给后续分析。正确做法是先小范围试几种编码，或者直接用 chardet 这类库自动检测。

python复制import chardet

with open("sales_dirty.csv", "rb") as f:
    raw = f.read(10000)
    result = chardet.detect(raw)
    print(result)  # {'encoding': 'utf-8', 'confidence': 0.99}

df = pd.read_csv("sales_dirty.csv", encoding=result["encoding"])

另一个容易忽略的是分隔符。有些导出文件不是标准逗号分隔，而是制表符或者说有空格分隔。read_csv 里可以指定 sep，比如 sep="\t"，或者更省事用 sep=None 配合 engine="python" 让它自动猜测。商用数据里还常遇到分隔符本身出现在字段内的情况，这时一般要用 quoting=csv.QUOTE_ALL 来保证正确解析。

我加载这份模拟数据后的初步输出是：

python复制print(df.shape)  # (8, 7)
print(df.columns.tolist())
# [' 订单号 ', '商品名称', '销售数量', '单价(元)', '销售额', '订单日期', '是否发货']

列名已经出现问题了：第一列带了前后空格。这正是第3步要解决的。

2.2 第二步：df.info()和describe()——机器帮你圈出重点

加载之后别急着清洗，先做"体检"：df.info() 看结构，df.describe() 看数值分布，df.head() 看前几行感知真实内容。这个步骤我称之为数据探查，是所有清洗动作的依据。

python复制print(df.info())

输出信息很清楚：销售数量 和 单价(元) 列显示为object，说明它们不是真正的数值列。原因是里面有字符串混入。销售额 也只有7个非空值，有一个缺失。订单号 同样只有7个非空值，有一个是None。

df.describe() 对这种object列没什么帮助，只能对已经识别为数值的列算分位数和均值。

python复制print(df.describe())

如果数据加载后没有一列能通过describe计算出统计量，就要意识到：这份数据远比想象中严重，大概率是数字全被读成了字符串，或者表头错行。

2.3 从describe()看出的和看不出的事

describe() 能快速暴露两类问题：数值列的极值与分布，以及缺失值导致的数量少一截。但它有一个盲区：字符串列的格式问题它完全看不到。比如 "5.0" 和 "???" 都显示成object，describe()不会提醒你。这时必须靠人工规则去检查唯一值和样本值。

python复制print(df["单价(元)"].unique())
# ['5.0', '2.5', '2.5', '5.0', '3.8', '4.2', '3.9', '???']
print(df["订单日期"].unique())
# ['2024/1/3', '2024-01-05', '2024-01-05', '2024/1/3',
#  '20240108', '2024-01-09', '2024/01/11', '2024-1-12']

一旦看到某个分类列的唯一值数量远小于行数，或者日期列里有正斜杠、横杠、连续数字，你就知道后面要做文本清洗和标准化了。所以第2步的核心结论是：info() 看类型和缺失，describe() 看分布，unique() 看枚举，三者组合才能形成一份完整的"病情报告"。

3. 第3-5步：列名标准化、重复记录与缺失值博弈

3.1 第三步：列名是清洗的第一站，不是最后一站

列名混乱的坑，等你做 df["单价(元)"] 取值时报KeyError，或者做 df.rename() 时才发现。所以我建议第3步就把列名一次性理顺。

清洗列名的基本规则有三个：去掉首尾空格、统一大小写或风格、把特殊字符替换成下划线或规范命名。

python复制df.columns = df.columns.str.strip()  # 去掉列名首尾空格
df.columns = df.columns.str.replace(" ", "_", regex=False)
df = df.rename(columns={
    "订单号": "order_id",
    "商品名称": "product_name",
    "销售数量": "quantity",
    "单价(元)": "unit_price",
    "销售额": "sales_amount",
    "订单日期": "order_date",
    "是否发货": "is_shipped",
})
print(df.columns.tolist())
# ['order_id', 'product_name', 'quantity', 'unit_price', 'sales_amount', 'order_date', 'is_shipped']

有人喜欢保留中文列名，完全没问题。问题不在中文还是英文，而在于列名是否唯一、是否稳定、是否没有隐藏的空格和换行符。实际业务中我遇到过列名结尾带 \n 的情况，打印出来完全看不见，但一merge或者groupby就出错。所以列名清洗后，建议加一句断言：

python复制assert df.columns.is_unique, "列名仍有重复"

3.2 第四步：去重要看清粒度

去重在数据分析里没有争议，有争议的是"凭什么判断两行是重复的"。

如果直接 df.drop_duplicates()，只要整行所有字段完全一样，就会去重。这份数据里订单A002两行看起来一样，但因为有缺失值和异常值的存在，实际去重逻辑不能只看表面。

python复制df_before = df.shape[0]
df = df.drop_duplicates()
print(f"去重后行数：{df.shape[0]}，原行数：{df_before}")

真实项目中更常见的重复是"主键重复但其他字段不同"。比如同一订单号出现两次，但销售额不同，这种就不能用全字段去重，而要看业务主键。比如订单表的主键是 order_id，那就用 subset=["order_id"] 去重，并根据 keep 参数决定保留哪一行。

python复制df = df.drop_duplicates(subset=["order_id"], keep="first")

keep="first" 保留第一次出现的行，keep="last" 保留最后一次，keep=False 则删掉所有重复行。具体用哪个，取决于业务上哪一条记录更接近事实。我一般会用 groupby 看一眼同一个主键不同字段的差异，确认一下哪个字段更可信，再决定去重方式。

3.3 第五步：缺失值处理三选一，按缺失比例决定

缺失值的处理策略不是固定的，核心要结合两个指标：缺失比例和缺失字段的业务意义。

缺失比例低于5%，可以直接删除这些行，影响很小
缺失比例在5%到30%，用均值/中位数填充，或者用前向/后向填充
缺失比例超过30%，这个字段本身基本失去了分析价值，建议删除整列

编写判断代码时，我会先统计每列的缺失情况：

python复制missing_report = df.isnull().sum()
missing_ratio = missing_report / len(df)
print(missing_ratio)

这份数据里 order_id 缺一行，quantity 缺一行，unit_price 有一行是"???"（不是NaN，是字符串），sales_amount 缺一行。要先决定哪些填、哪些删。

对于订单号缺失，如果该行是真实存在的记录，直接删除会让总数变少，影响统计口径。最好查看上下文，如果同一行其他字段都正常，可以先给一个临时编号，比如"UNKNOWN-001"，最后再做人工补录。数量缺失的商品，如果单价正常，可以用该商品的历史平均数量填充。销售额缺失但价格和数量都有，直接重算比填充更靠谱。

python复制df.loc[df["unit_price"] == "???", "unit_price"] = np.nan
df["unit_price"] = pd.to_numeric(df["unit_price"], errors="coerce")

# 销售额缺失时，用数量 * 单价 重算
mask = df["sales_amount"].isnull()
df.loc[mask, "sales_amount"] = df.loc[mask, "quantity"] * df.loc[mask, "unit_price"]

# 数量缺失时，按商品类别填充中位数
df["quantity"] = pd.to_numeric(df["quantity"], errors="coerce")
quantity_median = df.groupby("product_name")["quantity"].transform("median")
df["quantity"] = df["quantity"].fillna(quantity_median)

3.4 对应代码与输出验证

做完这三步，建议马上验证一下，而不是直接往下走。

python复制print(df.isnull().sum())
print(df.dtypes)

当 unit_price 和 quantity 变成float64，说明类型转换已经成功了一部分。sales_amount 原来是object，现在通过 pd.to_numeric 加上重算也变成了float64。这几步之间其实互相依赖：先处理"???"才能做数值计算，先有数值才能重算销售额。这就是为什么前面说第5步缺失值处理不能单独拎出来做的原因。

4. 第6-8步：类型转换、文本清理与异常值围剿

4.1 第六步：类型转换的"错误强制"机制

类型转换是数据清洗里最容易碰到"明明看着是数字却报错"的一步。

astype(float) 遇到字符串"???"会直接报错，所以需要一个更温和的转换方式：pd.to_numeric(..., errors="coerce")。coerce的意思是，转不动的值直接变成NaN，后续再看NaN情况决定填充还是删除。这种方式适合批量的、带杂质的数字列。

python复制df["quantity"] = pd.to_numeric(df["quantity"], errors="coerce")
df["unit_price"] = pd.to_numeric(df["unit_price"], errors="coerce")
df["sales_amount"] = pd.to_numeric(df["sales_amount"], errors="coerce")

日期列同理，pd.to_datetime 可以处理三种混合格式，只要加了 errors="coerce" 就不会中断运行。

python复制df["order_date"] = pd.to_datetime(df["order_date"], errors="coerce", format="mixed")
print(df["order_date"])

format="mixed" 是Pandas 2.0以后支持的参数，旧版本需要用 infer_datetime_format。如果你在跑代码时发现ERror说这个参数不存在，可以先手动规范日期字符串，比如把斜杠替换成横杠，再做转换：

python复制df["order_date"] = df["order_date"].str.replace("/", "-", regex=False)
df["order_date"] = pd.to_datetime(df["order_date"], errors="coerce")

4.2 第七步：字符串文本的隐性脏数据

字符串清洗处理的核心是那些"看不见的字符"和"不统一的写法"。最常见的就是首尾空格。

python复制df["product_name"] = df["product_name"].str.strip()
df["is_shipped"] = df["is_shipped"].str.strip()

strip() 不仅能去掉空格，还能去掉尾部换行符和 Tab。对全角空格这种特殊字符，strip() 默认不一定处理，需要用 str.replace("全角空格", "")。单位字符的混入也属于典型脏数据，比如价格列里混入"元"字，先正则以数字为中心进行提取更稳妥：

python复制df["unit_price"] = df["unit_price"].astype(str).str.extract(r"([0-9.]+)")[0]
df["unit_price"] = pd.to_numeric(df["unit_price"], errors="coerce")

正则提取的好处是，不管"5元"、"5.0元"、"¥5.0"还是"5.0(含税)"，都能提取出核心数字。我自己在清洗地址和手机号数据时也大量依赖 str.extract，比单纯 str.replace 稳得多。

“是否发货”这种二元或多元枚举值也要统一。例如把"未知"统一改成缺失，把"是"和"否"映射成1和0，这样后面做统计或者建模才不用反复处理字符串条件。

python复制df["is_shipped"] = df["is_shipped"].replace({"是": 1, "否": 0, "未知": np.nan})

4.3 第八步：异常值用IQR还是业务规则

异常值检测看似是数学问题，实际是业务问题。常用方法有Z-Score和IQR，但各有适用边界。Z-Score要求数据近似正态分布，如果不满足，异常值会被淹没。IQR方法不依赖正态假设，对所有连续值列都很友好。

IQR的公式是：取25%分位数Q1和75%分位数Q3，差值IQR=Q3-Q1，下界=Q1-1.5IQR，上界=Q3+1.5IQR，超出界外的值视为异常。

python复制q1 = df["unit_price"].quantile(0.25)
q3 = df["unit_price"].quantile(0.75)
iqr = q3 - q1
lower = q1 - 1.5 * iqr
upper = q3 + 1.5 * iqr
outliers = df[(df["unit_price"] < lower) | (df["unit_price"] > upper)]
print(outliers)

但这张表里单价异常并不一定是数据错误，有可能真的是高端商品。所以IQR检出异常只是第一步，第二步必须是业务规则校验。比如单价不可能低于0或者超过某个合理的价格上限，销售额必须等于数量乘单价。如果业务规则也没有明确上限，我会选择把异常值用上下界 clip 截断而不是直接删除，以保留大部分样本的整体分布。

python复制df["unit_price"] = df["unit_price"].clip(lower=lower, upper=upper)

4.4 实战代码与边界条件

这一步的整体代码把第6到第8步串在一起。

python复制# 第6步：类型转换
df["quantity"] = pd.to_numeric(df["quantity"], errors="coerce")
df["unit_price"] = pd.to_numeric(df["unit_price"], errors="coerce")
df["sales_amount"] = pd.to_numeric(df["sales_amount"], errors="coerce")

# 第7步：文本清理
df["order_id"] = df["order_id"].astype(str).str.strip()
df["product_name"] = df["product_name"].str.strip()
df["is_shipped"] = df["is_shipped"].str.strip().replace({"是": 1, "否": 0, "未知": np.nan})

# 第8步：异常值处理
q1 = df["unit_price"].quantile(0.25)
q3 = df["unit_price"].quantile(0.75)
iqr = q3 - q1
df["unit_price"] = df["unit_price"].clip(lower=q1 - 1.5 * iqr, upper=q3 + 1.5 * iqr)

边界条件有两个要特别提醒。第一，str.strip() 在列里有真实NaN时会变成NaN，因为 pd.NA 没有字符串方法，但Pandas的 .str 访问器会直接把缺失值跳过，所以放心用。第二，replace 在字典映射不匹配时会保留原值，不会报错，你最好在替换做完之后用 value_counts() 看一眼枚举值是否都清理干净。

python复制print(df["is_shipped"].value_counts(dropna=False))
# 1.0    4
# 0.0    2
# NaN    1

如果看到还有奇怪的枚举值，说明数据里还有你没发现的新写法。

5. 第9-10步：索引重排、数据导出与一个完整的清洗函数

5.1 第九步：索引复位与排序，不重排后面必出问题

清洗过程中删删改改，索引会出现空洞，比如原来行号是0到9，删了2行后变成0,1,4,5,7。这个问题在直接打印时不起眼，一旦做 groupby 后的索引对齐、join、merge，或者用 df.iloc 按位置取值，就会出现各种诡异结果。

所以清洗的最后一步逻辑是：先对需要的列排序，再重置索引。

python复制df = df.sort_values(by=["order_date", "order_id"], ascending=[True, True])
df = df.reset_index(drop=True)

reset_index(drop=True) 的 drop=True 参数很关键。如果不加，原来的索引会变成新的一列 index，反而给表里又引入一列垃圾数据。加了之后，新索引就是连续的0到N-1。

5.2 第十步：导出格式、编码与索引开关

导出时最常见的三个问题：索引列被导出、中文乱码、float列输出多余的小数位。

python复制df.to_csv("sales_clean.csv", index=False, encoding="utf-8-sig", float_format="%.2f")

index=False 避免把索引当成数据列导出，这是绝大多数项目里必须的配置。encoding="utf-8-sig" 解决Excel打开乱码问题。如果没有用WPS或Excel，而是导入数据库或做机器学习训练，普通 utf-8 更通用，因为部分数据库客户端对BOM的兼容不好。

如果是导出Excel，可以用 df.to_excel("sales_clean.xlsx", index=False)，但需要 openpyxl 这个库。导出前还可以做一次最终检查：

python复制print(df.shape)
print(df.dtypes)
print(df.isnull().sum())

这三行代码构成了清洗质量的最终验证。行数、列类型、缺失数量都符合预期，才说明数据可以拿出去用了。

5.3 把1-10步封装成可复用的清洗管道

清洗过一次的数据源，下次再拿到新数据时，很多步骤可以复用。我习惯把流程封装成一个函数，几个参数控制清洗策略，这样面对同类脏数据时，调用一次就够了。

python复制def clean_sales_data(df, fill_qty=True, outlier_method="iqr"):
    df = df.copy()

    # 第3步：列名标准化
    df.columns = df.columns.str.strip()
    df.columns = df.columns.str.replace(" ", "_", regex=False)
    df = df.rename(columns={
        "订单号": "order_id",
        "商品名称": "product_name",
        "销售数量": "quantity",
        "单价(元)": "unit_price",
        "销售额": "sales_amount",
        "订单日期": "order_date",
        "是否发货": "is_shipped",
    })

    # 第4步：去重
    df = df.drop_duplicates(subset=["order_id"], keep="first")

    # 第6步：类型转换
    df["quantity"] = pd.to_numeric(df["quantity"], errors="coerce")
    df["unit_price"] = pd.to_numeric(df["unit_price"], errors="coerce")

    # 第5步：缺失值处理
    df["sales_amount"] = df["quantity"] * df["unit_price"]

    # 第7步：文本清理
    df["product_name"] = df["product_name"].str.strip()
    df["is_shipped"] = df["is_shipped"].str.strip().replace({"是": 1, "否": 0, "未知": np.nan})

    # 第8步：异常值处理
    if outlier_method == "iqr":
        q1 = df["unit_price"].quantile(0.25)
        q3 = df["unit_price"].quantile(0.75)
        iqr = q3 - q1
        df["unit_price"] = df["unit_price"].clip(lower=q1 - 1.5 * iqr, upper=q3 + 1.5 * iqr)

    # 第9步：排序与索引重排
    df = df.sort_values(by=["order_date", "order_id"])
    df = df.reset_index(drop=True)

    return df

这里的 df.copy() 也是我特别强调的一点。函数内部一定要先复制，避免对传入的原始DataFrame产生副作用。

5.4 用一份完整demo跑通全流程

我建议你把上面所有步骤拼在一起，在Jupyter或者VS Code里跑一遍，观察每一步前后 df.info() 的变化。跑通之后你会有一个很直观的感受：清洗并不需要高超的算法，需要的是对每一步的判断依据有清晰认知。

下面是一个可以一键跑通的最小demo：

python复制import pandas as pd
import numpy as np

dirty_data = {
    "订单号": ["A001", "A002", "A002", "A003"],
    "商品名称": ["苹果", " 香蕉", "香蕉", "鸭梨"],
    "销售数量": ["3", "5", "5", "8.0"],
    "单价(元)": ["5.0", "2.5", "2.5", "???"],
    "订单日期": ["2024/1/3", "2024-01-05", "2024-01-05", "20240108"],
}

df = pd.DataFrame(dirty_data)

df["单价(元)"] = pd.to_numeric(df["单价(元)"], errors="coerce")

df["销售数量"] = pd.to_numeric(df["销售数量"], errors="coerce")

df = df.dropna(subset=["销售数量", "单价(元)"])

df["订单号"] = df["订单号"].astype(str).str.strip()

df = df.drop_duplicates(subset=["订单号"], keep="first")

df["订单日期"] = pd.to_datetime(df["订单日期"], format="mixed", errors="coerce")

df = df.sort_values(by=["订单日期"]).reset_index(drop=True)

print(df)
print(df.dtypes)

print出来的DataFrame和原始脏表对比一下，你会看到列名没变但空格没了，单价从???变成了NaN再被删掉，日期统一成了datetime格式。这个最小demo足以说明10步流程中的核心逻辑。

6. 实操中那些"代码没报错但结果是错的"事儿

6.1 read_csv的编码误判与utf-8-sig

有一次我处理一个外部客户交付的订单明细文件，read_csv之后表格前几行看起来很正常，结果发现中文字段全部变成了奇怪的汉字乱码。排查了半个小时，最后发现是文件本身是GBK编码，但read_csv默认按UTF-8读，没有报错，只是数据错了。这个案例给我的教训是：加载后第一件事可能是确认数据不是乱码，而不是急着看统计指标。而导出给Excel用utf-8-sig这个细节，是无数人踩过乱码坑之后总结出的经验。不加sig，在Windows Excel里打开CSV基本必乱。

6.2 inplace=True不是不能用，而是要分场景

Pandas早期大量教程喜欢用 df.dropna(inplace=True) 这种写法。但我后来在项目里发现，inplace=True在配合条件判断或者函数封装时会带来不确定性，而且pandas官方对inplace参数的态度也越来越谨慎。现在我的习惯是统一使用重新赋值的方式：df = df.dropna(...)。这样写的好处是每一步的返回值都可以被链式调用，并且原始数据不会被意外改动。如果你还在代码里看到老的inplace写法，建议慢慢迁到新风格。

6.3 链式赋值的SettingWithCopyWarning

另外一个经典坑是 SettingWithCopyWarning。你明明是在一个切片视图上改数值，结果原表没变，程序还只给你一个警告，进阶分析时才发现结果完全不对。这个警告的根源是：某些DataFrame操作产生的是视图，不是副本。我的解决方案很简单：任何需要改值之前，复制一份 df = df.copy()。复制多占一点内存，但能避免整个项目白跑一晚上，非常划算。

6.4 改数据前先备份，并保留清洗日志

数据清洗是有风险的操作，尤其是字段填充和删除行，一不留神会误伤有效数据。我的习惯是清洗前先保留一份原始数据备份，同时在代码里打印清洗日志：

python复制print(f"清洗前形状: {raw_shape}")
print(f"清洗后形状: {clean_shape}")
print(f"删除行数: {raw_shape[0] - clean_shape[0]}")

这样如果后续发现结果不符合预期，还能回溯到底是哪一步出了问题。日志不仅在项目交付时能帮自己回忆，也是团队协作里让别人能接手你代码的基础。

6.5 后续扩展：别在一开始就上自动清洗工具

有的同事喜欢一上来就装pandas-profiling或ydata-profiling生成一个自动报告。这个思路对探索性分析很友好，但它不能代替清洗。自动报告能告诉你哪列有缺失、哪列有异常，但无法判断缺失原因，更无法自动决定填充的值该怎么选。我自己的流程是：先用这套10步方法把数据整理到可用状态，再用profiling生成报告验证质量，顺序不能反。反过来只会产生一份"脏数据问题合集"，对你的清洗工作帮助不大。

写到这里，数据清洗的10个步骤和背后的判断逻辑基本都讲完了。最后提一句实操体会：清洗代码本身并不难写，难的是你愿意花多少时间做数据探查、理解业务字段含义。每拿到一批新数据，多留意那些看起来怪异的枚举值和异常分布，它们往往是数据质量问题的先兆。把这些先兆处理干净，后面建模和分析阶段会省下好几倍的时间。