比较两个Pandas DataFrame中某一列浮点数的差异数量，是数据一致性检查、回归测试和版本对比中的常见需求。当数据完全干净、没有任何缺失值时，用df1[col] != df2[col]再求和就能得到差异个数。可一旦列中出现了NaN，结果就会变得不可靠。因为NaN在浮点数标准中有一个反直觉的性质：它不等于任何值，包括它自己。这意味着两个位置上的NaN会被简单比较判定为不同，从而把相同的缺失状态错误地计入差异。这个问题在真实数据中非常普遍，因为浮点列经常由于采集缺失、计算异常等原因产生NaN。正确处理NaN并给出准确的差异计数，是每个数据工程师都需要掌握的技巧。

为什么NaN会让差异计数出错

NaN是Not a Number的缩写，由IEEE 754浮点标准定义。这个标准规定，NaN与任何数值的比较结果都应该是False，哪怕比较的对象是另一个NaN。在Python中可以用float('nan') != float('nan')验证，返回结果是True。Pandas底层依赖NumPy，而NumPy的浮点数组同样遵循这一规则。所以当两个Series在同一个索引位置上都是NaN时，表达式s1 != s2会返回True，表示它们被判定为不相等。

下面用一段最简单的代码复现这个问题。创建两个Series，第一个位置都是1.0，第二个位置都是NaN，第三个位置一个为2.5另一个为3.0。我们期望的差异数量应该是1，因为只有第三个位置真正不同。但直接比较并求和，得到的结果却是2。

import pandas as pd
import numpy as np
s1 = pd.Series([1.0, np.nan, 2.5])
s2 = pd.Series([1.0, np.nan, 3.0])
print(s1 != s2)
# 输出：
# 0    False
# 1     True
# 2     True
# dtype: bool
print((s1 != s2).sum())
# 输出：2

从输出中可以看到，索引1的两个NaN被标记成了True，这就是错误计数的来源。理解了这个底层机制，我们就能针对性地设计比较逻辑，把两个都为NaN的情况从差异掩码中剔除。

排除双NaN的差异计数方法

最直接的办法是在不等比较的基础上，叠加一个掩码来排除两边都是NaN的位置。具体做法是先用s1 != s2得到初步差异掩码，再用s1.isna() & s2.isna()得到双NaN掩码，最后对两个掩码做逻辑与的非运算。(s1 != s2) & ~(s1.isna() & s2.isna())的结果就是只包含真正差异的布尔Series，求和即可得到正确的差异数量。

import pandas as pd
import numpy as np
s1 = pd.Series([1.0, np.nan, 2.5])
s2 = pd.Series([1.0, np.nan, 3.0])
diff_mask = (s1 != s2) & ~(s1.isna() & s2.isna())
print(diff_mask)
# 输出：
# 0    False
# 1    False
# 2     True
# dtype: bool
print(diff_mask.sum())
# 输出：1

这段代码的结果是1，符合预期。这种掩码方法逻辑清晰、性能也不错，因为布尔运算在NumPy层是向量化的。它的一个优点是显式地表达了“双NaN不算差异”这一规则，可读性强。但需要注意，s1.isna() & s2.isna()中的&是按位与，不是Python的and，否则会得到标量布尔值而无法用于Series。

如果只是想判断两列是否完全相同，可以使用equals方法。s1.equals(s2)默认认为相同位置的NaN是相等的，因此直接返回True或False。但equals不能给出差异数量，只能作为整体一致性检查。另一个选择是使用compare方法。s1.compare(s2)返回一个只包含差异位置的DataFrame，而对于双NaN的位置，它会视为相同而不显示。因此对compare结果的行数计数，也能得到正确的差异数量。比如下面的代码：

import pandas as pd
import numpy as np
s1 = pd.Series([1.0, np.nan, 2.5])
s2 = pd.Series([1.0, np.nan, 3.0])
diff_df = s1.compare(s2)
print(diff_df)
# 输出：
#    self  other
# 2   2.5    3.0
print(len(diff_df))
# 输出：1

compare方法在Pandas 1.1.0以上版本中可用，它不仅处理NaN，还能同时展示两边不同的值，非常适合生成人工可读的差异报告。但它的开销比纯布尔掩码大，因为要构造新的DataFrame。如果只是统计数量，掩码方法更高效。

结合浮点容差进行比较

浮点数在计算机中是以二进制近似存储的，直接比较两个看似相等的浮点数有时会得到False。例如0.1 + 0.2 == 0.3在Python中返回False。所以在比较浮点列时，不应该使用精确相等，而应该允许一定的容差。NumPy提供了np.isclose函数来处理这个问题，它可以通过atol和rtol参数分别控制绝对容差和相对容差。更重要的是，np.isclose有一个equal_nan参数，当设置为True时，会把两个NaN视为相等。这正好同时解决了两个问题：浮点精度和NaN判断。

import pandas as pd
import numpy as np
s1 = pd.Series([0.1 + 0.2, np.nan, 2.5])
s2 = pd.Series([0.3, np.nan, 3.0])
diff_mask = ~np.isclose(s1, s2, equal_nan=True, atol=1e-8, rtol=1e-5)
print(diff_mask)
# 输出：
# 0    False
# 1    False
# 2     True
# dtype: bool
print(diff_mask.sum())
# 输出：1

在上面的代码中，第一个位置由于容差存在，0.1+0.2与0.3被判定为相等，第二个位置双NaN也被判定为相等，只有第三个位置真正不同。这样得到的差异计数既精确又可靠。需要注意的是，np.isclose默认的equal_nan为False，如果不显式设置为True，两个NaN会被判定为不相等，又会引入之前的错误。容差的选择要根据数据量纲和业务精度要求来确定。绝对容差适用于数值范围较小的数据，如果数值跨度很大，应使用相对容差，或者同时设置两者。

如果不想依赖np.isclose，也可以先排除双NaN，再对剩余部分进行容差比较。例如构造一个非NaN掩码，对非NaN位置计算(s1 - s2).abs() <= tolerance，然后与双NaN掩码的取反合并。这种方式更灵活，但代码会稍显冗长。在实际项目中，直接使用np.isclose(..., equal_nan=True)是最简洁的推荐方案。

对整个DataFrame进行差异计数与报告

真实场景往往需要比较两个DataFrame的多列差异，并生成一个汇总报告。可以设计一个通用函数，遍历所有公共列，根据列的数据类型选择合适的比较策略。对于浮点列，使用np.isclose并开启equal_nan=True；对于其他类型，使用掩码排除双NaN后直接比较。函数返回一个字典，记录每列的差异数量。

import pandas as pd
import numpy as np
def diff_count(df1, df2, tolerance=1e-8):
    common_cols = df1.columns.intersection(df2.columns)
    result = {}
    for col in common_cols:
        s1, s2 = df1[col], df2[col]
        if pd.api.types.is_float_dtype(s1) and pd.api.types.is_float_dtype(s2):
            diff_mask = ~np.isclose(
                s1, s2,
                equal_nan=True,
                atol=tolerance,
                rtol=tolerance
            )
        else:
            diff_mask = (s1 != s2) & ~(s1.isna() & s2.isna())
        result[col] = int(diff_mask.sum())
    return result
df1 = pd.DataFrame({
    'A': [1.0, np.nan, 2.5, 4.0],
    'B': ['x', 'y', 'z', 'w']
})
df2 = pd.DataFrame({
    'A': [1.0, np.nan, 3.0, 4.000000001],
    'B': ['x', 'y', 'z', 'v']
})
print(diff_count(df1, df2, tolerance=1e-6))
# 输出：
# {'A': 1, 'B': 1}

在这个案例中，列A的索引2真正不同，索引3虽然数值有微小差异，但被容差吸收；列B的索引3字符不同。函数返回的结果准确反映了每列的差异数量。如果需要更详细的信息，比如具体哪些行不同，可以返回diff_mask本身或调用compare生成差异表。另外，这个函数假设两个DataFrame的索引是对齐的。如果索引不一致，需要先执行df1 = df1.reset_index(drop=True)和df2 = df2.reset_index(drop=True)，或者确保两个DataFrame的索引完全一致后再比较。

对于列顺序不同但列名相同的情况，上述函数通过columns.intersection自动对齐了列，不会因为顺序不同而误判。如果两个DataFrame的列集合不完全相同，函数只会比较公共列。在需要严格校验的场景中，可以先检查列集合是否一致，再做差异计数。

总结来说，含NaN浮点列的差异计数问题，根源在于NaN不等于自身的语义。解决思路只有一条：在比较逻辑中显式处理NaN，同时兼顾浮点精度容差。掩码排除双NaN的方法简单高效，适合纯计数场景；compare方法适合生成详细的差异报告；而np.isclose结合equal_nan=True则是最全面且代码最简洁的方案。根据具体任务选择合适的工具，就能避免NaN带来的统计陷阱。