我必须将Pandas DataFrame的每一行数据与其馀行的数据进行比较，有没有一种方法可以加快计算速度？

Question

假设我有一个pandas DataFrame（从csv文件加载），其结构是这样的（var和err列的数量不是固定的，它因文件而异）：

var_0; var_1; var_2;
32;    9;     41;
47;    22;    41;
15;    12;    32;
3;     4;     4;
10;    9;     41;
43;    21;    45;
32;    14;    32;
51;    20;    40;

为了这个问题，让我们放弃err_ds_j和err_mean列。我必须对每一行的值与其他行的值进行自动比较；举个例子：我必须将第一行与第二行进行比较，然后与第三行进行比较，然后与第四行进行比较，依此类推，然后我必须将第二行与第一行进行比较，然后与第三行进行比较，对数据帧的其余部分进行比较，依此类推。

深入探讨问题，我想看看对于每两行，其中一行的所有“var_i”值是否都高于或等于另一行的对应值。如果满足这一点，则具有较高值的行称为DOMINANT（显性），我在另一个DataFrame中添加一行，结构如下：

SET_A; SET_B; DOMINANT_SET
0;     1;     B
...

其中SET_A和SET_B值是来自csv数据帧的索引，而DOMINANT_SET告诉我这两个值中的哪一个是主导集（或者如果没有主导集，则将其赋值为“none”）。我发现第三列很有用，因为它帮助我避免了以相反的方式比较的行（例如：比较行1和行0是无用的，因为我以前已经比较过0和1）。

因此，对于该csv文件，产生的输出应该是（实际上是，用我的代码）：

   SET_A SET_B DOMINANT_SET
1      0     1            B
2      0     2         none
3      0     3            A
4      0     4            A
5      0     5            B
6      0     6         none
7      0     7         none
8      1     2            A
9      1     3            A
10     1     4            A
11     1     5         none
12     1     6            A
13     1     7         none
14     2     3            A
15     2     4         none
16     2     5            B
17     2     6            B
18     2     7            B
19     3     4            B
20     3     5            B
21     3     6            B
22     3     7            B
23     4     5            B
24     4     6         none
25     4     7         none
26     5     6            A
27     5     7         none
28     6     7            B

import numpy as np
import pandas as pd

def couple_already_tested(index1, index2, dataframe):
    return (((dataframe['SET_A'] == index1) & (dataframe['SET_B'] == index2)).any()) | (((dataframe['SET_A'] == index2) & (dataframe['SET_B'] == index1)).any())

def check_dominance(set_a, set_b, index_i, index_j, dataframe):
    length = dataframe.shape[0]
    if np.all(set_a >= set_b):
        print("FOUND DOMINANT CONFIGURATION A > B")
        dataframe.loc[length+1] = [index_i,index_j,'A']
    elif np.all(set_b >= set_a):
        print("FOUND DOMINANT CONFIGURATION B > A")
        dataframe.loc[length+1] = [index_i,index_j,'B']
    else:
        dataframe.loc[length+1] = [index_i,index_j,'none']

df = pd.read_csv('test.csv', sep=';')
dom_table_df = pd.DataFrame(columns=['SET_A','SET_B','DOMINANT_SET'])
df_length = df.shape[0]
var_num = df.shape[1]-1 

a = None
b = None

for i in range(0, df_length):
    a = df.iloc[i, 0:var_num].values
    for j in range(0, df_length):
        if j == i:
            continue
        b = df.iloc[j, 0:var_num].values
        if couple_already_tested(i,j,dom_table_df):
            print("WARNING: configuration", i, j, "already compared, skipping")
        else:
            print("Comparing configuration at row", i, "with configuration at row", j)
            check_dominance(a, b, i, j, dom_table_df)

print(dom_table_df)

Answer 1

通过将.iloc[].values以及.loc[]替换为.values[]可以实现另一种加速，但是使用.loc[]我们必须调整下标，因为.values采用从零开始的下标，这与我们基于1的dom_table_df.index不同。

dom_table_df = pd.DataFrame(index=np.arange(1, 1+(df_length**2-df_length)/2).astype('i'),
                            columns=['SET_A', 'SET_B', 'DOMINANT_SET'])
length = 0  # counter of already filled rows
for i in range(0, df_length):
    a = df.values[i, 0:var_num]
    for j in range(i+1, df_length): # we can skip the range from 0 to i
        b = df.values[j, 0:var_num]
        #print("Comparing configuration at row", i, "with configuration at row", j)
        if np.all(a >= b):
            #print("FOUND DOMINANT CONFIGURATION A > B")
            dom_table_df.values[length] = [i, j, 'A']
        elif np.all(b >= a):
            #print("FOUND DOMINANT CONFIGURATION B > A")
            dom_table_df.values[length] = [i, j, 'B']
        else:
            dom_table_df.values[length] = [i, j, 'none']
        length += 1