вычесть столбцы, где отдельный столбец равен указанному c значению

Question

Я надеюсь вычесть столбцы, в которых отдельный столбец равен определенному значению c. Например, где Val == A, я хочу вычесть A - B. Однако, где Val == B, я хочу вычесть B - A.

df = pd.DataFrame({ 
    'Val' : ['A','B','A','B','A','B'],                  
    'A_1' : [1, 2, 3, 4, 5, 6], 
    'A_2' : [2, 3, 4, 5, 6, 1],              
    'B_1' : [6, 5, 4, 3, 2, 1],
    'B_2' : [6, 5, 4, 3, 2, 1],                        
        })

for x in df['Val']:
    
    if x == 'A':
        
        df['1_Sum'] = df.iloc[:,-4] - df.iloc[:,-2]
        df['2_Sum'] = df.iloc[:,-4] - df.iloc[:,-2]
        
    elif x == 'B':
        
        df['1_Sum'] = df.iloc[:,-2] - df.iloc[:,-4]
        df['2_Sum'] = df.iloc[:,-2] - df.iloc[:,-4]

Предполагаемый результат:

  Val  A_1  A_2  B_1  B_2  1_Sum  2_Sum
0   A    1    2    6    6     -5     -4
1   B    2    3    5    5      3      2 
2   A    3    4    4    4     -1      0
3   B    4    5    3    3     -1     -2
4   A    5    6    2    2      3      4
5   B    6    1    1    1     -5      0

Answer 1

Используйте numpy.select с вычитанием отфильтрованных столбцов на DataFrame.filter, только необходимый тот же порядок и одинаковый номер каждого столбца для групп A и B:

df1 = df.filter(like='A').sub(df.filter(like='B').to_numpy())
df2 = df.filter(like='B').sub(df.filter(like='A').to_numpy())
m1 = df['Val'].eq('A').to_numpy()[:, None]
m2 = df['Val'].eq('B').to_numpy()[:, None]

df3 = (pd.DataFrame(np.select([m1, m2], [df1, df2]), index=df.index)
         .rename(columns=lambda x: f'{x+1}_Sum'))
df = df.join(df3)
print (df)
  Val  A_1  A_2  B_1  B_2  1_Sum  2_Sum
0   A    1    2    6    6     -5     -4
1   B    2    3    5    5      3      2
2   A    3    4    4    4     -1      0
3   B    4    5    3    3     -1     -2
4   A    5    6    2    2      3      4
5   B    6    1    1    1     -5      0

Если вы хотите вычесть каждую серию отдельно:

mask = df.Val=='A'

df["1_Sum"] = np.where(mask, df.A_1 - df.B_1,  df.B_1 - df.A_1)
df["2_Sum"] = np.where(mask, df.A_2 - df.B_2,  df.B_2 - df.A_2)

print (df)
  Val  A_1  A_2  B_1  B_2  1_Sum  2_Sum
0   A    1    2    6    6     -5     -4
1   B    2    3    5    5      3      2
2   A    3    4    4    4     -1      0
3   B    4    5    3    3     -1     -2
4   A    5    6    2    2      3      4
5   B    6    1    1    1     -5      0

EDIT:

Никогда не используйте apply для вычитания значений, потому что петли под капотом очень медленные, здесь тест для DataFrame с 6k строками:

df = pd.DataFrame({ 
    'Val' : ['A','B','A','B','A','B'],                  
    'A_1' : [1, 2, 3, 4, 5, 6], 
    'A_2' : [2, 3, 4, 5, 6, 1],              
    'B_1' : [6, 5, 4, 3, 2, 1],
    'B_2' : [6, 5, 4, 3, 2, 1],                        
        })

df = pd.concat([df] * 1000, ignore_index=True)

df["1_Sum1"] = df.apply(lambda x: x.A_1 - x.B_1 if x.Val=='A' else x.B_1 - x.A_1, axis=1 )
df["1_Sum2"] = np.where(df.Val=='A', df.A_1 - df.B_1,  df.B_1 - df.A_1)


In [77]: %timeit df["1_Sum1"] = df.apply(lambda x: x.A_1 - x.B_1 if x.Val=='A' else x.B_1 - x.A_1, axis=1 )
271 ms ± 7.85 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [78]: %timeit df["1_Sum2"] = np.where(df.Val=='A', df.A_1 - df.B_1,  df.B_1 - df.A_1)
1.04 ms ± 4.22 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    

Answer 2

Здесь вы go:

df["1_Sum"] = df.apply(lambda x: x.A_1 - x.B_1 if x.Val=='A' else x.A_1 - x.B_1, axis=1 )

Аналогичным образом вы можете получить другой столбец. Нет необходимости повторять.