下面是一个稍显丑陋但速度更快的解决方案：

In [44]: pd.DataFrame(np.sort(data.values, axis=1), columns=data.columns).drop_duplicates()
Out[44]:
    A   B
0   0  50
1  10  22
2  11  35
3   5  21

时序：用于8K行DF

In [50]: big = pd.concat([data] * 10**3, ignore_index=True)

In [51]: big.shape
Out[51]: (8000, 2)

In [52]: %timeit big.apply(lambda r: sorted(r), axis = 1).drop_duplicates()
1 loop, best of 3: 3.04 s per loop

In [53]: %timeit pd.DataFrame(np.sort(big.values, axis=1), columns=big.columns).drop_duplicates()
100 loops, best of 3: 3.96 ms per loop

In [59]: %timeit big.apply(np.sort, axis = 1).drop_duplicates()
1 loop, best of 3: 2.69 s per loop

您可以在删除重复项之前对数据框的每一行进行排序：

data.apply(lambda r: sorted(r), axis = 1).drop_duplicates()

#   A    B
#0  0   50
#1  10  22
#2  11  35
#3  5   21

如果希望结果按列A排序：

data.apply(lambda r: sorted(r), axis = 1).drop_duplicates().sort_values('A')

#   A    B
#0  0   50
#3  5   21
#1  10  22
#2  11  35

现在这个解决方案起作用了

data.set_index(['A','B']).stack().drop_duplicates().unstack().reset_index()

可以根据需要添加更多的列。

data.set_index(['A','B', 'C']).stack().drop_duplicates().unstack().reset_index()

drop_duplicates（）函数的一个示例

这里是一个有点冗长的解决方案，但可能对初学者有帮助-
创建新列，以便对列A和列B中的值进行跨行排序-

data['C'] = np.where(data['A']<data['B'] , data['A'], data['B'])
data['D'] = np.where(data['A']>data['B'] , data['A'], data['B'])

删除重复项，按列“C”排序，并重命名列

data2 = data[['C', 'D']].drop_duplicates().sort_values('C')
data2.columns = ['A', 'B']   
data2

PS -“np.where”函数的工作原理与Excel中的If公式类似（逻辑条件，值为TRUE，值为FALSE）

另一个经典的选择是将这些值聚合为一个冻结集合，并使用布尔索引。

out = data[~data[['A', 'B']].agg(frozenset, axis=1).duplicated()]

输出量：

A   B
0   0  50
1  10  22
2  11  35
3  21   5

它的效率也相当高，尽管不如经过优化的np.sort方法：

%timeit big.apply(lambda r: sorted(r), axis = 1).drop_duplicates()
27.2 ms ± 914 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit pd.DataFrame(np.sort(big.values, axis=1), columns=big.columns).drop_duplicates()
733 µs ± 20.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit big.apply(np.sort, axis = 1).drop_duplicates()
12 s ± 403 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit big[~big[['A', 'B']].agg(frozenset, axis=1).duplicated()]
25 ms ± 657 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)