Pandas自定义分组聚合函数时，能否在分组条件上加以限制？

Question

I have the following dataframe:

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    

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

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

3. 将 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 为true）并保持2组不变
• 在 price 聚合函数中需要一个函数来访问两个列（即 price 和 weight）以获取加权平均值

谢谢！

- Eduardo Gomes

---

如果你有20、22、24，它们应该被分组吗？因为20和24之间的差值是4。 - Panwen Wang

是的，它们应该被分组在一起，因为它们之间的差值为2（小于或等于阈值）。 - Eduardo Gomes

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

- sammywemmy

---

谢谢你的帮助！我会将你的解决方案的一些部分融入到我的逐步过程中，尤其是连续行的方法，它很优雅且减少了代码行数！ - Eduardo Gomes

Answer 2

使用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）排序数据框并创建一个 price_diff 列，其中包含当前价格和前一行价格之间的差异。 然后通过这个差异，我们可以确定哪些行应该分开（group_flag）。

请注意，它不是分组标志，而只是告诉我们是否应该将当前行放在单独的组中。如果您查看第5行，它应该与第6/7行分组，但是这里的 True 告诉我们它应该与第4行分开。第6/7行的 False 告诉我们不要将它们与第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包的作者。

- Panwen Wang

---

谢谢！我不知道这个包，看起来它和pandas一样有用。但我肯定需要花些时间来理解它的语法 :D - Eduardo Gomes

Answer 3

如果我理解正确，您想仅聚合所有asc_diff列中所有值都为True的组。其他组(asc_diff == False)不应更改。

如果是这样，从您已经完成的工作开始，解决方案很简单。您只需要创建一个自定义apply函数，根据您定义的条件来执行所需的操作。自定义apply函数应该像这样：

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

- Ricardo Erikson

---

谢谢提供其他丰富解决方案的建议，但我将选择这个方案，因为它只使用了pandas，并且更有教学意义。 - Eduardo Gomes