python - inner - ¿Cuál es la diferencia entre join y merge en Pandas?

pandas python

Question

Supongamos que tengo dos DataFrames así:

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

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

Quiero fusionarlos, entonces intento algo como esto:

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

Y estoy feliz

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

Pero estoy tratando de usar el método de unión, que me han hecho creer que es bastante similar.

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

Y entiendo esto:

//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: 

¿Qué me estoy perdiendo?

Answer 1

Creo que join() es solo un método de conveniencia. Pruebe df1.merge(df2) lugar, lo que le permite especificar left_on y 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

Answer 2

Siempre uso join en í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

Se puede tener la misma funcionalidad al usar merge en las columnas siguientes:

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

Answer 3

http://pandas.pydata.org/pandas-docs/stable/merging.html#brief-primer-on-merge-methods-relational-algebra

pandas proporciona una única función, fusionar, como punto de entrada para todas las operaciones de combinación de base de datos estándar entre objetos DataFrame:

merge (left, right, how = ''inner'', on = None, left_on = None, right_on = None, left_index = False, right_index = False, sort = True, sufijos = (''_ x'', ''_y''), copy = Verdadero, indicador = Falso)

Y:

DataFrame.join es un método conveniente para combinar las columnas de dos DataFrames potencialmente indexados de manera diferente en un solo DataFrame de resultados. Aquí hay un ejemplo muy básico: la alineación de datos aquí está en los índices (etiquetas de fila). Este mismo comportamiento se puede lograr usando fusionar más argumentos adicionales para que use los índices: result = pd.merge (left, right, left_index = True, right_index = True, how = ''outer'')

Answer 4

pandas.merge() es la función subyacente utilizada para todo el comportamiento de fusión / unión.

DataFrames proporciona los pandas.DataFrame.merge() y pandas.DataFrame.join() como una forma conveniente de acceder a las capacidades de pandas.merge() . Por ejemplo, df1.merge(right=df2, ...) es equivalente a pandas.merge(left=df1, right=df2, ...) .

Estas son las principales diferencias entre df.join() y df.merge() :

1. búsqueda en la tabla derecha: df1.join(df2) siempre se une mediante el índice de df2 , pero df1.merge(df2) puede unirse a una o más columnas de df2 (predeterminado) o al índice de df2 (con right_index=True ) .
2. búsqueda en la tabla de la izquierda: de forma predeterminada, df1.join(df2) usa el índice de df1 y df1.merge(df2) usa la (s) columna (s) de df1 . Esto puede df1.join(df2, on=key_or_keys) especificando df1.join(df2, on=key_or_keys) o df1.merge(df2, left_index=True) .
3. combinación izquierda vs interna: df1.join(df2) hace una combinación izquierda por defecto (mantiene todas las filas de df1 ), pero df.merge hace una unión interna por defecto (devuelve solo filas coincidentes de df1 y df2 ).

Entonces, el enfoque genérico es usar pandas.merge(df1, df2) o df1.merge(df2) . Pero para una serie de situaciones comunes (mantener todas las filas de df1 y df1 a un índice en df2 ), puede guardar algo de tipeo usando df1.join(df2) lugar.

Algunas notas sobre estos temas de la documentación en http://pandas.pydata.org/pandas-docs/stable/merging.html#database-style-dataframe-joining-merging :

merge es una función en el espacio de nombres de los pandas, y también está disponible como un método de instancia de DataFrame, y el DataFrame llamante se considera implícitamente como el objeto izquierdo de la unión.

El método DataFrame.join relacionado utiliza merge internamente para las DataFrame.join index-on-index e index-on-column (s), pero se une a los índices de forma predeterminada en lugar de intentar unirse en columnas comunes (el comportamiento predeterminado para merge ). Si se está uniendo al índice, puede usar DataFrame.join para ahorrarse algunos DataFrame.join .

...

Estas dos llamadas a funciones son 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)