Python 数据清洗：终极指南，高效剔除 NaN 值，提升数据质量344

 

 

在数据驱动的时代，数据已成为企业和研究机构最宝贵的资产。然而，原始数据往往是“脏”的，充满着各种噪声、异常值和缺失值。其中，缺失值（Missing Values）是数据预处理过程中最常见且最棘手的问题之一。在 Python 的数据科学生态系统中，这些缺失值通常以 `NaN`（Not a Number）的形式出现。本文将作为一份全面的指南，深入探讨 Python 中如何高效、专业地剔除 `NaN` 数据，旨在帮助读者提升数据清洗能力，确保数据分析和机器学习模型的准确性与健度。

1. 深入理解 NaN：缺失值的本质与来源

在 Python 的数据科学领域，`NaN` 是一个特殊的浮点数值，由 IEEE 754 浮点数标准定义，表示“非数字”。它不同于 0、空字符串或 None，专门用于标记缺失或无效的数值。理解 `NaN` 的来源是有效处理它们的第一步：
数据采集不完整：传感器故障、问卷未填写、网络传输中断等都可能导致数据记录缺失。
数据合并或转换：当合并来自不同来源的数据集时，如果某个键在其中一个数据集中不存在，可能会引入 `NaN`。例如，左连接（left join）操作时，右表没有匹配项。
数据运算错误：例如，0 除以 0（`0/0`）、无穷大减无穷大（`inf - inf`）等无效数学运算的结果在 NumPy 中会被表示为 `NaN`。
特定函数返回：某些数据处理函数在无法计算有效结果时，也会返回 `NaN`。

`NaN` 的存在会严重影响数据分析的准确性、统计模型的有效性以及机器学习算法的性能。许多统计函数和机器学习算法无法直接处理 `NaN` 值，会导致程序崩溃、计算结果错误或模型训练失败。

2. Python 数据科学环境与 NaN 处理基础

在 Python 中，Pandas 库是处理结构化数据的核心工具，它构建在 NumPy 库之上，因此 `NaN` 的概念在 Pandas DataFrame 和 Series 中得到了广泛应用。在开始剔除 `NaN` 之前，我们需要先了解如何识别它们。

2.1 引入必要的库

import pandas as pd
import numpy as np

2.2 创建包含 NaN 的示例 DataFrame

为了演示，我们先创建一个包含缺失值的 DataFrame：data = {
'A': [1, 2, , 4, 5],
'B': [, 7, 8, 9, 10],
'C': [11, 12, 13, , 15],
'D': [, , , , ],
'E': [16, 17, 18, 19, 20]
}
df = (data)
print("原始 DataFrame:")
print(df)

输出：原始 DataFrame:
A B C D E
0 1.0 NaN 11.0 NaN 16
1 2.0 7.0 12.0 NaN 17
2 NaN 8.0 13.0 NaN 18
3 4.0 9.0 NaN NaN 19
4 5.0 10.0 15.0 NaN 20

2.3 检测 NaN 值

Pandas 提供了多种检测 `NaN` 的方法：
`isnull()` 或 `isna()`：这两个方法功能相同，返回一个布尔型 DataFrame，其中 `True` 表示 `NaN`，`False` 表示非 `NaN`。
`sum()`：结合 `isnull()`，可以计算每列或整个 DataFrame 中 `NaN` 的数量。

# 检测所有 NaN 值
print("NaN 值检测 (布尔型 DataFrame):")
print(())
# 计算每列的 NaN 数量
print("每列的 NaN 数量:")
print(().sum())
# 计算整个 DataFrame 的总 NaN 数量
print("DataFrame 的总 NaN 数量:")
print(().sum().sum())

输出：NaN 值检测 (布尔型 DataFrame):
A B C D E
0 False True False True False
1 False False False True False
2 True False False True False
3 False False True True False
4 False False False True False
每列的 NaN 数量:
A 1
B 1
C 1
D 5
E 0
dtype: int64
DataFrame 的总 NaN 数量:
8

3. 核心策略：使用 `()` 剔除 NaN 数据

`()` 是 Pandas 中用于删除包含 `NaN` 值的行或列的核心函数。它提供了丰富的参数来灵活控制删除行为。

3.1 基本用法：删除包含任何 NaN 的行

默认情况下，`dropna()` 会删除任何包含至少一个 `NaN` 值的行。df_dropped_rows = ()
print("删除包含任何 NaN 值的行后的 DataFrame:")
print(df_dropped_rows)

输出：删除包含任何 NaN 值的行后的 DataFrame:
Empty DataFrame
Columns: [A, B, C, D, E]
Index: []

注意，由于我们的示例 DataFrame 的每一行都至少包含一个 `NaN` (甚至列 `D` 都是全 `NaN` )，因此默认删除后得到了一个空的 DataFrame。这说明了 `dropna()` 的强大但也需要谨慎使用，特别是当缺失值广泛分布时。

3.2 `how` 参数：控制删除的严格程度

`how` 参数决定了只有当满足何种条件时才删除行/列：
`how='any'` (默认)：如果行/列中存在任何一个 `NaN` 值，就删除。
`how='all'`：只有当行/列中所有值都是 `NaN` 时，才删除。

# 删除只有当所有值都是 NaN 的行 (此示例中不会删除任何行)
df_dropna_all_rows = (how='all')
print("删除所有值都为 NaN 的行后的 DataFrame:")
print(df_dropna_all_rows)
# 创建一个全 NaN 的行来演示 how='all'
df_with_all_nan_row = ({
'A': [1, ],
'B': [, ],
'C': [3, ]
})
[1] = # 第二行全为 NaN
print("带有全 NaN 行的 DataFrame:")
print(df_with_all_nan_row)
print("删除所有值都为 NaN 的行后的 DataFrame (how='all'):")
print((how='all'))

输出：删除所有值都为 NaN 的行后的 DataFrame:
A B C D E
0 1.0 NaN 11.0 NaN 16
1 2.0 7.0 12.0 NaN 17
2 NaN 8.0 13.0 NaN 18
3 4.0 9.0 NaN NaN 19
4 5.0 10.0 15.0 NaN 20
带有全 NaN 行的 DataFrame:
A B C
0 1.0 NaN 3.0
1 NaN NaN NaN
删除所有值都为 NaN 的行后的 DataFrame (how='all'):
A B C
0 1.0 NaN 3.0

3.3 `axis` 参数：指定删除方向

`axis` 参数控制是删除行还是列：
`axis=0` (默认)：删除包含 `NaN` 的行。
`axis=1`：删除包含 `NaN` 的列。

# 删除包含任何 NaN 值的列
df_dropped_cols = (axis=1)
print("删除包含任何 NaN 值的列后的 DataFrame:")
print(df_dropped_cols)
# 删除只有当所有值都是 NaN 的列
df_dropna_all_cols = (axis=1, how='all')
print("删除所有值都为 NaN 的列后的 DataFrame:")
print(df_dropna_all_cols)

输出：删除包含任何 NaN 值的列后的 DataFrame:
E
0 16
1 17
2 18
3 19
4 20
删除所有值都为 NaN 的列后的 DataFrame:
A B C E
0 1.0 NaN 11.0 16
1 2.0 7.0 12.0 17
2 NaN 8.0 13.0 18
3 4.0 9.0 NaN 19
4 5.0 10.0 15.0 20

可以看到，当 `axis=1` 和 `how='any'` 时，除了完全没有 `NaN` 的 `E` 列，其他所有列都被删除了。而 `how='all'` 时，只有全为 `NaN` 的 `D` 列被删除。

3.4 `thresh` 参数：设定非 NaN 值的最小数量

`thresh` 参数允许您指定一个整数，表示在行/列中至少需要有多少个非 `NaN` 值才能保留该行/列。如果非 `NaN` 值的数量低于 `thresh`，则该行/列将被删除。# 保留至少有 4 个非 NaN 值的行
df_thresh_rows = (thresh=4)
print("保留至少有 4 个非 NaN 值的行后的 DataFrame:")
print(df_thresh_rows)
# 保留至少有 3 个非 NaN 值的列
df_thresh_cols = (axis=1, thresh=3)
print("保留至少有 3 个非 NaN 值的列后的 DataFrame:")
print(df_thresh_cols)

输出：保留至少有 4 个非 NaN 值的行后的 DataFrame:
A B C D E
1 2.0 7.0 12.0 NaN 17
4 5.0 10.0 15.0 NaN 20
保留至少有 3 个非 NaN 值的列后的 DataFrame:
A B C E
0 1.0 NaN 11.0 16
1 2.0 7.0 12.0 17
2 NaN 8.0 13.0 18
3 4.0 9.0 NaN 19
4 5.0 10.0 15.0 20

对于 `df_thresh_rows`：

行 0: 有 3 个非 `NaN` (`1.0, 11.0, 16`)，小于 4，删除。
行 1: 有 4 个非 `NaN` (`2.0, 7.0, 12.0, 17`)，等于 4，保留。
行 2: 有 3 个非 `NaN` (`8.0, 13.0, 18`)，小于 4，删除。
行 3: 有 3 个非 `NaN` (`4.0, 9.0, 19`)，小于 4，删除。
行 4: 有 4 个非 `NaN` (`5.0, 10.0, 15.0, 20`)，等于 4，保留。

对于 `df_thresh_cols`：

列 A: 有 4 个非 `NaN`，保留。
列 B: 有 4 个非 `NaN`，保留。
列 C: 有 4 个非 `NaN`，保留。
列 D: 有 0 个非 `NaN`，小于 3，删除。
列 E: 有 5 个非 `NaN`，保留。

3.5 `subset` 参数：在特定列中检查 NaN

`subset` 参数允许您指定一个列名的列表。`dropna()` 将只在这些指定的列中检查 `NaN` 值，并根据结果删除行。# 只有当 'A' 或 'B' 列包含 NaN 时才删除行
df_subset_drop = (subset=['A', 'B'])
print("仅在 'A' 和 'B' 列中检查 NaN 并删除行后的 DataFrame:")
print(df_subset_drop)

输出：仅在 'A' 和 'B' 列中检查 NaN 并删除行后的 DataFrame:
A B C D E
1 2.0 7.0 12.0 NaN 17
4 5.0 10.0 15.0 NaN 20

在上述例子中：

行 0: `A` (1.0) 非空，`B` (`NaN`) 为空，删除。
行 1: `A` (2.0) 非空，`B` (7.0) 非空，保留。
行 2: `A` (`NaN`) 为空，删除。
行 3: `A` (4.0) 非空，`B` (9.0) 非空，保留。
行 4: `A` (5.0) 非空，`B` (10.0) 非空，保留。

3.6 `inplace` 参数：原地修改 DataFrame

默认情况下，`dropna()` 返回一个新的 DataFrame，而不修改原始 DataFrame。如果您希望直接修改原始 DataFrame，可以使用 `inplace=True`。# 原始 DataFrame
print("修改前的原始 DataFrame:")
print(df)
# 原地删除含有 NaN 的行
(inplace=True, how='all') # 这里使用 how='all' 以避免删除所有行
print("原地删除后（how='all'）的 DataFrame:")
print(df)

输出：修改前的原始 DataFrame:
A B C D E
0 1.0 NaN 11.0 NaN 16
1 2.0 7.0 12.0 NaN 17
2 NaN 8.0 13.0 NaN 18
3 4.0 9.0 NaN NaN 19
4 5.0 10.0 15.0 NaN 20
原地删除后（how='all'）的 DataFrame:
A B C D E
0 1.0 NaN 11.0 NaN 16
1 2.0 7.0 12.0 NaN 17
2 NaN 8.0 13.0 NaN 18
3 4.0 9.0 NaN NaN 19
4 5.0 10.0 15.0 NaN 20

再次提醒，由于原始 `df` 没有任何一行是“全 NaN”，因此 `inplace=True, how='all'` 没有删除任何行。如果使用 `inplace=True` 且不指定 `how='all'`（即默认为 `how='any'`），那么原始 `df` 将会变成一个空 DataFrame。

4. 进阶剔除策略与考量

在实际项目中，直接使用 `dropna()` 可能会导致数据量急剧减少，损失掉大量有价值的信息。因此，我们需要更精细地考量何时以及如何剔除 NaN。

4.1 基于缺失比例的剔除

有时，如果某一列的缺失值过多（例如超过 70%-80%），那么该列可能对分析或建模的价值不大，可以考虑直接删除整列。# 重新创建 DataFrame 以便演示
data = {
'A': [1, 2, , 4, 5],
'B': [, 7, 8, 9, 10],
'C': [11, 12, 13, , 15],
'D': [, , , , ], # 100% NaN
'F': [1, , , , ] # 80% NaN
}
df_extended = (data)
# 计算每列的缺失比例
missing_percentage = ().sum() / len(df_extended)
print("每列的缺失比例:")
print(missing_percentage)
# 定义一个缺失比例阈值
threshold = 0.7
columns_to_drop = missing_percentage[missing_percentage > threshold].index
df_filtered_by_missing_ratio = (columns=columns_to_drop)
print(f"删除缺失比例超过 {threshold*100}% 的列后的 DataFrame:")
print(df_filtered_by_missing_ratio)

输出：每列的缺失比例:
A 0.2
B 0.2
C 0.2
D 1.0
F 0.8
dtype: float64
删除缺失比例超过 70.0% 的列后的 DataFrame:
A B C
0 1.0 NaN 11.0
1 2.0 7.0 12.0
2 NaN 8.0 13.0
3 4.0 9.0 NaN
4 5.0 10.0 15.0

可以看到，`D` (100% NaN) 和 `F` (80% NaN) 列被成功删除。

5. 何时避免直接剔除 NaN：数据填充 (Imputation)

尽管本文主要讨论剔除 `NaN`，但作为一名专业的程序员，必须认识到，直接删除数据往往是最后选择的策略。当数据量较小或缺失值并非随机分布时，直接删除可能导致：
信息丢失：删除行或列会丢失数据，减少样本量，可能影响统计推断的可靠性。
引入偏见：如果缺失值并非随机分布，删除它们可能会导致数据集中存在的某种模式被改变，从而引入偏见。

在这种情况下，更推荐的策略是数据填充 (Imputation)，即用合理的值来替代 `NaN`。常见的数据填充方法包括：
均值/中位数/众数填充：用列的平均值、中位数或众数填充缺失值。适用于数值型数据，但不适用于类别型数据。
前向/后向填充：使用前一个有效值或后一个有效值填充缺失值。适用于时间序列数据。
常数填充：用一个固定值（如 0 或一个特定标记）填充缺失值。
高级填充方法：基于回归模型、KNN (K-Nearest Neighbors)、MICE (Multiple Imputation by Chained Equations) 等更复杂的方法。

Pandas 提供了 `()` 函数来实现数据填充。例如：df_filled_mean = ((numeric_only=True)) # 均值填充
print("均值填充后的 DataFrame:")
print(df_filled_mean)
df_filled_ffill = (method='ffill') # 前向填充
print("前向填充后的 DataFrame:")
print(df_filled_ffill)

输出：均值填充后的 DataFrame:
A B C D F
0 1.0 8.5 11.0 NaN 1.0
1 2.0 7.0 12.0 NaN 1.0
2 3.0 8.0 13.0 NaN 1.0
3 4.0 9.0 12.7 NaN 1.0
4 5.0 10.0 15.0 NaN 1.0
前向填充后的 DataFrame:
A B C D F
0 1.0 NaN 11.0 NaN 1.0
1 2.0 7.0 12.0 NaN 1.0
2 2.0 8.0 13.0 NaN 1.0
3 4.0 9.0 13.0 NaN 1.0
4 5.0 10.0 15.0 NaN 1.0

可以看到，`fillna()` 是处理 `NaN` 的另一种强大工具，但它属于“处理”而不是“剔除”。在选择策略时，需要根据数据的特性、缺失值的模式以及后续分析或模型的具体要求来决定。

6. 最佳实践与注意事项

专业的 NaN 处理并非一蹴而就，而是一个需要深思熟虑和迭代优化的过程：
理解数据背景：首先要了解数据是如何收集的，`NaN` 的出现可能代表什么。例如，在一个问卷中，某个问题没有回答和回答“不适用”可能都表现为 `NaN`，但其含义截然不同。
可视化缺失模式：使用像 `missingno` 这样的库（`import missingno as msno; (df)`）可以直观地看到 `NaN` 的分布模式，帮助判断缺失值是随机的、与特定变量相关的还是时间序列相关的。
评估数据损失：在删除任何数据之前，务必评估其对数据集大小和潜在信息的影响。对于小型数据集，应尽量避免大规模删除。
分列处理：不同的列可能需要不同的 NaN 处理策略。例如，数值型特征可以均值填充，类别型特征可以众数填充或创建新类别“缺失”。
文档化决策：在数据清洗过程中做出的所有决策（如删除哪些列、如何填充等）都应该被详细记录，以保证数据处理流程的透明性和可复现性。
迭代与验证：数据清洗是一个迭代过程。在处理完 `NaN` 之后，需要再次检查数据的分布、统计特性，并验证其是否符合预期，是否为后续分析或建模做好了准备。

总结

`NaN` 值是数据清洗中不可避免的挑战。Python 凭借其强大的 Pandas 库，为我们提供了灵活且高效的工具来检测和剔除这些缺失值。`()` 函数及其丰富的参数（`how`、`axis`、`thresh`、`subset`、`inplace`）使得我们可以根据具体业务场景和数据特性，精准地控制删除行为。然而，作为一名专业的程序员，我们不仅要掌握工具的使用，更要理解数据背后的含义，权衡数据损失与分析准确性之间的关系，并根据实际情况选择最合适的处理策略（剔除或填充）。通过熟练运用这些技术和遵循最佳实践，我们能够显著提升数据质量，为后续的数据分析和机器学习任务打下坚实的基础。

2025-10-25

---

上一篇：Python文件存在性检测：从基础到高级，构建健壮文件操作的基石

下一篇：Python模块导入深度解析：构建高效可维护代码的基石