Qual é a diferença entre ingressar e mesclar no Pandas?

Suponha que eu tenha dois DataFrames como este:

left = pd.DataFrame({'key1': ['foo', 'bar'], 'lval': [1, 2]})

right = pd.DataFrame({'key2': ['foo', 'bar'], 'rval': [4, 5]})

Quero mesclá-los, então tento algo assim:

pd.merge(left, right, left_on='key1', right_on='key2')

E eu estou feliz

    key1    lval    key2    rval
0   foo     1       foo     4
1   bar     2       bar     5

Mas estou tentando usar o método join, no qual fui levado a acreditar que é bastante semelhante.

left.join(right, on=['key1', 'key2'])

E eu entendo isso:

//anaconda/lib/python2.7/site-packages/pandas/tools/merge.pyc in _validate_specification(self)
    406             if self.right_index:
    407                 if not ((len(self.left_on) == self.right.index.nlevels)):
--> 408                     raise AssertionError()
    409                 self.right_on = [None] * n
    410         elif self.right_on is not None:

AssertionError: 

o que estou perdendo?

Eu sempre uso joinem índices:

import pandas as pd
left = pd.DataFrame({'key': ['foo', 'bar'], 'val': [1, 2]}).set_index('key')
right = pd.DataFrame({'key': ['foo', 'bar'], 'val': [4, 5]}).set_index('key')
left.join(right, lsuffix='_l', rsuffix='_r')

     val_l  val_r
key            
foo      1      4
bar      2      5

A mesma funcionalidade pode ser obtida usando mergeas colunas a seguir:

left = pd.DataFrame({'key': ['foo', 'bar'], 'val': [1, 2]})
right = pd.DataFrame({'key': ['foo', 'bar'], 'val': [4, 5]})
left.merge(right, on=('key'), suffixes=('_l', '_r'))

   key  val_l  val_r
0  foo      1      4
1  bar      2      5

pandas.merge() é a função subjacente usada para todo o comportamento de mesclagem / junção.

Os DataFrames fornecem os métodos pandas.DataFrame.merge()e pandas.DataFrame.join()como uma maneira conveniente de acessar os recursos do pandas.merge(). Por exemplo, df1.merge(right=df2, ...)é equivalente a pandas.merge(left=df1, right=df2, ...).

Estas são as principais diferenças entre df.join()e df.merge():

1. pesquisa na tabela à direita: df1.join(df2)sempre ingressa no índice de df2, mas df1.merge(df2)pode ingressar em uma ou mais colunas de df2(padrão) ou no índice de df2(com right_index=True).
2. pesquisa na tabela esquerda: por padrão, df1.join(df2)usa o índice de df1e df1.merge(df2)usa a (s) coluna (s) de df1. Isso pode ser substituído especificando df1.join(df2, on=key_or_keys)ou df1.merge(df2, left_index=True).
3. junção esquerda vs interna: df1.join(df2)faz uma junção esquerda por padrão (mantém todas as linhas de df1), mas df.mergefaz uma junção interna por padrão (retorna apenas as linhas correspondentes de df1e df2).

Portanto, a abordagem genérica é usar pandas.merge(df1, df2)or df1.merge(df2). Porém, em várias situações comuns (mantendo todas as linhas df1e ingressando em um índice df2), você pode salvar algumas digitações usando df1.join(df2).

Algumas notas sobre esses problemas da documentação em http://pandas.pydata.org/pandas-docs/stable/merging.html#database-style-dataframe-joining-merging :

merge é uma função no espaço de nomes do pandas e também está disponível como um método de instância DataFrame, com o DataFrame de chamada sendo implicitamente considerado o objeto esquerdo na junção.

O DataFrame.joinmétodo relacionado , usa mergeinternamente para as associações índice-sobre-índice e índice-sobre-coluna (s), mas ingressa nos índices por padrão, em vez de tentar ingressar em colunas comuns (o comportamento padrão para merge). Se você estiver ingressando no índice, convém usar DataFrame.joinpara economizar algumas digitações.

...

Essas duas chamadas de função são completamente equivalentes:

left.join(right, on=key_or_keys)
pd.merge(left, right, left_on=key_or_keys, right_index=True, how='left', sort=False)

Eu acredito que join()é apenas um método de conveniência. Tente em df1.merge(df2)vez disso, o que permite especificar left_one right_on:

In [30]: left.merge(right, left_on="key1", right_on="key2")
Out[30]: 
  key1  lval key2  rval
0  foo     1  foo     4
1  bar     2  bar     5

A partir desta documentação

O pandas fornece uma única função, mesclar, como o ponto de entrada para todas as operações de junção de banco de dados padrão entre os objetos DataFrame:

merge(left, right, how='inner', on=None, left_on=None, right_on=None,
      left_index=False, right_index=False, sort=True,
      suffixes=('_x', '_y'), copy=True, indicator=False)

E:

DataFrame.joiné um método conveniente para combinar as colunas de dois DataFrames potencialmente indexados de maneira diferente em um único DataFrame de resultado. Aqui está um exemplo muito básico: O alinhamento de dados aqui está nos índices (rótulos de linha). Esse mesmo comportamento pode ser alcançado usando a mesclagem e argumentos adicionais instruindo-o a usar os índices:

result = pd.merge(left, right, left_index=True, right_index=True,
how='outer')

Uma das diferenças é que mergeestá criando um novo índice e joinmantendo o índice do lado esquerdo. Pode ter uma grande consequência em suas transformações posteriores se você assumir erroneamente que seu índice não foi alterado merge.

Por exemplo:

import pandas as pd

df1 = pd.DataFrame({'org_index': [101, 102, 103, 104],
                    'date': [201801, 201801, 201802, 201802],
                    'val': [1, 2, 3, 4]}, index=[101, 102, 103, 104])
df1

       date  org_index  val
101  201801        101    1
102  201801        102    2
103  201802        103    3
104  201802        104    4

-

df2 = pd.DataFrame({'date': [201801, 201802], 'dateval': ['A', 'B']}).set_index('date')
df2

       dateval
date          
201801       A
201802       B

-

df1.merge(df2, on='date')

     date  org_index  val dateval
0  201801        101    1       A
1  201801        102    2       A
2  201802        103    3       B
3  201802        104    4       B

-

df1.join(df2, on='date')
       date  org_index  val dateval
101  201801        101    1       A
102  201801        102    2       A
103  201802        103    3       B
104  201802        104    4       B

• Join: Default Index (Se houver o mesmo nome de coluna, ocorrerá um erro no modo padrão porque você não definiu lsuffix ou rsuffix))

df_1.join(df_2)

• Mesclar: nomes das mesmas colunas padrão (se não houver o mesmo nome de coluna, ocorrerá um erro no modo padrão)

df_1.merge(df_2)

• on parâmetro tem um significado diferente nos dois casos

df_1.merge(df_2, on='column_1')

df_1.join(df_2, on='column_1') // It will throw error
df_1.join(df_2.set_index('column_1'), on='column_1')

Em termos análogos ao SQL "a mesclagem do Pandas é a junção externa / interna e a junção do Pandas é a junção natural". Portanto, quando você usa a mesclagem no pandas, deseja especificar que tipo de junção sqlish deseja usar, enquanto que ao usar a junção pandas, você realmente deseja ter um rótulo de coluna correspondente para garantir que ela se junte