Data Analysis · Lección 08 de 19

pandas: merge, join y concat

Los datos reales nunca viven en una sola tabla. Los clientes están en una tabla, las transacciones en otra, las sucursales en otra. Para analizar necesitás cruzar tablas — exactamente como los JOINs de SQL pero con la sintaxis de pandas. Si ya dominás SQL JOINs (lecciones SQL 07 y 08), esto te va a resultar familiar.

90–120 min Prerrequisitos: Lección 07 (groupby y pivot)

Concepto teórico

Las 3 operaciones de combinación

Operación	Qué hace	Equivalente SQL	Cuándo usarla
`pd.merge()`	Combina por columna clave	`JOIN ... ON`	Cruzar tablas por una clave compartida
`pd.concat()`	Apila filas o columnas	`UNION ALL`	Combinar tablas con la misma estructura
`df.join()`	Combina por índice	`JOIN ... ON index`	Cuando la clave es el índice

El 90% de los casos: vas a usar pd.merge(). Es la operación más versátil y explícita. concat() se usa cuando tenés datos partidos en archivos (ej: un CSV por mes) y querés apilarlos. join() es un atajo para merge por índice que se usa menos frecuentemente.

Los 4 tipos de merge (joins)

Igual que en SQL, pandas soporta 4 tipos de cruce. La diferencia es qué pasa con las filas que no tienen match en la otra tabla:

Tipo	how=	Qué conserva	Filas sin match
Inner	`"inner"`	Solo filas con match en ambas	Se pierden
Left	`"left"`	Todas las de la izquierda	NaN en columnas de la derecha
Right	`"right"`	Todas las de la derecha	NaN en columnas de la izquierda
Outer	`"outer"`	Todas las de ambas	NaN donde no hay match

Analogía de la fiesta: tenés la lista de invitados y la lista de los que realmente vinieron. Inner: solo los que están en ambas listas (vinieron y estaban invitados). Left: todos los invitados, marcando quién vino y quién no. Right: todos los que vinieron, marcando quién estaba invitado. Outer: la unión de todos — invitados que no vinieron Y colados que no estaban invitados.

# Sintaxis de merge
pd.merge(
    df_izquierda,
    df_derecha,
    on="columna_clave",      # Si se llama igual en ambas
    # left_on="col_izq",     # Si se llaman distinto
    # right_on="col_der",
    how="inner"               # inner | left | right | outer
)

concat: apilar DataFrames

pd.concat() es para cuando tenés dos o más DataFrames con las mismas columnas y querés unirlos verticalmente (apilar filas). El caso típico: un archivo CSV por mes y querés un solo DataFrame con todo el año.

# Concatenar verticalmente (filas)
pd.concat([df_enero, df_febrero, df_marzo], ignore_index=True)

# Concatenar horizontalmente (columnas) → menos común
pd.concat([df1, df2], axis=1)

¡Cuidado con los índices! Si no usás ignore_index=True, concat() conserva los índices originales de cada DataFrame. Esto significa que puedes terminar con un DataFrame donde el índice dice 0, 1, 2, 0, 1, 2 (repetidos). Siempre usá ignore_index=True al concatenar verticalmente.

En el trabajo real: el 80% de tus análisis van a requerir al menos un merge. Ejemplo típico: la tabla de transacciones tiene un cliente_id pero no tiene el nombre ni la ciudad. La tabla de clientes tiene cliente_id con nombre, ciudad y segmento. Necesitás hacer merge para cruzarlas. Esto pasa en cualquier empresa con base de datos relacional.

Ejemplos explicados paso a paso

Ejemplo 1: merge INNER — el cruce básico

Cruzar transacciones con datos del cliente. Solo se conservan las filas que tienen match en ambas tablas.

ejemplo_01_inner.pyPython

import pandas as pd

# Tabla de transacciones
transacciones = pd.DataFrame({
    "Txn_ID": [1001, 1002, 1003, 1004, 1005],
    "Cliente_ID": [10, 20, 30, 10, 40],
    "Monto": [15000, 8500, 22000, 18000, 9500]
})

# Tabla de clientes
clientes = pd.DataFrame({
    "Cliente_ID": [10, 20, 30, 50],
    "Nombre": ["García", "López", "Pérez", "Sosa"],
    "Ciudad": ["CABA", "Rosario", "CABA", "Mendoza"]
})

print("=== Transacciones ===")
print(transacciones)
print("\n=== Clientes ===")
print(clientes)

# INNER JOIN: solo los que existen en ambas tablas
resultado = pd.merge(transacciones, clientes, on="Cliente_ID", how="inner")
print("\n=== INNER MERGE (solo con match) ===")
print(resultado)
print(f"\nObservá: Cliente_ID 40 no aparece (no existe en clientes)")
print(f"         Cliente_ID 50 (Sosa) tampoco (no tiene transacciones)")

Hacé clic en ▶ Ejecutar

Ejemplo 2: LEFT merge — conservar todos los de la izquierda

El caso más común: querés TODAS las transacciones, incluso las que no tienen match en clientes. Las sin match muestran NaN.

ejemplo_02_left.pyPython

import pandas as pd

transacciones = pd.DataFrame({
    "Txn_ID": [1001, 1002, 1003, 1004, 1005],
    "Cliente_ID": [10, 20, 30, 10, 40],
    "Monto": [15000, 8500, 22000, 18000, 9500]
})

clientes = pd.DataFrame({
    "Cliente_ID": [10, 20, 30, 50],
    "Nombre": ["García", "López", "Pérez", "Sosa"],
    "Ciudad": ["CABA", "Rosario", "CABA", "Mendoza"]
})

# LEFT JOIN: todas las transacciones, con o sin dato de cliente
left_result = pd.merge(transacciones, clientes, on="Cliente_ID", how="left")
print("=== LEFT MERGE ===")
print(left_result)

print(f"\nTxn 1005 tiene Cliente_ID=40 que no existe en clientes → NaN")

# ¿Cuántas transacciones no tienen info de cliente?
sin_info = left_result["Nombre"].isna().sum()
print(f"Transacciones sin info de cliente: {sin_info}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: OUTER merge y merge con claves distintas

A veces la columna clave se llama distinto en cada tabla. Usá left_on y right_on.

ejemplo_03_outer.pyPython

import pandas as pd

# Las columnas tienen nombres distintos
ventas = pd.DataFrame({
    "ID_Venta": [1, 2, 3, 4],
    "cod_producto": ["A01", "B02", "C03", "D04"],
    "Cantidad": [10, 5, 20, 8]
})

catalogo = pd.DataFrame({
    "SKU": ["A01", "B02", "E05"],
    "Nombre": ["Notebook", "Mouse", "Cable HDMI"],
    "Precio": [450000, 15000, 3500]
})

# OUTER JOIN: conserva todo (de ambos lados)
outer = pd.merge(
    ventas, catalogo,
    left_on="cod_producto",    # Nombre en la tabla izquierda
    right_on="SKU",             # Nombre en la tabla derecha
    how="outer"
)
print("=== OUTER MERGE ===")
print(outer)
print(f"\nC03 y D04: están en ventas pero no en catálogo → NaN en Nombre/Precio")
print(f"E05: está en catálogo pero no tuvo ventas → NaN en ID_Venta/Cantidad")

Hacé clic en ▶ Ejecutar

Tip profesional — indicator=True: agregá indicator=True al merge y pandas crea una columna _merge que dice "both", "left_only" o "right_only" para cada fila. Es perfecto para diagnosticar cuántas filas tienen match y cuántas no.

Ejemplo 4: concat para apilar DataFrames

Cuando los datos vienen partidos (un CSV por mes, un archivo por región), se concatenan para formar un solo DataFrame.

ejemplo_04_concat.pyPython

import pandas as pd

# Simular 3 archivos CSV mensuales
enero = pd.DataFrame({
    "Mes": ["Enero"] * 3,
    "Producto": ["A", "B", "C"],
    "Ventas": [100, 200, 150]
})

febrero = pd.DataFrame({
    "Mes": ["Febrero"] * 3,
    "Producto": ["A", "B", "C"],
    "Ventas": [120, 180, 170]
})

marzo = pd.DataFrame({
    "Mes": ["Marzo"] * 3,
    "Producto": ["A", "B", "C"],
    "Ventas": [90, 220, 160]
})

# Concatenar verticalmente (apilar filas)
anual = pd.concat([enero, febrero, marzo], ignore_index=True)
print("=== Dataset anual (concatenado) ===")
print(anual)
print(f"\nFilas totales: {len(anual)}")

# Ahora podemos hacer groupby sobre todo el año
print("\n=== Ventas totales por producto (todo el año) ===")
print(anual.groupby("Producto")["Ventas"].sum())

Hacé clic en ▶ Ejecutar

Ejemplo 5: Merge múltiple — enriquecer datos paso a paso

En un caso real, cruzás más de 2 tablas. Hacés un merge tras otro, enriqueciendo tu dataset progresivamente.

ejemplo_05_multi_merge.pyPython

import pandas as pd

# Tabla 1: Transacciones
txn = pd.DataFrame({
    "Txn_ID": [1, 2, 3, 4, 5],
    "Cliente_ID": [10, 20, 10, 30, 20],
    "Sucursal_ID": [1, 2, 1, 3, 2],
    "Monto": [15000, 8500, 22000, 9500, 12000]
})

# Tabla 2: Clientes
clientes = pd.DataFrame({
    "Cliente_ID": [10, 20, 30],
    "Nombre": ["García", "López", "Pérez"],
    "Segmento": ["Premium", "Estándar", "Básico"]
})

# Tabla 3: Sucursales
sucursales = pd.DataFrame({
    "Sucursal_ID": [1, 2, 3],
    "Ciudad": ["CABA", "Rosario", "Córdoba"],
    "Zona": ["Centro", "Litoral", "Interior"]
})

# Merge encadenado: txn → clientes → sucursales
resultado = (txn
    .merge(clientes, on="Cliente_ID", how="left")
    .merge(sucursales, on="Sucursal_ID", how="left")
)

print("=== Dataset enriquecido ===")
print(resultado)

# Ahora puedo hacer queries ricas
print("\n=== Ventas por Segmento ===")
print(resultado.groupby("Segmento")["Monto"].sum())

print("\n=== Ventas por Zona ===")
print(resultado.groupby("Zona")["Monto"].sum())

Hacé clic en ▶ Ejecutar

Cuidado con las duplicaciones: si la tabla derecha tiene filas duplicadas para una misma clave (ej: un cliente aparece 2 veces), el merge va a duplicar las filas de la izquierda. Si tenés 1000 transacciones y 1 cliente está duplicado en la tabla de clientes, tus transacciones de ese cliente se van a duplicar. Siempre verificá con len() antes y después del merge.

Referencia rápida

Operación	Sintaxis	Uso
Inner merge	`pd.merge(a, b, on="key")`	Solo filas con match
Left merge	`pd.merge(a, b, on="key", how="left")`	Todas las de la tabla izquierda
Right merge	`pd.merge(a, b, on="key", how="right")`	Todas las de la tabla derecha
Outer merge	`pd.merge(a, b, on="key", how="outer")`	Todas las de ambas
Claves distintas	`left_on="x", right_on="y"`	Columnas con distinto nombre
Diagnóstico	`indicator=True`	Columna _merge con both/left/right
Concat vertical	`pd.concat([dfs], ignore_index=True)`	Apilar filas
Concat horizontal	`pd.concat([dfs], axis=1)`	Agregar columnas lado a lado

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Inner merge simple

Cruzá la tabla de pedidos con la de productos usando Prod_ID. Imprimí el resultado. Debe incluir Notebook.

ejercicio_01.pyDebe incluir "Notebook"

import pandas as pd

pedidos = pd.DataFrame({
    "Pedido_ID": [1, 2, 3],
    "Prod_ID": ["A", "B", "C"],
    "Cantidad": [2, 5, 1]
})

productos = pd.DataFrame({
    "Prod_ID": ["A", "B", "D"],
    "Nombre": ["Notebook", "Mouse", "Cable"]
})

# Inner merge por Prod_ID

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Left merge

Hacé un LEFT merge de pedidos con productos. Imprimí el resultado — deben aparecer las 3 filas de pedidos (la última con NaN). Debe incluir NaN o nan.

ejercicio_02.pyDebe incluir "NaN"

import pandas as pd

pedidos = pd.DataFrame({
    "Pedido_ID": [1, 2, 3],
    "Prod_ID": ["A", "B", "C"],
    "Cantidad": [2, 5, 1]
})

productos = pd.DataFrame({
    "Prod_ID": ["A", "B", "D"],
    "Nombre": ["Notebook", "Mouse", "Cable"]
})

# Left merge

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: concat vertical

Concatená dos DataFrames de ventas (enero y febrero) verticalmente con ignore_index=True. Imprimí la cantidad total de filas. Debe dar 6.

ejercicio_03.pyDebe incluir "6"

import pandas as pd

enero = pd.DataFrame({"Producto": ["A","B","C"], "Ventas": [100,200,150]})
febrero = pd.DataFrame({"Producto": ["A","B","C"], "Ventas": [120,180,170]})

# Concatená e imprimí cantidad de filas

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Merge con claves distintas

Las tablas tienen la clave con distinto nombre (cod_cli vs ID_Cliente). Usá left_on y right_on. Debe incluir García.

ejercicio_04.pyDebe incluir "García"

import pandas as pd

ventas = pd.DataFrame({
    "Venta_ID": [1, 2, 3],
    "cod_cli": [10, 20, 30],
    "Monto": [5000, 3000, 8000]
})

clientes = pd.DataFrame({
    "ID_Cliente": [10, 20, 30],
    "Nombre": ["García", "López", "Pérez"]
})

# Merge con claves de distinto nombre

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Merge + indicator

Hacé un OUTER merge con indicator=True. Contá cuántas filas son "both". Debe dar 2.

ejercicio_05.pyDebe incluir "2"

import pandas as pd

izq = pd.DataFrame({"Key": [1, 2, 3], "Val_A": ["a", "b", "c"]})
der = pd.DataFrame({"Key": [2, 3, 4], "Val_B": ["x", "y", "z"]})

# Outer merge con indicator, contá "both"

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Merge + cálculo

Cruzá pedidos con precios y creá la columna "Total" = Cantidad × Precio. Imprimí la suma total de ventas. Debe incluir 960000.

ejercicio_06.pyDebe incluir "960000"

import pandas as pd

pedidos = pd.DataFrame({
    "Prod_ID": ["A", "B", "A"],
    "Cantidad": [2, 5, 1]
})

precios = pd.DataFrame({
    "Prod_ID": ["A", "B"],
    "Nombre": ["Notebook", "Mouse"],
    "Precio": [450000, 12000]
})

# Merge + calcular Total + sumar

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Detectar "huérfanos" con left merge

Hacé un LEFT merge y encontrá las transacciones sin cliente asociado. Imprimí cuántas son. Debe dar 1.

ejercicio_07.pyDebe incluir "1"

import pandas as pd

txn = pd.DataFrame({
    "Txn_ID": [1, 2, 3, 4],
    "Cliente_ID": [10, 20, 99, 10],
    "Monto": [5000, 3000, 8000, 2000]
})

clientes = pd.DataFrame({
    "Cliente_ID": [10, 20, 30],
    "Nombre": ["García", "López", "Pérez"]
})

# Left merge y contar los que tienen NaN en Nombre

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Merge encadenado (3 tablas)

Cruzá transacciones → clientes → ciudades. Imprimí las columnas del resultado. Debe incluir Zona.

ejercicio_08.pyDebe incluir "Zona"

import pandas as pd

txn = pd.DataFrame({"Txn_ID": [1,2,3], "Cli_ID": [10,20,10], "Ciudad_ID": [1,2,1], "Monto": [5000,3000,8000]})
clientes = pd.DataFrame({"Cli_ID": [10,20], "Nombre": ["García","López"]})
ciudades = pd.DataFrame({"Ciudad_ID": [1,2], "Ciudad": ["CABA","Rosario"], "Zona": ["Centro","Litoral"]})

# Merge encadenado: txn → clientes → ciudades

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: concat + groupby

Concatená 3 DataFrames trimestrales, luego hacé groupby por Producto y sumá las ventas. El producto "A" debe sumar 310.

ejercicio_09.pyDebe incluir "310"

import pandas as pd

q1 = pd.DataFrame({"Producto": ["A","B"], "Ventas": [100, 200]})
q2 = pd.DataFrame({"Producto": ["A","B"], "Ventas": [110, 180]})
q3 = pd.DataFrame({"Producto": ["A","B"], "Ventas": [100, 220]})

# Concatená los 3, groupby Producto, sumá Ventas

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Pipeline completo — merge + transform + reporte

Cruzá transacciones con clientes (left merge). Rellenálos NaN de Segmento con "Desconocido". Agrupá por Segmento y reportá total + porcentaje de participación. Debe incluir Premium.

ejercicio_10_desafio.pyDebe incluir "Premium"

import pandas as pd

txn = pd.DataFrame({
    "Txn_ID": [1, 2, 3, 4, 5],
    "Cliente_ID": [10, 20, 30, 10, 99],
    "Monto": [15000, 8500, 22000, 18000, 5000]
})

clientes = pd.DataFrame({
    "Cliente_ID": [10, 20, 30],
    "Segmento": ["Premium", "Estándar", "Premium"]
})

# Pipeline: merge → fillna → groupby → participación

Hacé clic en ▶ Ejecutar

Resumen y conexión

pd.merge() es el JOIN de pandas: cruza tablas por una columna clave compartida.
Los 4 tipos de merge (inner, left, right, outer) definen qué pasa con filas sin match.
left_on/right_on se usan cuando la clave se llama distinto en cada tabla.
indicator=True diagnostica el merge mostrando qué filas tienen match y cuáles no.
pd.concat() apila DataFrames con la misma estructura (como UNION ALL de SQL).
Siempre verificá len() antes y después del merge para detectar duplicaciones inesperadas.

En la siguiente lección (09 · Estadística descriptiva) vas a aprender los fundamentos estadísticos que todo analista debe dominar: medidas de centralidad, dispersión, distribuciones, percentiles y cómo interpretar los números que pandas calcula.

Recursos: pandas docs — Merge, join, concatenate

Hecho con ❤️ por Rodri Gonzalez