pandas obtêm linhas que NÃO estão em outro dataframe

Eu tenho dois quadros de dados de pandas que têm algumas linhas em comum.

Suponha que dataframe2 seja um subconjunto de dataframe1.

Como posso obter as linhas do dataframe1 que não estão no 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]})

Um método seria armazenar o resultado de um formulário de mesclagem interna de ambos os dfs; então, podemos simplesmente selecionar as linhas quando os valores de uma coluna não estiverem tão comuns:

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

EDITAR

Outro método que você encontrou é usar o isinque produzirá NaNlinhas que você pode soltar:

In [138]:

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

No entanto, se o df2 não iniciar linhas da mesma maneira, isso não funcionará:

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

produzirá o df inteiro:

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

A solução atualmente selecionada produz resultados incorretos. Para resolver corretamente esse problema, podemos executar uma junção esquerda de df1para df2, certificando-se de obter primeiro apenas as linhas exclusivas df2.

Primeiro, precisamos modificar o DataFrame original para adicionar a linha aos dados [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

Execute uma junção esquerda, eliminando duplicatas df2para que cada linha de df1junções tenha exatamente 1 linha de df2. Use o parâmetro indicatorpara retornar uma coluna extra indicando de qual tabela a linha era.

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

Crie uma condição booleana:

df_all['_merge'] == 'left_only'

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

Por que outras soluções estão erradas

Algumas soluções cometem o mesmo erro - elas apenas verificam se cada valor está independentemente em cada coluna, não juntas na mesma linha. A adição da última linha, única, mas com os valores de ambas as colunas, df2expõe o erro:

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

Esta solução obtém o mesmo resultado errado:

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

Supondo que os índices sejam consistentes nos quadros de dados (sem levar em consideração os valores reais da coluna):

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

Como já foi sugerido, o isin exige que as colunas e os índices sejam os mesmos para uma correspondência. Se a correspondência só deve estar no conteúdo das linhas, uma maneira de obter a máscara para filtrar as linhas presentes é convertê-las em um (Multi) Índice:

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 o índice deve ser levado em consideração, set_index possui um argumento de palavra-chave anexado para anexar colunas ao índice existente. Se as colunas não se alinharem, a lista (df.columns) poderá ser substituída pelas especificações da coluna para alinhar os dados.

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

alternativamente, poderia ser usado para criar os índices, embora eu duvide que isso seja mais eficiente.

Suponha que você tenha dois quadros de dados, df_1 e df_2 com vários campos (nome_da_coluna) e deseje encontrar apenas as entradas no df_1 que não estão no df_2 com base em alguns campos (por exemplo, campos_x, campos_y), siga as etapas a seguir.

Etapa1.Adicione uma coluna key1 e key2 a df_1 e df_2 respectivamente.

Etapa 2.Merge os quadros de dados conforme mostrado abaixo. field_x e field_y são nossas colunas desejadas.

Etapa 3. Selecione apenas as linhas de df_1 em que chave1 não é igual a chave2.

Passo4.Drop chave1 e chave2.

Este método resolverá seu problema e funciona rapidamente, mesmo com grandes conjuntos de dados. Eu tentei para quadros de dados com mais de 1.000.000 de linhas.

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)

um pouco tarde, mas pode valer a pena verificar o parâmetro "indicator" do pd.merge.

Veja esta outra pergunta para um exemplo: Compare os PandaS DataFrames e retorne as linhas ausentes do primeiro

você pode fazer isso usando o método isin (dict) :

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

Explicação:

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

Você também pode concat df1, df2:

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

e remova todas as duplicatas:

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

Que tal agora:

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]

Aqui está outra maneira de resolver isso:

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

Ou:

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

Minha maneira de fazer isso envolve adicionar uma nova coluna exclusiva a um dataframe e usá-la para escolher se deseja manter uma entrada

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

Isso faz com que cada entrada no df1 tenha um código - 0 se for exclusivo do df1, 1 se estiver nos dois DataFrames. Você então usa isso para restringir o que deseja

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