Pandy otrzymują wiersze, które NIE znajdują się w innych ramkach danych

Mam dwie ramki danych pand, które mają wspólne wiersze.

Załóżmy, że ramka danych2 jest podzbiorem ramki danych1.

Jak mogę uzyskać wiersze ramki danych 1, których nie ma w ramce danych 2?

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

Jedną z metod byłoby przechowywanie wyniku scalenia wewnętrznego z obu plików dfs, a następnie możemy po prostu wybrać wiersze, gdy wartości jednej kolumny nie są wspólne:

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

EDYTOWAĆ

Inną metodą, którą znalazłeś, jest użycie, isinktóre utworzy NaNwiersze, które możesz upuścić:

In [138]:

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

Jednak jeśli df2 nie uruchamia wierszy w ten sam sposób, to nie zadziała:

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

wyprodukuje cały 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

Aktualnie wybrane rozwiązanie daje nieprawidłowe wyniki. Aby poprawnie rozwiązać ten problem, możemy wykonać lewe połączenie od df1do df2, upewniając się, że najpierw otrzymamy tylko unikalne wiersze df2.

Najpierw musimy zmodyfikować oryginalny DataFrame, aby dodać wiersz z danymi [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

Wykonaj lewe łączenie, eliminując duplikaty df2, aby każdy rząd df1złączeń miał dokładnie 1 wiersz df2. Użyj tego parametru, indicatoraby zwrócić dodatkową kolumnę wskazującą, z której tabeli pochodzi wiersz.

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

Utwórz warunek logiczny:

df_all['_merge'] == 'left_only'

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

Dlaczego inne rozwiązania są złe

Kilka rozwiązań popełnia ten sam błąd - sprawdzają tylko, czy każda wartość jest niezależnie w każdej kolumnie, a nie razem w tym samym wierszu. Dodanie ostatniego wiersza, który jest unikalny, ale zawiera wartości z obu kolumn, df2ujawnia błąd:

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

To rozwiązanie otrzymuje ten sam zły wynik:

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

Zakładając, że indeksy są spójne w ramkach danych (nie biorąc pod uwagę rzeczywistych wartości col):

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

Jak już wspomniano, isin wymaga, aby kolumny i indeksy były takie same dla dopasowania. Jeśli dopasowanie powinno dotyczyć tylko zawartości wierszy, jednym ze sposobów uzyskania maski do filtrowania obecnych wierszy jest przekonwertowanie wierszy na (Multi) Indeks:

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

Jeśli indeks ma być brany pod uwagę, set_index ma argument słowa kluczowego, który dołącza kolumny do istniejącego indeksu. Jeśli kolumny nie są wyrównane, listę (df.columns) można zastąpić specyfikacjami kolumn, aby wyrównać dane.

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

można alternatywnie wykorzystać do stworzenia indeksów, choć wątpię, aby było to bardziej wydajne.

Załóżmy, że masz dwie ramki danych: df_1 i df_2 z wieloma polami (nazwy kolumn) i chcesz znaleźć tylko te wpisy w df_1, których nie ma w df_2 na podstawie niektórych pól (np. Field_x, fields_y), wykonaj następujące kroki.

Krok 1. Dodaj kolumnę klucz1 i klucz2 odpowiednio do df_1 i df_2.

Krok 2. Połącz ramki danych, jak pokazano poniżej. field_x i field_y są naszymi pożądanymi kolumnami.

Krok 3. Wybierz tylko te wiersze z df_1, w których klucz1 nie jest równy kluczowi2.

Step4.Drop key1 i key2.

Ta metoda rozwiąże Twój problem i działa szybko nawet w przypadku dużych zbiorów danych. Wypróbowałem to dla ramek danych z ponad 1 000 000 wierszy.

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)

nieco później, ale warto sprawdzić parametr „wskaźnik” pd.merge.

Zobacz inne pytanie na przykład: Porównaj ramki danych PandaS i zwróć wiersze, których brakuje w pierwszym

możesz to zrobić za pomocą metody isin (dict) :

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

Wyjaśnienie:

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

Można również Concat df1, df2:

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

a następnie usuń wszystkie duplikaty:

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

Co powiesz na to:

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]

Oto inny sposób rozwiązania tego:

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

Lub:

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

Mój sposób na zrobienie tego polega na dodaniu nowej kolumny, która jest unikalna dla jednej ramki danych i za pomocą tej opcji mogę wybrać, czy zachować wpis

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

To sprawia, że ​​każdy wpis w df1 ma kod - 0, jeśli jest unikalny dla df1, 1, jeśli jest w obu ramkach danych. Następnie użyj tego, aby ograniczyć się do tego, co chcesz

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