应用自定义groupby聚合函数在pandas python中输出二进制结果

编程问答 2022-01-05

问题描述

import numpy as np
import pandas as pd

df = pd.DataFrame({'Buy/Sell': [1, 0, 1, 1, 0, 1, 0, 0],
                   'Trader': ['A', 'A', 'B', 'B', 'B', 'C', 'C', 'C']})

grouped = df.groupby(['Trader'])
result = grouped['Buy/Sell'].agg(['sum', 'count'])
means = grouped['Buy/Sell'].mean()
result['Buy/Sell'] = np.select(condlist=[means>0.5, means<0.5], choicelist=[1, 0], 
    default=np.nan)
print(result)

产量

        Buy/Sell  sum  count
Trader                      
A            NaN    1      2
B              1    2      3
C              0    1      3

我最初的答案使用了一个自定义聚合器categorize：

def categorize(x):
    m = x.mean()
    return 1 if m > 0.5 else 0 if m < 0.5 else np.nan
result = df.groupby(['Trader'])['Buy/Sell'].agg([categorize, 'sum', 'count'])
result = result.rename(columns={'categorize' : 'Buy/Sell'})

虽然调用自定义函数可能很方便，但与内置聚合器（如groupby/agg/mean）相比，使用自定义函数时的性能通常会大大降低。内置的聚合器是Cythonized的，而自定义函数将性能降低到普通的Python for循环速度。

当组数很大时，速度差异特别明显。例如，对于具有1000个组的10000行DataFrame，

import numpy as np
import pandas as pd
np.random.seed(2017)
N = 10000
df = pd.DataFrame({
    'Buy/Sell': np.random.randint(2, size=N),
    'Trader': np.random.randint(1000, size=N)})

def using_select(df):
    grouped = df.groupby(['Trader'])
    result = grouped['Buy/Sell'].agg(['sum', 'count'])
    means = grouped['Buy/Sell'].mean()
    result['Buy/Sell'] = np.select(condlist=[means>0.5, means<0.5], choicelist=[1, 0], 
        default=np.nan)
    return result

def categorize(x):
    m = x.mean()
    return 1 if m > 0.5 else 0 if m < 0.5 else np.nan

def using_custom_function(df):
    result = df.groupby(['Trader'])['Buy/Sell'].agg([categorize, 'sum', 'count'])
    result = result.rename(columns={'categorize' : 'Buy/Sell'})
    return result

using_select比快50倍以上using_custom_function：

In [69]: %timeit using_custom_function(df)
10 loops, best of 3: 132 ms per loop

In [70]: %timeit using_select(df)
100 loops, best of 3: 2.46 ms per loop

In [71]: 132/2.46
Out[71]: 53.65853658536585

解决方法

我有一个交易者交易的数据集，其中感兴趣的变量Buy/Sell是二进制的，取值1 f表示该交易为买入交易，值为0则为卖出交易。一个示例如下所示：

Trader     Buy/Sell
  A           1
  A           0
  B           1
  B           1
  B           0
  C           1
  C           0
  C           0

我想计算Buy/Sell每个交易者的净额，这样，如果交易者有超过50％的交易作为买入，他将有一个Buy/Sell1，如果他有少于50％的买入，那么他将有Buy/Sell0和恰好有50％的人将拥有NA（并且在以后的计算中将被忽略）。

因此，对于交易者A，买入比例​​为（买入数量）/（交易者总数）= 1/2 = 0.5，得出NA。

对于交易者B，它是2/3 = 0.67，得出1

对于交易者C，它是1/3 = 0.33，得出0

该表应如下所示：

Trader     Buy/Sell
  A           NA
  B           1
  C           0

最终，我想计算购买总数，在这种情况下为1，总交易总数（不考虑资产净值），在这种情况下为2。我对第二张表不感兴趣，我只是感兴趣的总购买次数和的总数（总数）Buy/Sell。

如何在熊猫中做到这一点？

python