Как выполнить цикл сравнения одного столбца с соответствующим столбцом в Python

Question

У меня есть файл Excel, который я импортировал как фрейм данных.Я хочу перебрать столбцы данных.Например, я хочу сравнить 2-й столбец с первым, а затем 3-й столбец со вторым. Я преобразовал столбец rule_id в индекс.Это данные:

rule_id reqid1  reqid2  reqid3
53139   0         0      1
51181   1         1      0
50412   0         1      1
50356   0         0      1
50239   0         1      0
50238   1         1      0
50014   1         0      1      

И это код, который я использую.

for n in fin2.columns[0:]:
    n = 0
    n_int = int(n)
    if ([fin2.iloc[: , n_int+1] != fin2.iloc[: , n_int]]):
        print dframe2

    if ([fin2.iloc[: , n_int+1] == fin2.iloc[: , n_int]]):
        print dframe3
    n = n+1

С этим кодом я могу сравнивать только второй столбец с первым, я установилзначение от n до 0, а также применяется логика, n = n + 1, которая увеличивает значение n каждый раз, когда выполняются условия.Ваша помощь будет высоко ценится.Я создал эти две функции:

def solved_prior(df):
    n = 0
    n_int = int(n)
    df['solved_prior'] = np.where(df.iloc[: , n_int+1] < df.iloc[: , n_int] , 100 , np.nan)
    return df

и

def repeated_prior(df):
    n = 0
    n_int = int(n)
    df['repeated_prior'] = np.where((df.iloc[: , n_int+1] == df.iloc[: , n_int]) & (df.iloc[: , n_int] == 1) , 1 , np.nan)
    return df

Я сохранил эти функции в daframe2 и dataframe3 соответственно.Я хочу, чтобы результат для первого сравнения между 2-м и 1-м столбцом был следующим:

rule_id reqid1  reqid2  reqid3 solved prior repeated prior
    53139   0         0      1    NaN          NaN
    51181   1         1      0    NaN           1
    50412   0         1      1    NaN          NaN
    50356   0         0      1    NaN          NaN
    50239   0         1      0    NaN          NaN
    50238   1         1      0    NaN           1
    50014   1         0      1    100          NaN 

И результат для сравнения между 3-м и 2-м столбцом должен выглядеть следующим образом:

  rule_id reqid1     reqid2 reqid3 solved prior repeated prior
    53139   0         0      1       NaN          NaN
    51181   1         1      0       100          NaN
    50412   0         1      1       NaN           1
    50356   0         0      1       NaN          NaN
    50239   0         1      0       100          NaN
    50238   1         1      0       NaN          NaN
    50014   1         0      1       NaN          NaN 

Answer 1

Как и в одном из комментариев, ваш ожидаемый результат может повлиять на лучшее решение.Помня об этом, циклический переход по столбцам редко является лучшим решением.Я предлагаю просто добавить новые столбцы, которые указывают, равны ли сравниваемые столбцы или нет.Например:

In [1]: import pandas as pd

In [2]: df = pd.DataFrame({'rule_id': [53139,51181,50412,50356,50239,50238,50014], 'reqid1':[0,1,0,0,0,1,1],'reqid2':[0,1,1,0,1,1,0],'reqid3':[1,0,1,1,0,0,1]})

In [3]: df
Out[3]: 
   rule_id  reqid1  reqid2  reqid3
0    53139       0       0       1
1    51181       1       1       0
2    50412       0       1       1
3    50356       0       0       1
4    50239       0       1       0
5    50238       1       1       0
6    50014       1       0       1

In [4]: df['compare_1_and_2'] = df.reqid1 == df.reqid2

In [5]: df
Out[5]: 
   rule_id  reqid1  reqid2  reqid3  compare_1_and_2
0    53139       0       0       1             True
1    51181       1       1       0             True
2    50412       0       1       1            False
3    50356       0       0       1             True
4    50239       0       1       0            False
5    50238       1       1       0             True
6    50014       1       0       1            False

In [6]: df['compare_2_and_3'] = df.reqid2 == df.reqid3

In [7]: df
Out[7]: 
   rule_id  reqid1  reqid2  reqid3  compare_1_and_2  compare_2_and_3
0    53139       0       0       1             True            False
1    51181       1       1       0             True            False
2    50412       0       1       1            False             True
3    50356       0       0       1             True            False
4    50239       0       1       0            False            False
5    50238       1       1       0             True            False
6    50014       1       0       1            False            False

Теперь, если столбцы очень длинные, вы можете найти любые () и все () полезными.Чтобы увидеть, являются ли какие-либо из значений истинными (хотя бы одно значение идентично):

In [8]: df.compare_1_and_2.any()
Out[8]: True

И посмотреть, являются ли все значения истинными (столбцы идентичны):

In [9]: df.compare_1_and_2.all()
Out[9]: False

Редактировать: (чтобы соответствовать ожидаемому результату) Теперь просто использовать логические столбцы, чтобы соответствовать тому, что вам нужно

df['solved_prior_1_vs_2'] = np.NaN
df['repeated_prior_1_vs_2'] = np.NaN
df.loc[(df.compare_1_and_2 == False) & (df.reqid1 == 1),'solved_prior_1_vs_2'] = 100
df.loc[(df.compare_1_and_2 == True) & (df.reqid1 == 1),'repeated_prior_1_vs_2'] = 1

И результаты выглядят так:

In [27]: df[['rule_id','reqid1','reqid2','solved_prior_1_vs_2','repeated_prior_1_vs_2']]
Out[27]: 
   rule_id  reqid1  reqid2  solved_prior_1_vs_2  repeated_prior_1_vs_2
0    53139       0       0                  NaN                    NaN
1    51181       1       1                  NaN                    1.0
2    50412       0       1                  NaN                    NaN
3    50356       0       0                  NaN                    NaN
4    50239       0       1                  NaN                    NaN
5    50238       1       1                  NaN                    1.0
6    50014       1       0                100.0                    NaN

Теперь вы можете удалить ненужные столбцы и сделать то же самое для сравнения 2–3. Также можно преобразовать новые столбцы в целые.

Окончательное редактирование (надеюсь): более простое решение -просто определите функцию, например:

def compare_columns(df, col1, col2):
    repeated_name = "{}_{}_repeated".format(col1, col2)
    solved_name = "{}_{}_solved".format(col1, col2)
    diff = df[col1] == df[col2]
    col1_is_1 = df[col1] == 1
    df[repeated_name] = 100
    df[solved_name] = 1
    df[repeated_name] = df[repeated_name].astype(int)
    df[solved_name] = df[sovled_name].astype(int)
    df.loc[~(diff & col1_is_1), solved_name] = np.NaN
    df.loc[~(~diff & col1_is_1), repeated_name] = np.NaN
    return df

И теперь вы можете просто сделать:

In [42]: df1 = compare_columns(df, 'reqid1', 'reqid2')
In [43]: df1
Out[43]: 
   rule_id  reqid1  reqid2  reqid3  reqid1_reqid2_repeated  reqid1_reqid2_solved
0    53139       0       0       1                     NaN                   NaN
1    51181       1       1       0                     NaN                   1
2    50412       0       1       1                     NaN                   NaN
3    50356       0       0       1                     NaN                   NaN
4    50239       0       1       0                     NaN                   NaN
5    50238       1       1       0                     NaN                   1
6    50014       1       0       1                     100                   NaN