Cómo unir Da­ta­Fra­mes con Pandas merge() en Python

La función Pandas DataFrame.merge() se utiliza para unir dos Da­ta­Fra­mes basándose en claves (keys) comunes. De este modo, puedes combinar datos de di­fe­re­n­tes fuentes de manera eficiente para realizar análisis más completos.

Sintaxis de la función Pandas merge()

La función de Pandas DataFrame.merge() de la Bi­blio­te­ca Python Pandas acepta una amplia variedad de pa­rá­me­tros que afectan la forma en que se combinan los Da­ta­Fra­mes. La sintaxis general de la función merge() es la siguiente:

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

Pa­rá­me­tros re­le­va­n­tes

Con los di­fe­re­n­tes pa­rá­me­tros que acepta la función Pandas merge(), no solo es­pe­ci­fi­cas los Da­ta­Fra­mes, que deseas combinar, sino también el tipo de unión (también llamada join en inglés) y otros detalles adi­cio­na­les.

Cómo utilizar Pandas merge()

Te pre­se­n­ta­mos una serie de ejemplos que te ayudarán a co­m­pre­n­der cómo funciona Pandas merge().

INNER JOIN o unión interna

Una INNER JOIN o unión interna une dos Da­ta­Fra­mes de Pandas y devuelve solo las filas en las que las claves coinciden en ambos Da­ta­Fra­mes. Primero, crearemos dos Da­ta­Fra­mes que nos servirán de ejemplo:

import pandas as pd
# DataFrames de ejemplo
df1 = pd.DataFrame({
    'Clave': ['A', 'B', 'C'],
    'Valor1': [1, 2, 3]
})
df2 = pd.DataFrame({
    'Clave': ['B', 'C', 'D'],
    'Valor2': [4, 5, 6]
})
print(df1)
print(df2)

Los dos Da­ta­Fra­mes re­su­l­ta­n­tes tendrían el siguiente aspecto:

Clave    Valor1
0        A             1
1        B             2
2        C             3
    Clave    Valor2
0        B             4
1        C             5
2        D             6

Ahora puedes realizar una INNER JOIN uti­li­za­n­do la función die merge():

# INNER JOIN
result = pd.merge(df1, df2, how='inner', on='Clave')
print(result)

La salida muestra que, en este ejemplo, solo las filas con las claves B y C se incluyen en el DataFrame re­su­l­ta­n­te, ya que estas están presentes en ambos Da­ta­Fra­mes ori­gi­na­les.

Clave    Valor1    Valor2
0        B            2            4
1        C            3            5

OUTER JOIN o unión externa

Una OUTER JOIN o unión externa también une dos Da­ta­Fra­mes. A di­fe­re­n­cia de la unión interna (INNER JOIN), con la unión externa se devuelven todas las filas y los valores faltantes se rellenan con NaN.

# OUTER JOIN
result = pd.merge(df1, df2, how='outer', on='Clave')
print(result)

Como era de esperar, en el DataFrame re­su­l­ta­n­te se incluyen todas las filas de ambos Da­ta­Fra­mes. Para la clave A, que solo está presente en df1, y la clave D, que solo está presente en df2, los valores faltantes se rellenan con NaN.

Clave    Valor1    Valor2
0        A        1.0        NaN
1        B        2.0        4.0
2        C        3.0        5.0
3        D        NaN        6.0

Uso de left_on y right_on

A veces, los dos Da­ta­Fra­mes tienen di­fe­re­n­tes nombres de columnas clave. En este caso, puedes usar los pa­rá­me­tros left_on y right_on para es­pe­ci­fi­car qué columnas se deben utilizar. Para esto, primero debes crear dos nuevos Da­ta­Fra­mes:

df3 = pd.DataFrame({
    'Clave': ['A', 'B', 'C'],
    'Valor1': [1, 2, 3]
})
df4 = pd.DataFrame({
    'Clave2': ['B', 'C', 'D'],
    'Valor2': [4, 5, 6]
})
print(df3)
print(df4)

Los dos Da­ta­Fra­mes re­su­l­ta­n­tes tienen el siguiente aspecto:

Clave    Valor1
0        A            1
1        B            2
2        C            3
    Clave2    Valor2
0        B            4
1        C            5
2        D            6

Para realizar la operación JOIN con claves di­fe­re­n­tes, se es­pe­ci­fi­can los pa­rá­me­tros left_on y right_on:

# Unir con diferentes nombres de columnas clave
result = pd.merge(df3, df4, how='inner', left_on='Clave', right_on='Clave2')
print(result)

Al utilizar ex­plí­ci­ta­me­n­te left_on='Clave' y right_on='Clave2', se usan las columnas clave co­rre­s­po­n­die­n­tes para realizar la unión.

Clave  Valor1 Clave2 Valor2
0     B        2        B        4
1     C        3        C        5

Uso de índices como clave

También puedes utilizar los índices de los Da­ta­Fra­mes como clave para la unión co­n­fi­gu­ra­n­do los pa­rá­me­tros left_index y right_index en True. Primero, se crean dos nuevos Da­ta­Fra­mes con índices:

df5 = pd.DataFrame({
    'Valor1': [1, 2, 3]
}, index=['A', 'B', 'C'])
df6 = pd.DataFrame({
    'Valor2': [4, 5, 6]
}, index=['B', 'C', 'D'])
print(df5)
print(df6)

Con el código anterior, se generan los si­guie­n­tes Da­ta­Fra­mes:

Valor1
A        1
B        2
C        3
    Valor2
B        4
C        5
D        6

Ahora se puede realizar una operación de unión basada en los índices con Pandas merge():

# Unir con índices
result = pd.merge(df5, df6, how='inner', left_index=True, right_index=True)
print(result)

El resultado, tal y como era de esperar, es una unión o JOIN basada en los índices de los Da­ta­Fra­mes:

Valor1  Valor2
B        2        4
C        3        5