"Pandas DataFrames 中的平等 - 列顺序很重要？"

Question

作为单元测试的一部分，我需要测试两个 DataFrame 是否相等。 DataFrames 中列的顺序对我来说并不重要。 然而，这对 Pandas 来说似乎很重要：

import pandas
df1 = pandas.DataFrame(index = [1,2,3,4])
df2 = pandas.DataFrame(index = [1,2,3,4])
df1['A'] = [1,2,3,4]
df1['B'] = [2,3,4,5]
df2['B'] = [2,3,4,5]
df2['A'] = [1,2,3,4]
df1 == df2

结果是：

Exception: Can only compare identically-labeled DataFrame objects

我相信表达式df1 == df2应该评估为包含所有True值的 DataFrame。 显然，在这种情况下==的正确功能应该是什么是值得商榷的。 我的问题是：有没有一种 Pandas 方法可以满足我的要求？ 也就是说，有没有办法进行忽略列顺序的相等比较？

Answer 1

最常见的意图是这样处理的：

def assertFrameEqual(df1, df2, **kwds ):
    """ Assert that two dataframes are equal, ignoring ordering of columns"""
    from pandas.util.testing import assert_frame_equal
    return assert_frame_equal(df1.sort_index(axis=1), df2.sort_index(axis=1), check_names=True, **kwds )

当然，您可以传递的其他参数请参见pandas.util.testing.assert_frame_equal

Answer 2

您可以使用sort_index对列进行sort_index ：

df1.sort_index(axis=1) == df2.sort_index(axis=1)

这将评估为所有True值的数据帧。

---

正如@osa 评论的那样，这对于 NaN 失败并且也不是特别健壮，实际上可能建议使用类似于 @quant 的答案的内容（注意：如果有问题，我们想要一个 bool 而不是 raise ）：

def my_equal(df1, df2):
    from pandas.util.testing import assert_frame_equal
    try:
        assert_frame_equal(df1.sort_index(axis=1), df2.sort_index(axis=1), check_names=True)
        return True
    except (AssertionError, ValueError, TypeError):  perhaps something else?
        return False

Answer 3

def equal( df1, df2 ):
    """ Check if two DataFrames are equal, ignoring nans """
    return df1.fillna(1).sort_index(axis=1).eq(df2.fillna(1).sort_index(axis=1)).all().all()

Answer 4

通常你会想要快速测试，而排序方法对于较大的索引可能会非常低效（就像你使用行而不是列来解决这个问题一样）。 sort 方法也容易受到非唯一索引的假阴性的影响。

幸运的是， pandas.util.testing.assert_frame_equal已经更新了check_like选项。 将此设置为 true，测试中将不考虑排序。

对于非唯一索引，您将得到神秘的ValueError: cannot reindex from a duplicate axis 。 这是由reindex_like操作引发的，该操作重新排列一个 DataFrame 以匹配另一个的顺序。 重建索引比如下证明排序快得多。

import pandas as pd
from pandas.util.testing import assert_frame_equal

df  = pd.DataFrame(np.arange(1e6))
df1 = df.sample(frac=1, random_state=42)
df2 = df.sample(frac=1, random_state=43)

%timeit -n 1 -r 5 assert_frame_equal(df1.sort_index(), df2.sort_index())
## 5.73 s ± 329 ms per loop (mean ± std. dev. of 5 runs, 1 loop each)

%timeit -n 1 -r 5 assert_frame_equal(df1, df2, check_like=True)
## 1.04 s ± 237 ms per loop (mean ± std. dev. of 5 runs, 1 loop each)

对于那些喜欢良好性能比较图的人：

重新索引与对 int 和 str 索引进行排序（str 更加激烈）

Answer 5

仅当行和列标签在整个框架中匹配时，对列进行排序才有效。 假设您在单元格中有 2 个具有相同值但具有不同标签的数据框，那么排序解决方案将不起作用。 我在使用 Pandas 实现 k 模式聚类时遇到了这种情况。

我用一个简单的 equals 函数绕过它来检查单元格相等性（下面的代码）

def frames_equal(df1,df2) :
    if not isinstance(df1,DataFrame) or not isinstance(df2,DataFrame) :
        raise Exception(
            "dataframes should be an instance of pandas.DataFrame")

    if df1.shape != df2.shape:
        return False

    num_rows,num_cols = df1.shape
    for i in range(num_rows):
       match = sum(df1.iloc[i] == df2.iloc[i])
       if match != num_cols :
          return False
   return True

Answer 6

你试过使用 df1.equals(df2) 吗？ 我认为 df1==df2 更可靠，但我不确定它是否会解决您的列顺序问题。

http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.equals.html

Answer 7

您可能需要函数来比较 DataFrames 忽略行和列顺序？ 唯一的要求是有一些唯一的列将其用作索引。

f1 = pd.DataFrame([
    {"id": 1, "foo": "1", "bar": None},
    {"id": 2, "foo": "2", "bar": 2},
    {"id": 3, "foo": "3", "bar": 3},
    {"id": 4, "foo": "4", "bar": 4}
])
f2 = pd.DataFrame([
    {"id": 3, "foo": "3", "bar": 3},
    {"id": 1, "bar": None, "foo": "1",},
    {"id": 2, "foo": "2", "bar": 2},
    {"id": 4, "foo": "4", "bar": 4}
])

def comparable(df, index_col='id'):
    return df.fillna(value=0).set_index(index_col).to_dict('index')

comparable(f1) == comparable (f2)  # returns True

Answer 8

当处理包含元组和列表等 Python 对象的数据帧时， df.eq(df2)和df == df2不够的。 即使每个数据帧中的相同单元格包含相同的对象，例如(0, 0) ，相等比较也会导致False 。 要解决此问题，请在比较之前将所有列转换为字符串：

df.apply(lambda x: x.astype(str)).eq(df2.apply(lambda x: x.astype(str)))

Answer 9

assert_frame_equal<\/code>中的pandas.testing<\/code>是一个检查帧是否相等的函数。 如assert_frame_equal<\/code> 文档<\/a>中所述，如果将check_like<\/code>参数设置为True<\/code> ，它将忽略索引和列的顺序。

"