two name inner index data columns column python pandas join merge

name - python merge inner join



Pandas fusionando 101 (2)

Esta publicación tiene como objetivo proporcionar a los lectores una introducción a la fusión con pandas con sabor a SQL, cómo usarla y cuándo no.

En particular, esto es lo que pasará con esta publicación:

  • Los conceptos básicos: tipos de combinaciones (IZQUIERDA, DERECHA, EXTERIOR, INTERIOR)

    • fusionarse con diferentes nombres de columna
    • evitando la columna de clave de combinación duplicada en la salida
  • Fusión con índice bajo diferentes condiciones.
    • efectivamente usando su índice nombrado
    • clave de fusión como el índice de uno y la columna de otro
  • Multiway se fusiona en columnas e índices (únicos y no únicos)
  • Alternativas notables para merge y join

Lo que este post no pasará:

  • Discusiones y horarios relacionados con el desempeño (por ahora). Principalmente menciones notables de mejores alternativas, donde sea apropiado.
  • Manejar sufijos, eliminar columnas adicionales, cambiar el nombre de las salidas y otros casos de uso específicos. Hay otros (leer: mejor) publicaciones que tratan con eso, ¡así que descúbralo!

Nota
La mayoría de los ejemplos predeterminan las operaciones de INNER JOIN mientras se muestran varias características, a menos que se especifique lo contrario.

Además, todos los DataFrames aquí se pueden copiar y replicar para que puedas jugar con ellos. Además, vea esta publicación sobre cómo leer DataFrames desde su portapapeles.

Por último, todas las representaciones visuales de las operaciones de JOIN se han dibujado a mano utilizando los dibujos de Google. Inspiración desde here .

Basta de hablar, solo muéstrame cómo usar merge !

Preparar

np.random.seed(0) left = pd.DataFrame({''key'': [''A'', ''B'', ''C'', ''D''], ''value'': np.random.randn(4)}) right = pd.DataFrame({''key'': [''B'', ''D'', ''E'', ''F''], ''value'': np.random.randn(4)}) left key value 0 A 1.764052 1 B 0.400157 2 C 0.978738 3 D 2.240893 right key value 0 B 1.867558 1 D -0.977278 2 E 0.950088 3 F -0.151357

En aras de la simplicidad, la columna clave tiene el mismo nombre (por ahora).

Un INNER JOIN está representado por

Nota
Esto, junto con las próximas figuras, siguen esta convención:

  • azul indica filas que están presentes en el resultado de la fusión
  • rojo indica las filas que están excluidas del resultado (es decir, eliminadas)
  • verde indica valores perdidos que se reemplazan con NaN en el resultado

Para realizar un INNER JOIN, llame a pd.merge especificando el DataFrame izquierdo, el DataFrame derecho y la clave de combinación.

pd.merge(left, right, on=''key'') key value_x value_y 0 B 0.400157 1.867558 1 D 2.240893 -0.977278

Esto devuelve solo las filas de left y right que comparten una clave común (en este ejemplo, "B" y "D").

En versiones más recientes de pandas (v0.21 o algo así), merge es ahora una función de primer orden, por lo que puede llamar a DataFrame.merge .

left.merge(right, on=''key'') # Or, if you want to be explicit # left.merge(right, on=''key'', how=''inner'') key value_x value_y 0 B 0.400157 1.867558 1 D 2.240893 -0.977278

Una UNIÓN EXTERNA IZQUIERDA , o UNA UNIÓN IZQUIERDA se representa por

Esto se puede realizar especificando how=''left'' .

left.merge(right, on=''key'', how=''left'') key value_x value_y 0 A 1.764052 NaN 1 B 0.400157 1.867558 2 C 0.978738 NaN 3 D 2.240893 -0.977278

Tenga en cuenta cuidadosamente la colocación de NaNs aquí. Si especifica how=''left'' , solo se usan las teclas de la left , y los datos que faltan de la right se reemplazan por NaN.

Y de manera similar, para una JUNTA EXTERNA DERECHA , o UNA JUNTA CORRECTA que es ...

... especifique how=''right'' :

left.merge(right, on=''key'', how=''right'') key value_x value_y 0 B 0.400157 1.867558 1 D 2.240893 -0.977278 2 E NaN 0.950088 3 F NaN -0.151357

Aquí, se usan las teclas de la right y los datos que faltan de la left se reemplazan por NaN.

Finalmente, para la ÚLTIMA UNIÓN EXTERNA , dada por

especifique how=''outer'' .

left.merge(right, on=''key'', how=''outer'') key value_x value_y 0 A 1.764052 NaN 1 B 0.400157 1.867558 2 C 0.978738 NaN 3 D 2.240893 -0.977278 4 E NaN 0.950088 5 F NaN -0.151357

Esto utiliza las claves de ambos cuadros, y se insertan NaN para las filas que faltan en ambos.

La documentación resume estas diversas combinaciones muy bien:

Otros JOINs - LEFT-Excluding, RIGHT-Excluding y FULL-Excluding / ANTI JOINs

Si necesita JOINs con exclusión IZQUIERDA y JOIN con DERECHA en dos pasos.

Para JOIN IZQUIERDO Excluido, representado como

Comience por realizar una JUNTA EXTERNA IZQUIERDA y luego filtre (¡excluyendo!) Las filas que vienen de la left solamente

(left.merge(right, on=''key'', how=''left'', indicator=True) .query(''_merge == "left_only"'') .drop(''_merge'', 1)) key value_x value_y 0 A 1.764052 NaN 2 C 0.978738 NaN

Dónde,

left.merge(right, on=''key'', how=''left'', indicator=True) key value_x value_y _merge 0 A 1.764052 NaN left_only 1 B 0.400157 1.867558 both 2 C 0.978738 NaN left_only 3 D 2.240893 -0.977278 both

Y de manera similar, para un JOIN que excluye el DERECHO,

(left.merge(right, on=''key'', how=''right'', indicator=True) .query(''_merge == "right_only"'') .drop(''_merge'', 1)) key value_x value_y 2 E NaN 0.950088 3 F NaN -0.151357

Por último, si tiene que hacer una combinación que solo retenga las teclas de la izquierda o la derecha, pero no de ambas (IOW, realizando un ANTI-JOIN ),

Puedes hacer esto de manera similar:

(left.merge(right, on=''key'', how=''outer'', indicator=True) .query(''_merge != "both"'') .drop(''_merge'', 1)) key value_x value_y 0 A 1.764052 NaN 2 C 0.978738 NaN 4 E NaN 0.950088 5 F NaN -0.151357

Nombres diferentes para columnas clave

Si las columnas clave tienen nombres diferentes, por ejemplo, left tiene keyLeft y right tiene keyRight lugar de key entonces tendrá que especificar left_on y right_on como argumentos en lugar de on :

left2 = left.rename({''key'':''keyLeft''}, axis=1) right2 = right.rename({''key'':''keyRight''}, axis=1) left2 keyLeft value 0 A 1.764052 1 B 0.400157 2 C 0.978738 3 D 2.240893 right2 keyRight value 0 B 1.867558 1 D -0.977278 2 E 0.950088 3 F -0.151357

left2.merge(right2, left_on=''keyLeft'', right_on=''keyRight'', how=''inner'') keyLeft value_x keyRight value_y 0 B 0.400157 B 1.867558 1 D 2.240893 D -0.977278

Evitando la columna de clave duplicada en la salida

Al fusionar en keyLeft desde la left y keyRight desde la right , si solo desea que keyLeft o keyRight (pero no ambas) en la salida, puede comenzar configurando el índice como un paso preliminar.

left3 = left2.set_index(''keyLeft'') left3.merge(right2, left_index=True, right_on=''keyRight'') value_x keyRight value_y 0 0.400157 B 1.867558 1 2.240893 D -0.977278

Contraste esto con la salida del comando justo antes (thst is, la salida de left2.merge(right2, left_on=''keyLeft'', right_on=''keyRight'', how=''inner'') ), notará que falta keyLeft . Puede averiguar qué columna mantener en función de qué índice de cuadro se establece como clave. Esto puede importar cuando, por ejemplo, realizar alguna operación de OUTER JOIN.

Fusionando solo una columna de uno de los DataFrames

Por ejemplo, considere

right3 = right.assign(newcol=np.arange(len(right))) right3 key value newcol 0 B 1.867558 0 1 D -0.977278 1 2 E 0.950088 2 3 F -0.151357 3

Si se le pide que combine solo "new_val" (sin ninguna de las otras columnas), generalmente puede agrupar columnas antes de fusionar:

left.merge(right3[[''key'', ''newcol'']], on=''key'') key value newcol 0 B 0.400157 0 1 D 2.240893 1

Si está realizando una IZQUIERDA EXTERNA IZQUIERDA, una solución más eficaz incluiría un map :

# left[''newcol''] = left[''key''].map(right3.set_index(''key'')[''newcol''])) left.assign(newcol=left[''key''].map(right3.set_index(''key'')[''newcol''])) key value newcol 0 A 1.764052 NaN 1 B 0.400157 0.0 2 C 0.978738 NaN 3 D 2.240893 1.0

Como se mencionó, esto es similar, pero más rápido que

left.merge(right3[[''key'', ''newcol'']], on=''key'', how=''left'') key value newcol 0 A 1.764052 NaN 1 B 0.400157 0.0 2 C 0.978738 NaN 3 D 2.240893 1.0

Fusión en múltiples columnas

Para unirse en más de una columna, especifique una lista para on (o left_on y right_on , según corresponda).

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

O, en el caso de que los nombres sean diferentes,

left.merge(right, left_on=[''lkey1'', ''lkey2''], right_on=[''rkey1'', ''rkey2''])

Otras operaciones y funciones de merge* útiles

Esta sección solo cubre lo más básico, y está diseñada para solo abrir el apetito. Para ver más ejemplos y casos, consulte la documentación sobre merge , join y concat , así como los enlaces a las especificaciones de la función.

Basado en índices * -JOIN (+ merge índice-columna s)

Preparar

np.random.seed([3, 14]) left = pd.DataFrame({''value'': np.random.randn(4)}, index=[''A'', ''B'', ''C'', ''D'']) right = pd.DataFrame({''value'': np.random.randn(4)}, index=[''B'', ''D'', ''E'', ''F'']) left.index.name = right.index.name = ''idxkey'' left value idxkey A -0.602923 B -0.402655 C 0.302329 D -0.524349 right value idxkey B 0.543843 D 0.013135 E -0.326498 F 1.385076

Normalmente, una combinación en el índice se vería así:

left.merge(right, left_index=True, right_index=True) value_x value_y idxkey B -0.402655 0.543843 D -0.524349 0.013135

Soporte para nombres de índice

Si se nombra su índice, entonces los usuarios de v0.23 también pueden especificar el nombre del nivel on (o left_on y right_on según sea necesario).

left.merge(right, on=''idxkey'') value_x value_y idxkey B -0.402655 0.543843 D -0.524349 0.013135

Fusión en el índice de una, columna (s) de otra

Es posible (y bastante simple) usar el índice de uno, y la columna de otro, para realizar una fusión. Por ejemplo,

left.merge(right, left_on=''key1'', right_index=True)

O viceversa ( right_on=... e left_index=True ).

right2 = right.reset_index().rename({''idxkey'' : ''colkey''}, axis=1) right2 colkey value 0 B 0.543843 1 D 0.013135 2 E -0.326498 3 F 1.385076 left.merge(right2, left_index=True, right_on=''colkey'') value_x colkey value_y 0 -0.402655 B 0.543843 1 -0.524349 D 0.013135

En este caso especial, el índice para la left tiene un nombre, por lo que también puede usar el nombre del índice con left_on , así:

left.merge(right2, left_on=''idxkey'', right_on=''colkey'') value_x colkey value_y 0 -0.402655 B 0.543843 1 -0.524349 D 0.013135

DataFrame.join
Además de estos, hay otra opción sucinta. Puede usar DataFrame.join que por defecto se une en el índice. DataFrame.join realiza una IZQUIERDA DataFrame.join IZQUIERDA de forma predeterminada, por how=''inner'' aquí es necesario how=''inner'' .

left.join(right, how=''inner'', lsuffix=''_x'', rsuffix=''_y'') value_x value_y idxkey B -0.402655 0.543843 D -0.524349 0.013135

Tenga en cuenta que necesitaba especificar los argumentos de lsuffix y rsuffix ya que de lo contrario, la join generaría un error:

left.join(right) ValueError: columns overlap but no suffix specified: Index([''value''], dtype=''object'')

Dado que los nombres de las columnas son los mismos. Esto no sería un problema si tuvieran un nombre diferente.

left.rename(columns={''value'':''leftvalue''}).join(right, how=''inner'') leftvalue value idxkey B -0.402655 0.543843 D -0.524349 0.013135

pd.concat
Por último, como alternativa para uniones basadas en índices, puede usar pd.concat :

pd.concat([left, right], axis=1, sort=False, join=''inner'') value value idxkey B -0.402655 0.543843 D -0.524349 0.013135

Omita join=''inner'' si necesita un FULL OUTER JOIN (el valor predeterminado):

pd.concat([left, right], axis=1, sort=False) value value A -0.602923 NaN B -0.402655 0.543843 C 0.302329 NaN D -0.524349 0.013135 E NaN -0.326498 F NaN 1.385076

Para obtener más información, consulte esta publicación canónica en pd.concat por @piRSquared .

Generalizando: merge múltiples DataFrames

A menudo, la situación surge cuando se deben fusionar varios DataFrames. De forma ingenua, esto se puede hacer encadenando llamadas de merge :

df1.merge(df2, ...).merge(df3, ...)

Sin embargo, esto se va rápidamente de las manos para muchos DataFrames. Además, puede ser necesario generalizar para un número desconocido de DataFrames.

Aquí presento pd.concat para pd.concat de múltiples vías en claves únicas , y DataFrame.join para DataFrame.join de múltiples vías en claves no únicas . Primero, la configuración.

# Setup. np.random.seed(0) A = pd.DataFrame({''key'': [''A'', ''B'', ''C'', ''D''], ''valueA'': np.random.randn(4)}) B = pd.DataFrame({''key'': [''B'', ''D'', ''E'', ''F''], ''valueB'': np.random.randn(4)}) C = pd.DataFrame({''key'': [''D'', ''E'', ''J'', ''C''], ''valueC'': np.ones(4)}) dfs = [A, B, C] # Note, the "key" column values are unique, so the index is unique. A2 = A.set_index(''key'') B2 = B.set_index(''key'') C2 = C.set_index(''key'') dfs2 = [A2, B2, C2]

Fusión de múltiples vías en claves únicas (o índice)

Si sus claves (aquí, la clave podría ser una columna o un índice) son únicas, entonces puede usar pd.concat . Tenga en cuenta que pd.concat une a DataFrames en el índice .

# merge on `key` column, you''ll need to set the index before concatenating pd.concat([ df.set_index(''key'') for df in dfs], axis=1, join=''inner'' ).reset_index() key valueA valueB valueC 0 D 2.240893 -0.977278 1.0 # merge on `key` index pd.concat(dfs2, axis=1, sort=False, join=''inner'') valueA valueB valueC key D 2.240893 -0.977278 1.0

Omit join=''inner'' para una JUNTA EXTERIOR COMPLETA. Tenga en cuenta que no puede especificar uniones IZQUIERDA o EXTRA DERECHA (si las necesita, use la join , que se describe a continuación).

Multiway fusionar en claves con duplicados

concat es rápido, pero tiene sus defectos. No puede manejar duplicados.

A3 = pd.DataFrame({''key'': [''A'', ''B'', ''C'', ''D'', ''D''], ''valueA'': np.random.randn(5)})

pd.concat([df.set_index(''key'') for df in [A3, B, C]], axis=1, join=''inner'') ValueError: Shape of passed values is (3, 4), indices imply (3, 2)

En esta situación, podemos usar la join ya que puede manejar claves no únicas (tenga en cuenta que la join une los marcos de datos en su índice; llama a la merge bajo el capó y realiza una UNIÓN EXTERNA IZQUIERDA a menos que se especifique lo contrario)

# join on `key` column, set as the index first # For inner join. For left join, omit the "how" argument. A.set_index(''key'').join( [df.set_index(''key'') for df in (B, C)], how=''inner'').reset_index() key valueA valueB valueC 0 D 2.240893 -0.977278 1.0 # join on `key` index A3.set_index(''key'').join([B2, C2], how=''inner'') valueA valueB valueC key D 1.454274 -0.977278 1.0 D 0.761038 -0.977278 1.0

  • ¿Cómo realizar una unión ( LEFT | RIGHT | FULL ) ( INNER | OUTER ) con pandas?
  • ¿Cómo agrego NaNs para las filas faltantes después de combinar?
  • ¿Cómo me deshago de los NaN después de la fusión?
  • ¿Puedo fusionarme en el índice?
  • Cruzar con los pandas?
  • ¿Cómo fusiono múltiples DataFrames?
  • merge join ? concat ? update ? ¿Quien? ¿Qué? ¡¿Por qué?!

... y más. He visto estas preguntas recurrentes sobre varias facetas de la funcionalidad de fusión de pandas. La mayor parte de la información sobre la fusión y sus diversos casos de uso hoy en día está fragmentada en docenas de publicaciones mal redactadas e inescrutables. El objetivo aquí es recopilar algunos de los puntos más importantes para la posteridad.

Esta QnA está destinada a ser la próxima entrega de una serie de guías de usuario útiles sobre modismos pandas comunes (consulte esta publicación sobre pivotaje y esta publicación sobre concatenación , que veré más adelante).

Tenga en cuenta que esta publicación no pretende ser un reemplazo de la documentation , ¡así que lea esto también! Algunos de los ejemplos son tomados de allí.

Una vista visual complementaria de pd.concat([df0, df1], kwargs) . Observe que el significado de kwarg axis=0 o axis=1 no es tan intuitivo como df.mean() o df.apply(func)