Python:Pandas-按组删除第一行

我有如下大数据帧（

df

），看起来像这样：

    ID     date        PRICE       
1   10001  19920103  14.500    
2   10001  19920106  14.500    
3   10001  19920107  14.500     
4   10002  19920108  15.125     
5   10002  19920109  14.500   
6   10002  19920110  14.500    
7   10003  19920113  14.500 
8   10003  19920114  14.500     
9   10003  19920115  15.000 

问题：删除（或删除）每个ID的第一行最有效的方法是什么？我想要这个：

        ID     date     PRICE       
    2   10001  19920106  14.500    
    3   10001  19920107  14.500     
    5   10002  19920109  14.500   
    6   10002  19920110  14.500    
    8   10003  19920114  14.500     
    9   10003  19920115  15.000 

---

我可以在每个唯一的

ID

上循环并删除第一行，但我认为这不是很有效。

您可以使用

groupby/transform

来准备一个布尔掩码，该掩码对于您想要的行为True，对于您不想要的行为False。一旦有了这样一个布尔掩码，就可以使用

df.loc[mask]

选择子数据帧：

import numpy as np
import pandas as pd

df = pd.DataFrame(
    {'ID': [10001, 10001, 10001, 10002, 10002, 10002, 10003, 10003, 10003],
     'PRICE': [14.5, 14.5, 14.5, 15.125, 14.5, 14.5, 14.5, 14.5, 15.0],
     'date': [19920103, 19920106, 19920107, 19920108, 19920109, 19920110,
              19920113, 19920114, 19920115]},
    index = range(1,10)) 

def mask_first(x):
    result = np.ones_like(x)
    result[0] = 0
    return result

mask = df.groupby(['ID'])['ID'].transform(mask_first).astype(bool)
print(df.loc[mask])

屈服

      ID  PRICE      date
2  10001   14.5  19920106
3  10001   14.5  19920107
5  10002   14.5  19920109
6  10002   14.5  19920110
8  10003   14.5  19920114
9  10003   15.0  19920115

---

由于您对效率感兴趣，这里有一个基准：

import timeit
import operator
import numpy as np
import pandas as pd

N = 10000
df = pd.DataFrame(
    {'ID': np.random.randint(100, size=(N,)),
     'PRICE': np.random.random(N),
     'date': np.random.random(N)}) 

def using_mask(df):
    def mask_first(x):
        result = np.ones_like(x)
        result[0] = 0
        return result

    mask = df.groupby(['ID'])['ID'].transform(mask_first).astype(bool)
    return df.loc[mask]

def using_apply(df):
    return df.groupby('ID').apply(lambda group: group.iloc[1:, 1:])

def using_apply_alt(df):
    return df.groupby('ID', group_keys=False).apply(lambda x: x[1:])

timing = dict()
for func in (using_mask, using_apply, using_apply_alt):
    timing[func] = timeit.timeit(
        '{}(df)'.format(func.__name__), 
        'from __main__ import df, {}'.format(func.__name__), number=100)

for func, t in sorted(timing.items(), key=operator.itemgetter(1)):
    print('{:16}: {:.2f}'.format(func.__name__, t))

报告

using_mask      : 0.85
using_apply_alt : 2.04
using_apply     : 3.70

---

另一个单行代码是

df.groupby（'ID'）.apply（lambda-group:group.iloc[1:，1:]）

---

旧的但仍然经常观看：一个更快的解决方案是N（0）与删除重复项相结合：

def using_nth(df):
    to_del = df.groupby('ID',as_index=False).nth(0)
    return pd.concat([df,to_del]).drop_duplicates(keep=False)

在我的系统中，unutbus设置的时间为：

using_nth       : 0.43
using_apply_alt : 1.93
using_mask      : 2.11
using_apply     : 4.33

---

比第一个答案简单一千倍！我感谢您为什么我们需要两个

1:

在

[1:，1:

中？第二个1:是不必要的。它意味着从第二列开始（因为第一列是0）直到结束。您只需执行group.iloc[1:]。

using_nth       : 0.43
using_apply_alt : 1.93
using_mask      : 2.11
using_apply     : 4.33