具有组条件的熊猫自定义聚合函数，这可能吗？

Question

我有以下数据框：

df = pd.DataFrame(
  [{'price': 22, 'weight': 1, 'product': 'banana', },
  {'price': 20, 'weight': 2, 'product': 'apple', },
  {'price': 18, 'weight': 2, 'product': 'car', },
  {'price': 100, 'weight': 1, 'product': 'toy', },
  {'price': 27, 'weight': 1, 'product': 'computer', },
  {'price': 200, 'weight': 1, 'product': 'book', },
  {'price': 200.5, 'weight': 3, 'product': 'mouse', },
  {'price': 202, 'weight': 3, 'product': 'door', },]
)

我必须做的是按连续价格分组，它们之间的差异是否小于阈值（例如 2.0）。之后，我必须仅对“小于阈值”的组应用以下聚合，否则不应聚合该组：

1. price 应该是 price 和 weight 之间的加权平均值
2. weight 应该是最大值
3. product 应该是字符串拼接

到目前为止我做了什么（一步一步）：

1. 我按价格升序对数据框进行了排序（以获取连续值）

df.sort_values(by=['price'], inplace=True)

    price  weight   product
2   18.0       2       car
1   20.0       2     apple
0   22.0       1    banana
4   27.0       1  computer
3  100.0       1       toy
5  200.0       1      book
6  200.5       3     mouse
7  202.0       3      door    

1. 获取价格之间的升序和降序价格差异以检测连续价格

df['asc_diff'] = df['price'].diff(periods=1)
df['desc_diff'] = df['price'].diff(periods=-1).abs()

    price  weight   product  asc_diff  desc_diff
2   18.0       2       car       NaN        2.0
1   20.0       2     apple       2.0        2.0
0   22.0       1    banana       2.0        5.0
4   27.0       1  computer       5.0       73.0
3  100.0       1       toy      73.0      100.0
5  200.0       1      book     100.0        0.5
6  200.5       3     mouse       0.5        1.5
7  202.0       3      door       1.5        NaN

1. 合并 asc_diff 和 desc_diff 列以删除 NaN 并创建连续区域

df['asc_diff'] = df['asc_diff'].combine_first(df['desc_diff'])
df['asc_diff'] = df[['asc_diff', 'desc_diff']].min(axis=1).abs()
df['asc_diff'] = df['asc_diff'] <= 2.0
df = df.drop(columns=['desc_diff'])

    price  weight   product  asc_diff
2   18.0       2       car      True
1   20.0       2     apple      True
0   22.0       1    banana      True
4   27.0       1  computer     False
3  100.0       1       toy     False
5  200.0       1      book      True
6  200.5       3     mouse      True
7  202.0       3      door      True

4. 创建组

g = df.groupby((df['asc_diff'].shift() != df['asc_diff']).cumsum())
for k, v in g:
    print(f'[group {k}]')
    print(v)

[group 1]
   price  weight product  asc_diff
2   18.0       2     car      True
1   20.0       2   apple      True
0   22.0       1  banana      True
[group 2]
   price  weight   product  asc_diff
4   27.0       1  computer     False
3  100.0       1       toy     False
[group 3]
   price  weight product  asc_diff
5  200.0       1    book      True
6  200.5       3   mouse      True
7  202.0       3    door      True

到目前为止一切都很好，但是当我不得不汇总时，问题就来了：

def product_join(x):
    return ' '.join(x)
g.agg({'weight': 'max', 'product': product_join})

           weight           product
asc_diff                          
1              2  car apple banana
2              1      computer toy
3              3   book mouse door

问题：

• 只有第 1 组和第 3 组应该聚合（但在代码中它适用于所有组）
• 即使使用自定义函数（例如 product_join），我也无法访问其他列的值，因此我可以获取例如加权平均价格。

我想要完成的事情：

• 仅聚合第 1 组和第 3 组（asc_diff 为真）并保持第 2 组不变
• 在price 聚合函数中，我需要一个函数来访问两列（即price 和weight）以获得加权平均值

提前致谢！

Answer 1

这是基于@Panwen Wang 的解决方案，并坚持使用 Pandas：

通过 cumsum 和 diff 获取连续的行：

temp = (df
        .sort_values('price')
        .assign(group = lambda df: df.price.diff().gt(2).cumsum())
       )

temp

   price  weight   product  group
2   18.0       2       car      0
1   20.0       2     apple      0
0   22.0       1    banana      0
4   27.0       1  computer      1
3  100.0       1       toy      2
5  200.0       1      book      3
6  200.5       3     mouse      3
7  202.0       3      door      3

创建一个自定义函数来获取加权平均值（您也可以使用 np.average，我只是想避免使用 apply 函数）：

def weighted_mean(df, column_to_average, weights, by):
     df = df.copy()
     df = df.set_index(by)
     numerator = df[column_to_average].mul(df[weights]).sum(level=by)
     denominator = df[weights].sum(level=by)
     return numerator/denominator

计算结果：

(temp
 .assign(price = lambda df: df.group.map(weighted_mean))
 .groupby('group')
 .agg(price=('price','first'), 
      weight=('weight','max'), 
      product=('product', ' '.join))
 )
 
            price  weight           product
group                                      
0       19.600000       2  car apple banana
1       27.000000       1          computer
2      100.000000       1               toy
3      201.071429       3   book mouse door

Answer 2

如果我没说错，您只想聚合asc_diff 列中的所有值都是True 的组。其他组 (asc_diff == False) 不应更改。

如果是这种情况，从您目前所做的开始，解决方案很简单。您只需要创建一个自定义应用函数，它将根据您定义的条件为您完成工作。自定义的应用函数是这样的：

def custom_apply(df):
    if df['asc_diff'].all() == False:
        df = df.set_index('asc_diff')
        return df[['price', 'weight', 'product']]
    
    def wavg(x): return np.average(x, weights=df.loc[x.index, "weight"])

    df1 = df.groupby('asc_diff').agg({'price': wavg, 'weight': 'max'})
    df2 = df.groupby('asc_diff').agg({'product': ' '.join})
    return pd.concat([df1, df2], axis=1)

该功能的主要调整如下：

1. 您需要检查asc_diff 列的值。如果它们都是False，则只需返回包含所需列的数据框。
2. 使用自定义函数计算您的加权价格 (wavg)
3. 计算聚合并将它们连接起来。

然后，您只需在分组数据框中应用此函数，如下所示：

print(g.apply(custom_apply).droplevel(1))

结果将是：

               price  weight           product
asc_diff                                      
1          19.600000       2  car apple banana
2          27.000000       1          computer
2         100.000000       1               toy
3         201.071429       3   book mouse door

Answer 3

使用 datar 很容易做到，它由 pandas 支持，但在 R 中实现了 dplyr 语法：

创建组

>>> from datar.all import (
...     f, tribble, arrange, lag, if_else, is_na, 
...     group_by, mutate, summarise, select,
...     cur_group_id, cumsum, weighted_mean, max, paste
... )
[2021-06-25 13:35:20][datar][WARNING] Builtin name "max" has been overriden by datar.
>>> 
>>> df = tribble(
...     f.price, f.weight, f.product, 
...     22,      1,        'banana',
...     20,      2,        'apple',
...     18,      2,        'car',
...     100,     1,        'toy',
...     27,      1,        'computer',
...     200,     1,        'book',
...     200.5,   3,        'mouse',
...     202,     3,        'door', 
... )
>>> 
>>> df = df >> \
...     arrange(f.price) >> \
...     mutate(
...         price_diff=f.price - lag(f.price),
...         group_flag=f.price_diff > 2.0,
...         group=cumsum(f.group_flag)
...     ) >> \
...     group_by(f.group)
>>> df
      price  weight   product  price_diff  group_flag   group
  <float64> <int64>  <object>   <float64>      <bool> <int64>
0      18.0       2       car         NaN       False       0
1      20.0       2     apple         2.0       False       0
2      22.0       1    banana         2.0       False       0
3      27.0       1  computer         5.0        True       1
4     100.0       1       toy        73.0        True       2
5     200.0       1      book       100.0        True       3
6     200.5       3     mouse         0.5       False       3
7     202.0       3      door         1.5       False       3

[Groups: group (n=4)]

这个想法很像你所做的。我们首先按price 对df 进行排序，并创建了一个price_diff 列，其中包含当前价格与上一行价格之间的差异。 然后通过这种差异，我们可以判断何时应该分开行 (group_flag)。

请注意，这不是分组标志，它只是告诉我们是否应该将当前行放在单独的组中。如果您查看第 5 行，它应该与第 6/7 行分组，但True 这里告诉我们它应该与第 4 行分隔。第 6/7 行的 Falses 拒绝将它们与第 5 行分开。

然后通过cumsum他们，我们就可以轻松获取组id了。

进行聚合

>>> df >> \
...     # don't include the intermediate columns
...     select(~f.price_diff, ~f.group_flag) >> \
...     summarise(
...         price=weighted_mean(f.price, f.weight),
...         weight=max(f.weight),
...         product=paste(f.product, collapse=' ')
...     )
    group       price  weight           product
  <int64>   <float64> <int64>          <object>
0       0   19.600000       2  car apple banana
1       1   27.000000       1          computer
2       2  100.000000       1               toy
3       3  201.071429       3   book mouse door

免责声明：我是datar 包的作者。