python - Pandas 在给定多个条件的情况下计算多列的总和

Question

我有一个宽表，格式如下(最多可容纳 10 人):

person1_status | person2_status | person3_status | person1_type | person_2 type | person3_type 
       0       |        1       |        0       |        7     |        4      |        6  

status 可以是 0 或 1(前 3 列)。

type 可以是 4-7 之间的#。这里的值对应另外一个表，是根据类型来指定值的。所以……

Type | Value
 4   |   10
 5   |   20
 6   |   30
 7   |   40

我需要计算两列“A”和“B”，其中:

1. A 是每个人的类型(在该行中)的值的总和，其中状态 = 0。
2. B 是每个人的类型(在该行中)的值的总和，其中状态 = 1。

例如，结果列“A”和“B”如下所示:

A  | B
70 | 10

对此的解释:

'A' 的值为 70，因为 person1 和 person3 的“status”为 0，对应类型为 7 和 6(对应于值 30 和 40)。

同样，应该有另一列 'B' 的值为“10”，因为只有 person2 的状态为“1”并且他们的类型为“4”(对应值为 10)。

这可能是一个愚蠢的问题，但我如何以矢量化的方式做到这一点？我不想使用 for 循环或任何东西，因为它会降低效率......

我希望这是有道理的...有人可以帮助我吗？我想我已经脑残了，想弄清楚这个问题。

对于更简单的计算列，我只使用了 np.where 但我有点卡在这里，因为我需要在给定特定条件的情况下计算多个列的值的总和，同时从单独的表中提取这些值。 .

希望这是有道理的

Answer 1

使用 filter 方法过滤其中出现字符串的列名。

为查找值 other_table 创建数据框，并将索引设置为类型列。

df_status = df.filter(like = 'status')
df_type = df.filter(like = 'type')
df_type_lookup = df_type.applymap(lambda x: other_table.loc[x]).values

df['A'] = np.sum((df_status == 0).values * df_type_lookup, 1)
df['B'] = np.sum((df_status == 1).values * df_type_lookup, 1)

完整示例如下:

创建虚假数据

df = pd.DataFrame({'person_1_status':np.random.randint(0, 2,1000) , 
                   'person_2_status':np.random.randint(0, 2,1000), 
                   'person_3_status':np.random.randint(0, 2,1000), 
                   'person_1_type':np.random.randint(4, 8,1000), 
                   'person_2_type':np.random.randint(4, 8,1000),
                   'person_3_type':np.random.randint(4, 8,1000)},
                 columns= ['person_1_status', 'person_2_status', 'person_3_status',
                           'person_1_type', 'person_2_type', 'person_3_type'])

 person_1_status  person_2_status  person_3_status  person_1_type  \
0                1                0                0              7   
1                0                1                0              6   
2                1                0                1              7   
3                0                0                0              7   
4                0                0                1              4   

   person_3_type  person_3_type  
0              5              5  
1              7              7  
2              7              7  
3              7              7  
4              7              7 

制作other_table

other_table = pd.Series({4:10, 5:20, 6:30, 7:40})

4    10
5    20
6    30
7    40
dtype: int64

将状态和类型列过滤到自己的数据框中

df_status = df.filter(like = 'status')
df_type = df.filter(like = 'type')

制作查找表

df_type_lookup = df_type.applymap(lambda x: other_table.loc[x]).values

跨行应用矩阵乘法和求和。

df['A'] = np.sum((df_status == 0).values * df_type_lookup, 1)
df['B'] = np.sum((df_status == 1).values * df_type_lookup, 1)

输出

 person_1_status  person_2_status  person_3_status  person_1_type  \
0                0                0                1              7   
1                0                1                0              4   
2                0                1                1              7   
3                0                1                0              6   
4                0                0                1              5   

   person_2_type  person_3_type   A   B  
0              7              5  80  20  
1              6              4  20  30  
2              5              5  40  40  
3              6              4  40  30  
4              7              5  60  20