主页 / coding / 问题 / 78082450
Accepted
user23503493
Asked: 2024-02-29 23:10:08 +0800 CST

从 pandas 数据框中删除重复的子数据框

  • 772

例如，我有一个 pandas 数据框

df_dupl = pd.DataFrame({
    'EVENT_TIME': ['00:01', '00:01', '00:01', '00:03', '00:03', '00:03', '00:06', '00:06', '00:06', '00:08', '00:08', '00:10', '00:10', '00:11', '00:11', '00:13', '00:13', '00:13'],
    'UNIQUE_ID': [123, 123, 123, 125, 125, 125, 123, 123, 123, 127, 127, 123, 123, 123, 123, 123, 123, 123],
    'Value1': ['A', 'B', 'A', 'A', 'B', 'A', 'A', 'B', 'A', 'A', 'B', 'A', 'B', 'C', 'B', 'A', 'B', 'A'],
    'Value2': [0.3, 0.2, 0.2, 0.1, 1.3, 0.2, 0.3, 0.2, 0.2, 0.1, 1.3, 0.3, 0.2, 0.3, 0.2, 0.3, 0.2, 0.2]
})

我想删除与具有相同 UNIQUE_ID 的先前（按 EVENT_TIME）行具有相同值的行序列。对于该示例，结果应如下所示：

df = pd.DataFrame({
    'EVENT_TIME': ['00:01', '00:01', '00:01', '00:03', '00:03', '00:03', '00:08', '00:08', '00:10', '00:10', '00:11', '00:11', '00:13', '00:13', '00:13'],
    'UNIQUE_ID': [123, 123, 123, 125, 125, 125, 127, 127, 123, 123, 123, 123, 123, 123, 123],
    'Value1': ['A', 'B', 'A', 'A', 'B', 'A', 'A', 'B', 'A', 'B', 'C', 'B', 'A', 'B', 'A'],
    'Value2': [0.3, 0.2, 0.2, 0.1, 1.3, 0.2, 0.1, 1.3, 0.3, 0.2, 0.3, 0.2, 0.3, 0.2, 0.2]
}).

应删除时间为 00:06 的行，因为前一个具有 UNIQUE_ID 123（时间 00:01）的子数据帧是相同的。另一方面，时间为 00:13 的行应该保留 - 它们也与时间为 00:01 的行相同，但中间还有其他 UNIQUE_ID 123 的行。关键是我想比较整个子数据帧，而不是单行。

我可以通过使用以下函数达到预期的结果，但速度很慢。

def del_dupl_gr(df):
    out = []
    for x in df['UNIQUE_ID'].unique():
        prev_df = pd.DataFrame()
        for y in df[df['UNIQUE_ID'] == x]['EVENT_TIME'].unique():
            test_df = df[(df['UNIQUE_ID'] == x) & (df['EVENT_TIME'] == y)]
            if not test_df.iloc[:, 2:].reset_index(drop=True).equals(prev_df.iloc[:, 2:].reset_index(drop=True)):
                out.append(test_df)
                prev_df = test_df
    return pd.concat(out).sort_index().reset_index(drop=True)

真实的数据帧非常大（超过百万行），并且这种循环需要很多时间。我确信必须有适当的（或至少更快）的方法来做到这一点。

结果

感谢您提交的所有答案。我比较了他们的速度。在某些情况下，我稍微编辑了方法以产生完全相同的结果。因此，在所有 sort_values 方法中，我添加了 kind='stable' 以确保保留顺序，最后我添加了 .reset_index(drop=True)。

方法 1000 行 10 000 行 100 000 行
原来的 556 毫秒 5.41秒 未测试
莫兹韦 1.24秒 10.1秒 未测试
安德烈·凯斯利 696 毫秒 4.56秒 未测试
光黄 11.3 毫秒 34.1 毫秒 318 毫秒
python

3 个回答

  1. Best Answer

    另一种方法是通过枚举移动行，然后进行比较：

    # the value columns
value_cols = df.columns[2:]

# groups are identified as `EVENT_TIME` and `UNIQUE_ID`
groupby = df_dupl.groupby(['EVENT_TIME','UNIQUE_ID'])['Value1']

# these are the groups
groups = groupby.ngroup()

# enumeration within the groups
enums = groupby.cumcount()

# sizes of the groups - populated across the rows
sizes = groupby.transform('size')

dup = (df_dupl.groupby(['UNIQUE_ID',enums])[value_cols].shift(). # shift by enumeration within `UNIQUE_ID`
     .eq(df_dupl[value_cols]).all(axis=1)                        # equal the current rows
     .groupby(groups).transform('all')                           # identical across the groups
 &
 sizes.groupby([df_dupl['UNIQUE_ID'],enums]).diff().eq(0).       # and the group size are equal too
)

# output
df_dupl.loc[~dup]

    输出：

       EVENT_TIME  UNIQUE_ID Value1  Value2
0       00:01        123      A     0.3
1       00:01        123      B     0.2
2       00:01        123      A     0.2
3       00:03        125      A     0.1
4       00:03        125      B     1.3
5       00:03        125      A     0.2
9       00:08        127      A     0.1
10      00:08        127      B     1.3
11      00:10        123      A     0.3
12      00:10        123      B     0.2
13      00:11        123      C     0.3
14      00:11        123      B     0.2
15      00:13        123      A     0.3
16      00:13        123      B     0.2
17      00:13        123      A     0.2
    • 3

  2. 您可以形成组并散列子数据帧，然后groupby.shift与前一个块进行比较：

    def hash_df(g):
    return hash(tuple(pd.util.hash_pandas_object(g, index=False)))

groups = ['UNIQUE_ID', 'EVENT_TIME']
tmp = (df_dupl.sort_values(by=list(df_dupl))
       .set_index(groups)
       .groupby(groups, sort=False).agg(hash_df)
      )

keep = tmp.ne(tmp.groupby('UNIQUE_ID').shift()).any(axis=1)

out = df_dupl[df_dupl.merge(keep.reset_index(name='flag'))['flag']]

    输出：

       EVENT_TIME  UNIQUE_ID Value1  Value2
0       00:01        123      A     0.3
1       00:01        123      B     0.2
2       00:01        123      A     0.2
3       00:03        125      A     0.1
4       00:03        125      B     1.3
5       00:03        125      A     0.2
9       00:08        127      A     0.1
10      00:08        127      B     1.3
11      00:10        123      A     0.3
12      00:10        123      B     0.2
13      00:11        123      C     0.3
14      00:11        123      B     0.2
15      00:13        123      A     0.3
16      00:13        123      B     0.2
17      00:13        123      A     0.2

    中间体：

    #tmp
                                   Value1               Value2
UNIQUE_ID EVENT_TIME                                          
123       00:01      -2647391080000972640 -2479202283702687367
125       00:03      -2647391080000972640  1479523423813153529
123       00:06      -2647391080000972640 -2479202283702687367
127       00:08      -1564261656412067059 -4515207542275771698
123       00:10      -1564261656412067059 -2126568776299078705
          00:11       2187186574447344670 -5299110227501839425
          00:13      -2647391080000972640 -2479202283702687367
# flag
   EVENT_TIME  UNIQUE_ID Value1  Value2   flag
0       00:01        123      A     0.3   True
1       00:01        123      B     0.2   True
2       00:01        123      A     0.2   True
3       00:03        125      A     0.1   True
4       00:03        125      B     1.3   True
5       00:03        125      A     0.2   True
6       00:06        123      A     0.3  False
7       00:06        123      B     0.2  False
8       00:06        123      A     0.2  False
9       00:08        127      A     0.1   True
10      00:08        127      B     1.3   True
11      00:10        123      A     0.3   True
12      00:10        123      B     0.2   True
13      00:11        123      C     0.3   True
14      00:11        123      B     0.2   True
15      00:13        123      A     0.3   True
16      00:13        123      B     0.2   True
17      00:13        123      A     0.2   True
    • 1

  3. 另一种方法：

    def fn(g):
    groups = g.groupby("EVENT_TIME").agg(tuple)
    mask = (groups == groups.shift()).all(axis=1)
    return g[g["EVENT_TIME"].isin(groups.index[~mask])]


out = (
    df_dupl.groupby("UNIQUE_ID")
    .apply(fn, include_groups=False)
    .droplevel(1)
    .reset_index()
    .sort_values(by="EVENT_TIME")
)

print(out)

    印刷：

        UNIQUE_ID EVENT_TIME Value1  Value2
0         123      00:01      A     0.3
1         123      00:01      B     0.2
2         123      00:01      A     0.2
10        125      00:03      A     0.1
11        125      00:03      B     1.3
12        125      00:03      A     0.2
13        127      00:08      A     0.1
14        127      00:08      B     1.3
3         123      00:10      A     0.3
4         123      00:10      B     0.2
5         123      00:11      C     0.3
6         123      00:11      B     0.2
7         123      00:13      A     0.3
8         123      00:13      B     0.2
9         123      00:13      A     0.2
    • 1

相关问题