in

python – Pandas Merging 101

apple touch icon@2

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

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

  • Conceptos básicos: tipos de uniones (IZQUIERDA, DERECHA, EXTERIOR, INTERIOR)

    • fusionando con diferentes nombres de columna
    • fusionando con varias columnas
    • evitando la columna de clave de combinación duplicada en la salida

Por lo que no pasará esta publicación (y otras publicaciones mías en este hilo):

  • Debates y horarios relacionados con el rendimiento (por ahora). Sobre todo menciones notables de mejores alternativas, cuando corresponda.
  • Manejo de sufijos, eliminación de columnas adicionales, cambio de nombre de salidas y otros casos de uso específicos. Hay otras publicaciones (léase: mejores) que tratan con eso, ¡así que descúbrelo!

Nota
La mayoría de los ejemplos utilizan de forma predeterminada las operaciones INNER JOIN mientras se muestran varias funciones, a menos que se especifique lo contrario.

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

Por último, toda la representación visual de las operaciones JOIN se ha dibujado a mano con Dibujos de Google. Inspiración de aquí.



Configuración y conceptos básicos

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 UNIR INTERNAMENTE está representado por

YvuOa

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

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

Para realizar una INNER JOIN, llame merge en el DataFrame izquierdo, especificando el DataFrame derecho y la clave de combinación (como mínimo) como argumentos.

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

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

A IZQUIERDA COMBINACIÓN EXTERNA, o LEFT JOIN está representado por

BECid

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

Observe detenidamente la ubicación de los NaN aquí. Si especifica how='left', entonces solo claves de left se utilizan, y faltan datos de right es reemplazado por NaN.

Y de manera similar, para un UNIÓN EXTERIOR DERECHA, o RIGHT JOIN que es …

8w1US

…especificar 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í, llaves de right se utilizan y faltan datos de left es reemplazado por NaN.

Finalmente, para el UNIÓN EXTERIOR COMPLETA, dada por

euLoe

especificar 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 usa las claves de ambos marcos, y los NaN se insertan para las filas que faltan en ambos.

La documentación resume muy bien estas diversas fusiones:

Ingrese la descripción de la imagen aquí


Otras JOINs: IZQUIERDA-Excluyendo, DERECHA-Excluyendo y FULL-Excluyendo / ANTI JOINs

Si necesitas IZQUIERDA-Excluyendo JOINs y DERECHO-Excluyendo JOINs en dos pasos.

Para LEFT-Excluyendo JOIN, representado como

bXWIV

Comience realizando una LEFT OUTER JOIN y luego filtre (¡excluyendo!) Filas provenientes de 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,

Z0br2

(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 debe realizar una combinación que solo retiene las claves de la izquierda o la derecha, pero no ambas (IOW, realizando una ANTI-UNIR),

PWMYd

Puede 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

Diferentes nombres para columnas clave

Si las columnas de clave tienen un nombre diferente, por ejemplo, left tiene keyLeft, y right tiene keyRight en lugar de key—Entonces tendrás 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

Evitar la columna de clave duplicada en la salida

Al fusionarse en keyLeft de left y keyRight de right, si solo quieres cualquiera de los keyLeft o keyRight (pero no ambos) en la salida, puede comenzar estableciendo 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

Compare esto con la salida del comando justo antes (es decir, la salida de left2.merge(right2, left_on='keyLeft', right_on='keyRight', how='inner')), notarás keyLeft Está perdido. Puede averiguar qué columna conservar en función del índice de qué marco se establece como clave. Esto puede ser importante cuando, por ejemplo, se realiza alguna operación 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 debe fusionar solo «new_val» (sin ninguna de las otras columnas), normalmente puede crear subconjuntos de 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á haciendo una LEFT OUTER JOIN, una solución más eficaz implicaría 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

Fusionar en varias columnas

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

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

O, en caso de que los nombres sean diferentes,

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

Otros útiles merge* operaciones y funciones

Esta sección solo cubre los conceptos básicos y está diseñada para abrirle el apetito. Para obtener 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.



Vaya a otros temas en Pandas Merging 101 para continuar aprendiendo:

*Estás aquí.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

60 124173 1512724240

¿Qué son los archivos .pyc en Python?

BKjAhCXREJgoY5TDuU3kZG 1200 80

Borderlands 3 One Pump Chump: dónde conseguir la escopeta legendaria de One Punch Man