Pandas erhalten Zeilen, die sich NICHT in einem anderen Datenrahmen befinden

Ich habe zwei Pandas-Datenrahmen, die einige Zeilen gemeinsam haben.

Angenommen, Datenrahmen2 ist eine Teilmenge von Datenrahmen1.

Wie kann ich die Zeilen von Datenrahmen1 abrufen, die sich nicht in Datenrahmen2 befinden?

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

Eine Methode wäre, das Ergebnis einer inneren Zusammenführung aus beiden dfs zu speichern. Dann können wir einfach die Zeilen auswählen, wenn die Werte einer Spalte nicht so häufig sind:

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

BEARBEITEN

Eine andere Methode, die Sie gefunden haben, besteht darin isin, NaNZeilen zu erstellen, die Sie löschen können:

In [138]:

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

Wenn df2 Zeilen jedoch nicht auf die gleiche Weise startet, funktioniert dies nicht:

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

wird das gesamte df produzieren:

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

Die aktuell ausgewählte Lösung führt zu falschen Ergebnissen. Um dieses Problem richtig zu lösen, können wir eine Linksverknüpfung von df1bis durchführen df2und sicherstellen, dass zuerst nur die eindeutigen Zeilen für abgerufen werden df2.

Zuerst müssen wir den ursprünglichen DataFrame ändern, um die Zeile mit Daten hinzuzufügen [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

Führen Sie eine Linksverknüpfung durch, wobei Sie Duplikate entfernen, df2sodass jede Verknüpfungsreihe df1genau 1 Zeile enthält df2. Verwenden Sie den Parameter indicator, um eine zusätzliche Spalte zurückzugeben, die angibt, aus welcher Tabelle die Zeile stammt.

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

Erstellen Sie eine boolesche Bedingung:

df_all['_merge'] == 'left_only'

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

Warum andere Lösungen falsch sind

Einige Lösungen machen den gleichen Fehler - sie prüfen nur, ob jeder Wert in jeder Spalte unabhängig ist und nicht zusammen in derselben Zeile. Das Hinzufügen der letzten Zeile, die eindeutig ist, aber die Werte aus beiden Spalten enthält, df2macht den Fehler sichtbar:

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

Diese Lösung führt zum gleichen falschen Ergebnis:

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

Angenommen, die Indizes sind in den Datenrahmen konsistent (ohne Berücksichtigung der tatsächlichen Spaltenwerte):

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

Wie bereits angedeutet, erfordert isin, dass Spalten und Indizes für eine Übereinstimmung identisch sind. Wenn die Übereinstimmung nur für den Zeileninhalt gelten soll, besteht eine Möglichkeit, die Maske zum Filtern der vorhandenen Zeilen zu erhalten, darin, die Zeilen in einen (Mehrfach-) Index zu konvertieren:

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

Wenn der Index berücksichtigt werden soll, wird bei set_index das Schlüsselwortargument angehängt, um Spalten an den vorhandenen Index anzuhängen. Wenn die Spalten nicht ausgerichtet sind, kann die Liste (df.columns) durch Spaltenspezifikationen ersetzt werden, um die Daten auszurichten.

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

könnte alternativ verwendet werden, um die Indizes zu erstellen, obwohl ich bezweifle, dass dies effizienter ist.

Angenommen, Sie haben zwei Datenrahmen, df_1 und df_2 mit mehreren Feldern (Spaltennamen), und Sie möchten anhand einiger Felder (z. B. Felder_x, Felder_y) die einzigen Einträge in df_1 finden, die nicht in df_2 enthalten sind. Führen Sie die folgenden Schritte aus.

Schritt 1. Fügen Sie df_1 bzw. df_2 eine Spalte key1 und key2 hinzu.

Schritt 2. Führen Sie die Datenrahmen wie unten gezeigt zusammen. field_x und field_y sind unsere gewünschten Spalten.

Schritt 3.Wählen Sie nur die Zeilen aus df_1 aus, in denen Schlüssel1 nicht gleich Schlüssel2 ist.

Step4.Drop key1 und key2.

Diese Methode löst Ihr Problem und funktioniert auch bei großen Datenmengen schnell. Ich habe es für Datenrahmen mit mehr als 1.000.000 Zeilen versucht.

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)

etwas spät, aber es könnte sich lohnen, den "Indikator" -Parameter von pd.merge zu überprüfen.

In dieser anderen Frage finden Sie ein Beispiel: Vergleichen Sie PandaS DataFrames und geben Sie Zeilen zurück, die in der ersten fehlen

Sie können dies mit der isin (dict) -Methode tun :

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

Erläuterung:

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

Sie können auch verketten df1, df2:

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

und entfernen Sie dann alle Duplikate:

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

Wie wäre es damit:

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]

Hier ist eine andere Möglichkeit, dies zu lösen:

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

Oder:

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

Um dies zu tun, füge ich eine neue Spalte hinzu, die für einen Datenrahmen eindeutig ist, und wähle anhand dieser Spalte aus, ob ein Eintrag beibehalten werden soll

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

Dadurch hat jeder Eintrag in df1 einen Code - 0, wenn er für df1 eindeutig ist, 1, wenn er in beiden dataFrames enthalten ist. Sie verwenden dies dann, um sich auf das zu beschränken, was Sie möchten

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