如何高效校验pandas DataFrame列表两两共有行列子集的相等性

需求说明 #

持有存储多个pandas DataFrame的列表，需满足校验规则：任意两个DataFrame之间，二者共有的行索引、共有的列对应的子集数据完全相等。
示例测试数据构造代码如下：

import pandas as pd

df1 = pd.DataFrame({"ix": [1, 2, 3], "1": [3, 4, 5]                }).set_index("ix")
df2 = pd.DataFrame({"ix": [1, 2   ], "1": [3, 4   ], "2": [3, 4   ]}).set_index("ix")
df3 = pd.DataFrame({"ix": [   2, 3], "1": [   4, 5], "2": [   4, 6]}).set_index("ix")
df4 = pd.DataFrame({"ix": [      3],                 "2": [      6]}).set_index("ix")
dataframes = [df1, df2, df3, df4]

现有实现的问题 #

当前采用两两配对双重循环的校验逻辑：

from pandas._testing import assert_frame_equal

kwargs = {"check_dtype": False, "check_like": True}

for i, left in enumerate(dataframes):
    for right in dataframes[i + 1:]:
        cl = left.columns.intersection(right.columns)
        ix = left.index.intersection(right.index)
        assert_frame_equal(left.loc[ix, cl], right.loc[ix, cl], **kwargs)

该实现时间复杂度为O(n²)，当DataFrame列表长度较长、单表数据量较大时，会产生大量重复的交集计算、切片、比对操作，性能损耗非常明显，不是最优实现。

优化实现思路 #

核心逻辑是放弃两两比对，转为全局统一校验：

1. 先收集所有DataFrame出现过的全部行索引、列名，构建统一的坐标体系
2. 校验每个(行索引, 列名)坐标位置上，所有DataFrame在该位置的非空值完全一致
   该逻辑和原需求等价：只要每个坐标点的非空值唯一，任意两个DataFrame取共有行、共有列的子集必然完全相等，时间复杂度从O(n²)降到线性级别。

常规内存版本（速度最快） #

适合内存充足的场景，用numpy数组批量处理减少循环开销：

import numpy as np

# 收集全量索引和列
all_index = sorted({idx for df in dataframes for idx in df.index})
all_cols = sorted({col for df in dataframes for col in df.columns})

# 所有DataFrame对齐到统一结构后堆叠
stacked = np.full((len(dataframes), len(all_index), len(all_cols)), np.nan)
for df_idx, df in enumerate(dataframes):
    aligned_df = df.reindex(index=all_index, columns=all_cols)
    stacked[df_idx] = aligned_df.values

# 逐坐标校验非空值唯一性
for row_pos, row_name in enumerate(all_index):
    for col_pos, col_name in enumerate(all_cols):
        cell_values = stacked[:, row_pos, col_pos]
        valid_values = cell_values[~pd.isna(cell_values)]
        if len(np.unique(valid_values)) > 1:
            raise AssertionError(f"数据不一致：行索引{row_name}、列{col_name}存在多个冲突值")

该实现自动兼容原逻辑的check_like=True（不要求索引、列顺序一致）、check_dtype=False（不强制校验数据类型）要求，报错时可以直接定位到冲突的具体单元格，排查效率更高。

低内存版本 #

适合单表数据量极大、内存不足以存放全量堆叠数组的场景，遍历过程中只存每个坐标第一次出现的非空值，后续遇到同坐标值直接比对，冲突立刻抛错：

# 初始化值存储表
all_index = sorted({idx for df in dataframes for idx in df.index})
all_cols = sorted({col for df in dataframes for col in df.columns})
value_map = pd.DataFrame(index=all_index, columns=all_cols, dtype=object)

for df in dataframes:
    for row in df.index:
        for col in df.columns:
            current_val = df.loc[row, col]
            stored_val = value_map.loc[row, col]
            if pd.isna(stored_val):
                value_map.loc[row, col] = current_val
            else:
                # 跳过两边都是空值的情况，值不一致则抛错
                if not (current_val == stored_val or (pd.isna(current_val) and pd.isna(stored_val))):
                    raise AssertionError(f"数据不一致：行索引{row}、列{col}，已存值{stored_val}，新值{current_val}")

两种实现的性能都远高于原双重循环方案，DataFrame数量越多，性能优势越明显。

内容的提问来源于stack exchange，提问作者PanchoVarallo