在数据帧中查找重复项并仅保留最高的重复项

使用 + 屏蔽每个组的最小值。然后使用蒙版仅选择所需的行。groupbytransform

# map each consecutive group of rows to a different integer
group_labels = (df.group != df.group.shift()).cumsum()

# find the minimum value of each group 
group_min_val = df.groupby(group_labels)['value'].transform('min')

# get only the rows of each group whose value is higher than the minimum 
res = df[df.value != group_min_val]

>>> res

   index  group  value
0      1      1    402
3      4      2    416
4      5      2    407

中间结果

>>> group_labels

0    1
1    1
2    2
3    2
4    2
5    2
6    3
7    4
Name: group, dtype: int64

>>> group_min_val

0    396
1    396
2    406
3    406
4    406
5    406
6    200
7    350
Name: value, dtype: int64

>>> df.value != group_min_val

0     True
1    False
2    False
3     True
4     True
5    False
6    False
7    False
Name: value, dtype: bool

@HarryPlotter 的回答的单行版本：

df.loc[df.value.ne(df.groupby(df.group.ne(df.group.shift()).cumsum()).value.transform('min'))]

使用这里的技巧来应用OP对“分组”的理解，并进行转换以获得每个组中的最小值，然后对所有不等于这些值的值进行-ing。.loc

警告：这会删除任何单例“组”！（如果 OP 的注释表明“保持除最低值之外的所有值”，则丢弃了从技术上讲也是其组中“最高”的单例值。

使用 rank（） 可以更容易地做到这一点。
在这种情况下，您需要决定如何处理相同的最小值 - 删除其中一个 （） 或两个 （）。根据解决方案集中的条件“删除最低的”：method = 'first'method = 'min'method = 'first'

df = pd.DataFrame({'index': [1, 2, 3, 4, 5, 6, 7], 'group': [1, 1, 2, 2, 2, 1, 2],
                   'value': [402, 396, 406, 416, 407, 200, 350]}).set_index('index')
print('Source df:\n', df)
df = df[df.groupby(df.group.diff().ne(0).cumsum())['value'].rank(method='first').gt(1)]
print('\nResult df:\n', df)

输出：

Source df:
        group  value
index              
1          1    402
2          1    396
3          2    406
4          2    416
5          2    407
6          1    200
7          2    350

Result df:
        group  value
index              
1          1    402
4          2    416
5          2    407