Как рассчитать с условиями в pandas? - PullRequest
Новая
       9

Как рассчитать с условиями в pandas?

0 голосов
/ 23 января 2020

У меня есть такой фрейм данных, я хочу вычислить и добавить новый столбец, который соответствует формуле: Value = A(where Time=1) + A(where Time=3), я не хочу использовать A (где Time = 5). 

Type subType Time   A           Value
 X    a       1      3         =3+9=12
 X    a       3      9  
 X    a       5      9
 X    b       1      4         =4+5=9
 X    b       3      5 
 X    b       5      0
 Y    a       1      1         =1+2=3
 Y    a       3      2  
 Y    a       5      3
 Y    b       1      4         =4+5=9
 Y    b       3      5 
 Y    b       5      2

Я знаю, как это сделать, выбрав ячейку, необходимую для формулы, но есть ли другие более эффективные способы выполнения вычислений? Я подозреваю, что мне нужно добавить условие, но не знаю, как, любое предложение?

Ответы [ 3 ]

3 голосов
/ 23 января 2020

Вы можете использовать groupby для суммирования A, когда Time не равен 5. Затем объедините его с оригинальным df. 

(
    df.groupby(by=['Type','subType'])
    .apply(lambda x: x.loc[x.Time!=5].A.sum()) # sum time each group exclu
    .to_frame('Value').reset_index()
    .pipe(lambda x: pd.merge(df, x, on=['Type', 'subType'], how='left'))
)


    Type    subType Time    A   Value
0   X       a       1       3   12.0
1   X       a       3       9   12.0
2   X       a       5       9   12.0
3   X       b       1       4   9.0
4   X       b       3       5   9.0
5   X       b       5       0   9.0
6   Y       a       1       1   3.0
7   Y       a       3       2   3.0
8   Y       a       5       3   3.0
9   Y       b       1       4   9.0
10  Y       b       3       5   9.0
11  Y       b       5       2   9.0
3 голосов
/ 23 января 2020

Используйте Series.eq с DataFrame.groupby и Series.cumsum для создания групп и добавления. 

c1 = df.Time.eq(1)
c3 = df.Time.eq(3)
df['Value'] = (df.loc[c1|c3]
                 .groupby(c1.cumsum())
                 .A
                 .transform('sum')
                 .loc[c1])
print(df)

или если вы хотите идентифицировать его на основе неэквивалентности с 5 : 

c = df['Time'].eq(5)
df['value'] = (df['A'].mask(c)
                     .groupby(c.cumsum())
                     .transform('sum')
                     .where(c.shift(fill_value = True))
              )
 #Another option is map
 c = df['Time'].eq(5)
 c_cumsum = c.cumsum()
 df['value'] = (c_cumsum.map(df['A'].mask(c)
                       .groupby(c_cumsum)
                       .sum())
                       .where(c.shift(fill_value = True)))

Выход 

   Type subType  Time  A  Value
0     X       a     1  3   12.0
1     X       a     3  9    NaN
2     X       a     5  9    NaN
3     X       b     1  4    9.0
4     X       b     3  5    NaN
5     X       b     5  0    NaN
6     Y       a     1  1    3.0
7     Y       a     3  2    NaN
8     Y       a     5  3    NaN
9     Y       b     1  4    9.0
10    Y       b     3  5    NaN
11    Y       b     5  2    NaN

пропущенные значения 

c = df['Time'].eq(5)
df['value'] = (df['A'].mask(c)
                     .groupby(c.cumsum())
                     .transform('sum')

              )
#or method 1
#c1 = df.Time.eq(1)
#c3 = df.Time.eq(3)
#df['Value'] = (df.loc[c1|c3]
#                 .groupby(c1.cumsum())
#                 .A
#                 .transform('sum')
#               )
print(df)

Выход 

   Type subType  Time  A  value
0     X       a     1  3   12.0
1     X       a     3  9   12.0
2     X       a     5  9    9.0
3     X       b     1  4    9.0
4     X       b     3  5    9.0
5     X       b     5  0    3.0
6     Y       a     1  1    3.0
7     Y       a     3  2    3.0
8     Y       a     5  3    9.0
9     Y       b     1  4    9.0
10    Y       b     3  5    9.0
11    Y       b     5  2    0.0

или заполнение всех, кроме тех случаев, где время 5 

c = df['Time'].eq(5)
df['value'] = (df['A'].mask(c)
                     .groupby(c.cumsum())
                     .transform('sum').mask(c))

#c1 = df.Time.eq(1)
#c3 = df.Time.eq(3)
#or method 1
#df['Value'] = (df.loc[c1|c3]
#                 .groupby(c1.cumsum())
#                 .A
#                 .transform('sum')
#                 .loc[c1|c3])
print(df)
   Type subType  Time  A  value
0     X       a     1  3   12.0
1     X       a     3  9   12.0
2     X       a     5  9    NaN
3     X       b     1  4    9.0
4     X       b     3  5    9.0
5     X       b     5  0    NaN
6     Y       a     1  1    3.0
7     Y       a     3  2    3.0
8     Y       a     5  3    NaN
9     Y       b     1  4    9.0
10    Y       b     3  5    9.0
11    Y       b     5  2    NaN

Почему бы не применить здесь?

Даже в небольшом кадре данных это уже медленнее 

%%timeit

(
    df.groupby(by=['Type','subType'])
    .apply(lambda x: x.loc[x.Time!=5].A.sum()) # sum time each group exclu
    .to_frame('Value').reset_index()
    .pipe(lambda x: pd.merge(df, x, on=['Type', 'subType'], how='left'))
)
13.6 ms ± 2.67 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)

%%timeit
c = df['Time'].eq(5)
df['value'] = (df['A'].mask(c)
                     .groupby(c.cumsum())
                     .transform('sum')
                     .where(c.shift(fill_value = True))
              )

3.67 ms ± 118 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
0 голосов
/ 23 января 2020

Ответ с использованием только индексации и условий: 

df.loc[df['Time'] == 1,'Value'] = (df[df['Time'] == 1].reset_index()+df[df['Time'] == 3].reset_index())['A'].values
df

   Type subType  Time  A  Value
0     X       a     1  3   12.0
1     X       a     3  9    NaN
2     X       a     5  9    NaN
3     X       b     1  4    9.0
4     X       b     3  5    NaN
5     X       b     5  0    NaN
6     Y       a     1  1    3.0
7     Y       a     3  2    NaN
8     Y       a     5  3    NaN
9     Y       b     1  4    9.0
10    Y       b     3  5    NaN
11    Y       b     5  2    NaN
...