Início / coding / Perguntas / 78082450
Accepted
user23503493
Asked: 2024-02-29 23:10:08 +0800 CST

Removendo sub-dataframes duplicados de um dataframe do pandas

  • 772

Eu tenho um dataframe do pandas, por exemplo

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]
})

Quero remover as sequências de linhas que possuem os mesmos valores das linhas anteriores (por EVENT_TIME) com o mesmo UNIQUE_ID. Para o exemplo o resultado deve ficar assim:

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]
}).

As linhas com horário 00:06 devem ser removidas, pois o subdataframe anterior com UNIQUE_ID 123 (horário 00:01) é idêntico. Por outro lado, as linhas com horário 00:13 devem permanecer - elas também são idênticas às linhas com horário 00:01, mas existem outras linhas com UNIQUE_ID 123 entre elas. A principal coisa é que quero comparar todos os sub-dataframes, não linhas únicas.

Posso alcançar o resultado desejado usando a seguinte função, mas é bastante lenta.

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)

O dataframe real é bastante grande (mais de um milhão de linhas) e esse loop leva muito tempo. Tenho certeza de que deve haver uma maneira adequada (ou pelo menos mais rápida) de fazer isso.

Resultados

Obrigado por todas as respostas enviadas. Eu comparei a velocidade deles. Em alguns casos, editei ligeiramente os métodos para produzir exatamente os mesmos resultados. Portanto, em todos os métodos sort_values ​​adicionei kind='stable' para garantir que a ordem seja preservada e no final adicionei .reset_index(drop=True).

Método 1000 linhas 10.000 linhas 100.000 linhas
original 556ms 5,41s Não testado
mozway 1,24s 10,1s Não testado
Andrej Kesely 696ms 4,56s Não testado
Quang Hoang 11,3ms 34,1ms 318ms
python

3 respostas

  1. Best Answer

    Outra abordagem é deslocar as linhas por enumeração e depois comparar:

    # 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]

    Saída:

       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. Você pode formar grupos e fazer hash dos subdataframes e depois groupby.shiftcomparar com o bloco anterior:

    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']]

    Saída:

       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

    Intermediários:

    #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. Outro método:

    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)

    Impressões:

        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

relate perguntas