i panda ottengono righe che NON si trovano in altri frame di dati

Ho due frame di dati Panda che hanno alcune righe in comune.

Supponiamo che dataframe2 sia un sottoinsieme di dataframe1.

Come posso ottenere le righe di dataframe1 che non sono in dataframe2?

df1 = pandas.DataFrame(data = {'col1' : [1, 2, 3, 4, 5], 'col2' : [10, 11, 12, 13, 14]}) 
df2 = pandas.DataFrame(data = {'col1' : [1, 2, 3], 'col2' : [10, 11, 12]})

Un metodo sarebbe quello di memorizzare il risultato di una unione interna da entrambi i dfs, quindi possiamo semplicemente selezionare le righe quando i valori di una colonna non sono in questo comune:

In [119]:

common = df1.merge(df2,on=['col1','col2'])
print(common)
df1[(~df1.col1.isin(common.col1))&(~df1.col2.isin(common.col2))]
   col1  col2
0     1    10
1     2    11
2     3    12
Out[119]:
   col1  col2
3     4    13
4     5    14

MODIFICARE

Un altro metodo che hai trovato è quello di isinprodurre NaNrighe che puoi rilasciare:

In [138]:

df1[~df1.isin(df2)].dropna()
Out[138]:
   col1  col2
3     4    13
4     5    14

Tuttavia, se df2 non avvia le righe nello stesso modo, questo non funzionerà:

df2 = pd.DataFrame(data = {'col1' : [2, 3,4], 'col2' : [11, 12,13]})

produrrà l'intero df:

In [140]:

df1[~df1.isin(df2)].dropna()
Out[140]:
   col1  col2
0     1    10
1     2    11
2     3    12
3     4    13
4     5    14

La soluzione attualmente selezionata produce risultati errati. Per risolvere correttamente questo problema, possiamo eseguire un join sinistro da df1a df2, assicurandoci innanzitutto di ottenere solo le righe univoche df2.

Innanzitutto, è necessario modificare il DataFrame originale per aggiungere la riga con i dati [3, 10].

df1 = pd.DataFrame(data = {'col1' : [1, 2, 3, 4, 5, 3], 
                           'col2' : [10, 11, 12, 13, 14, 10]}) 
df2 = pd.DataFrame(data = {'col1' : [1, 2, 3],
                           'col2' : [10, 11, 12]})

df1

   col1  col2
0     1    10
1     2    11
2     3    12
3     4    13
4     5    14
5     3    10

df2

   col1  col2
0     1    10
1     2    11
2     3    12

Eseguire un join sinistro, eliminando i duplicati in df2modo che ogni riga di df1join con esattamente 1 riga di df2. Utilizzare il parametro indicatorper restituire una colonna aggiuntiva che indica da quale tabella proveniva la riga.

df_all = df1.merge(df2.drop_duplicates(), on=['col1','col2'], 
                   how='left', indicator=True)
df_all

   col1  col2     _merge
0     1    10       both
1     2    11       both
2     3    12       both
3     4    13  left_only
4     5    14  left_only
5     3    10  left_only

Crea una condizione booleana:

df_all['_merge'] == 'left_only'

0    False
1    False
2    False
3     True
4     True
5     True
Name: _merge, dtype: bool

Perché altre soluzioni sono sbagliate

Alcune soluzioni commettono lo stesso errore: controllano solo che ciascun valore sia indipendente in ciascuna colonna, non insieme nella stessa riga. L'aggiunta dell'ultima riga, che è unica ma ha i valori di entrambe le colonne df2espone l'errore:

common = df1.merge(df2,on=['col1','col2'])
(~df1.col1.isin(common.col1))&(~df1.col2.isin(common.col2))
0    False
1    False
2    False
3     True
4     True
5    False
dtype: bool

Questa soluzione ottiene lo stesso risultato errato:

df1.isin(df2.to_dict('l')).all(1)

Supponendo che gli indici siano coerenti nei frame di dati (non tenendo conto dei valori di col effettivi):

df1[~df1.index.isin(df2.index)]

Come già accennato, isin richiede che colonne e indici siano gli stessi per una partita. Se la corrispondenza deve essere solo sui contenuti delle righe, un modo per ottenere la maschera per filtrare le righe presenti è convertire le righe in un (Multi) Index:

In [77]: df1 = pandas.DataFrame(data = {'col1' : [1, 2, 3, 4, 5, 3], 'col2' : [10, 11, 12, 13, 14, 10]})
In [78]: df2 = pandas.DataFrame(data = {'col1' : [1, 3, 4], 'col2' : [10, 12, 13]})
In [79]: df1.loc[~df1.set_index(list(df1.columns)).index.isin(df2.set_index(list(df2.columns)).index)]
Out[79]:
   col1  col2
1     2    11
4     5    14
5     3    10

Se si deve tenere conto dell'indice, set_index ha l'argomento della parola chiave append per aggiungere colonne all'indice esistente. Se le colonne non si allineano, l'elenco (df.columns) può essere sostituito con le specifiche delle colonne per allineare i dati.

pandas.MultiIndex.from_tuples(df<N>.to_records(index = False).tolist())

in alternativa potrebbe essere usato per creare gli indici, anche se dubito che sia più efficiente.

Supponiamo di avere due frame di dati, df_1 e df_2 con più campi (column_names) e si desidera trovare le sole voci in df_1 che non si trovano in df_2 sulla base di alcuni campi (ad es. Fields_x, fields_y), attenersi alla seguente procedura.

Passaggio 1: aggiungere una colonna key1 e key2 rispettivamente a df_1 e df_2.

Passaggio 2: riunire i frame di dati come mostrato di seguito. field_x e field_y sono le nostre colonne desiderate.

Passaggio 3: selezionare solo quelle righe da df_1 in cui chiave1 non è uguale a chiave2.

Passaggio 4: rilasciare il tasto 1 e il tasto 2.

Questo metodo risolverà il tuo problema e funziona velocemente anche con set di big data. L'ho provato per i frame di dati con oltre 1.000.000 di righe.

df_1['key1'] = 1
df_2['key2'] = 1
df_1 = pd.merge(df_1, df_2, on=['field_x', 'field_y'], how = 'left')
df_1 = df_1[~(df_1.key2 == df_1.key1)]
df_1 = df_1.drop(['key1','key2'], axis=1)

un po 'in ritardo, ma potrebbe valere la pena di controllare il parametro "indicatore" di pd.merge.

Vedi questa altra domanda per un esempio: confronta PandaS DataFrames e restituisci le righe mancanti dal primo

puoi farlo usando il metodo isin (dict) :

In [74]: df1[~df1.isin(df2.to_dict('l')).all(1)]
Out[74]:
   col1  col2
3     4    13
4     5    14

Spiegazione:

In [75]: df2.to_dict('l')
Out[75]: {'col1': [1, 2, 3], 'col2': [10, 11, 12]}

In [76]: df1.isin(df2.to_dict('l'))
Out[76]:
    col1   col2
0   True   True
1   True   True
2   True   True
3  False  False
4  False  False

In [77]: df1.isin(df2.to_dict('l')).all(1)
Out[77]:
0     True
1     True
2     True
3    False
4    False
dtype: bool

È inoltre possibile concat df1, df2:

x = pd.concat([df1, df2])

e quindi rimuovere tutti i duplicati:

y = x.drop_duplicates(keep=False, inplace=False)

Cosa ne pensi di questo:

df1 = pandas.DataFrame(data = {'col1' : [1, 2, 3, 4, 5], 
                               'col2' : [10, 11, 12, 13, 14]}) 
df2 = pandas.DataFrame(data = {'col1' : [1, 2, 3], 
                               'col2' : [10, 11, 12]})
records_df2 = set([tuple(row) for row in df2.values])
in_df2_mask = np.array([tuple(row) in records_df2 for row in df1.values])
result = df1[~in_df2_mask]

Ecco un altro modo di risolvere questo:

df1[~df1.index.isin(df1.merge(df2, how='inner', on=['col1', 'col2']).index)]

O:

df1.loc[df1.index.difference(df1.merge(df2, how='inner', on=['col1', 'col2']).index)]

Il mio modo di fare questo consiste nell'aggiungere una nuova colonna unica per un frame di dati e usarla per scegliere se mantenere una voce

df2[col3] = 1
df1 = pd.merge(df_1, df_2, on=['field_x', 'field_y'], how = 'outer')
df1['Empt'].fillna(0, inplace=True)

Questo lo rende così ogni voce in df1 ha un codice - 0 se è univoco per df1, 1 se si trova in entrambi i frame di dati. Quindi lo usi per limitarti a ciò che desideri

answer = nonuni[nonuni['Empt'] == 0]

df = df.merge(same.drop_duplicates(), on=['col1','col2'], 
               how='left', indicator=True)

df[df['_merge'] == 'left_only'].to_csv('output.csv')