панди отримують рядки, які НЕ є в інших даних

У мене є два кадри даних панд, які мають деякі спільні рядки.

Припустимо, dataframe2 - це підмножина dataframe1.

Як я можу отримати рядки dataframe1, які відсутні в 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]})

Одним із методів було б збереження результату внутрішньої форми злиття обох dfs, тоді ми можемо просто вибрати рядки, коли значення одного стовпця не є цим загальним:

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

EDIT

Інший метод , як ви знайшли це використання , isinяке буде виробляти NaNрядки , які ви можете впасти:

In [138]:

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

Однак якщо df2 не починає рядки таким же чином, це не працюватиме:

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

буде виробляти весь 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

Наразі вибране рішення дає невірні результати. Щоб правильно вирішити цю проблему, ми можемо виконати ліве з'єднання від df1до df2, переконавшись, що спочатку отримаємо лише унікальні рядки df2.

Спочатку нам потрібно змінити оригінальний DataFrame, щоб додати рядок з даними [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

Виконайте з’єднання ліворуч, усуваючи дублікати df2так, щоб кожен ряд поєднувався df1з рівно 1 рядком df2. Використовуйте параметр, indicatorщоб повернути додатковий стовпець із зазначенням, з якої таблиці був рядок.

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

Створіть булеву умову:

df_all['_merge'] == 'left_only'

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

Чому інші рішення неправильні

Кілька рішень роблять ту саму помилку - вони лише перевіряють, що кожне значення знаходиться незалежно у кожному стовпчику, а не разом у одному рядку. Додаючи останній рядок, який є унікальним, але має значення обох стовпців з df2викриває помилку:

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

Це рішення отримує той самий неправильний результат:

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

Якщо припустити, що індекси відповідають рамкам даних (не беручи до уваги фактичні значення col):

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

Як уже натякали, для isin потрібні стовпці та індекси однакові для відповідності. Якщо збіг повинен міститись лише для вмісту рядків, один із способів отримати маску для фільтрації наявних рядків - перетворити рядки в індекс (Multi):

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

Якщо індекс слід враховувати, у set_index аргумент ключового слова додає стовпці до існуючого індексу. Якщо стовпці не вирівнюються, список (df.колонки) можна замінити специфікаціями стовпців для вирівнювання даних.

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

Можна альтернативно використовувати для створення індексів, хоча я сумніваюся, що це більш ефективно.

Припустимо, у вас є два фрейми даних, df_1 та df_2, що мають кілька полів (імена стовпців), і ви хочете знайти лише ті записи в df_1, які не є в df_2 на основі деяких полів (наприклад, polja_x, поля_y), виконайте наступні кроки.

Крок 1.Додайте ключ стовпця1 та ключ2 до df_1 та df_2 відповідно.

Крок2.Змініть рамки даних, як показано нижче. field_x і field_y - наші бажані стовпці.

Виберіть лише ті рядки з df_1, де key1 не дорівнює key2.

Крок4.Запустіть клавіші1 та клавішу2.

Цей метод вирішить вашу проблему і працює швидко навіть при великих наборах даних. Я спробував це для фреймів даних з більш ніж 1 000 000 рядків.

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)

трохи пізно, але, можливо, варто перевірити параметр "індикатор" pd.merge.

Дивіться цей приклад для прикладу: Порівняйте параметри DataFrames PandaS та повернення рядків, відсутніх у першому

ви можете зробити це за допомогою методу isin (dict) :

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

Пояснення:

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

Ви також можете Concat df1, df2:

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

а потім видаліть усі дублікати:

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

Як щодо цього:

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]

Ось ще один спосіб вирішення цього питання:

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

Або:

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

Мій спосіб зробити це передбачає додавання нового стовпця, унікального для одного фрейму даних, і використовувати його, щоб вибрати, чи потрібно зберігати запис

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

Це робить його таким, що кожен запис у df1 має код - 0, якщо він унікальний для df1, 1, якщо він є в обох фреймах даних. Потім ви використовуєте це для обмеження того, що ви хочете

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