pd.merge: joins internos y externos
Combine dos DataFrames mediante una columna clave compartida usando joins internos y externos, y comprenda qué filas se conservan o descartan.
pd.merge: joins internos y externos es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Pandas & NumPy Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.
¿Qué es un join?
Un join combina dos DataFrames haciendo coincidir las filas según una columna de clave compartida, el mismo concepto que la cláusula JOIN de SQL. Pandas implementa los joins mediante pd.merge(). A diferencia de pd.concat(), que simplemente apila los datos, pd.merge() alinea de forma inteligente las filas de dos tablas diferentes según los valores coincidentes de una o más columnas.
La columna de clave compartida
Para que una combinación funcione, ambos DataFrames deben tener al menos una columna con valores compartidos: la columna clave. Por ejemplo, una tabla orders tiene una columna customer_id, y una tabla customers también tiene una columna customer_id. Al combinar por customer_id, se añaden los detalles del cliente a cada fila de pedidos. Especifique la clave con el parámetro on cuando ambos DataFrames compartan el mismo nombre de columna.
import pandas as pd
orders = pd.DataFrame({
'order_id': [1, 2, 3, 4],
'customer_id': [101, 102, 101, 103],
'amount': [250, 80, 320, 150]
})
customers = pd.DataFrame({
'customer_id': [101, 102, 104],
'name': ['Alice', 'Bob', 'Diana']
})Combinación interna: intersección de ambas tablas
Una combinación interna (la opción predeterminada) conserva únicamente las filas cuyo valor clave existe en ambos DataFrames. Las filas de cualquiera de las tablas cuya clave no tenga correspondencia en la otra se descartan silenciosamente. En el ejemplo de los pedidos, los clientes 103 y 104 no tienen correspondencia en la otra tabla, por lo que sus filas se excluyen del resultado de la combinación interna.
# Inner join (default): only matching rows from both
result = pd.merge(orders, customers, on='customer_id', how='inner')
print(result)
# order_id customer_id amount name
# 0 1 101 250 Alice
# 1 3 101 320 Alice
# 2 2 102 80 Bob
# Order 4 (customer 103) dropped - no match in customers
# Diana (customer 104) dropped - no match in ordersCombinación externa: unión de ambas tablas
Una combinación externa (how='outer') conserva todas las filas de ambos DataFrames. Cuando una fila no tiene una clave correspondiente en la otra tabla, las columnas que faltan se rellenan con NaN. Esto resulta útil cuando desea obtener una visión completa de ambos conjuntos de datos y conservar los registros que no encontraron correspondencia.
result = pd.merge(orders, customers, on='customer_id', how='outer')
print(result)
# order_id customer_id amount name
# 0 1.0 101 250.0 Alice
# 1 3.0 101 320.0 Alice
# 2 2.0 102 80.0 Bob
# 3 4.0 103 150.0 NaN <- order with unknown customer
# 4 NaN 104 NaN Diana <- customer with no ordersCombinar columnas con nombres diferentes
Cuando la columna clave tiene un nombre diferente en cada DataFrame, use left_on y right_on en lugar de on. Pandas hace coincidir las filas en las que left_on del DataFrame izquierdo es igual a right_on del DataFrame derecho. Ambas columnas clave aparecen en el resultado; después puede eliminar la redundante.
products = pd.DataFrame({
'prod_id': [10, 20, 30],
'name': ['Widget', 'Gadget', 'Doohickey']
})
order_lines = pd.DataFrame({
'item_id': [10, 10, 20],
'qty': [3, 1, 5]
})
result = pd.merge(order_lines, products,
left_on='item_id', right_on='prod_id')
print(result.drop(columns='prod_id'))
# item_id qty name
# 0 10 3 Widget
# 1 10 1 Widget
# 2 20 5 GadgetCombinar por varias columnas
Para hacer coincidir filas mediante una combinación de columnas (una clave compuesta), pase una lista a on. Esto es habitual cuando una sola columna no basta para obtener una coincidencia única, como al combinar por year y region. Todas las columnas indicadas deben coincidir simultáneamente para que una fila se incluya en el resultado.
targets = pd.DataFrame({
'year': [2023, 2023, 2024],
'region': ['East', 'West', 'East'],
'target': [100, 150, 120]
})
actuals = pd.DataFrame({
'year': [2023, 2024, 2024],
'region': ['East', 'East', 'West'],
'actual': [95, 115, 80]
})
result = pd.merge(targets, actuals, on=['year', 'region'], how='inner')
print(result)
# year region target actual
# 0 2023 East 100 95
# 1 2024 East 120 115Gestionar nombres de columnas coincidentes
Cuando ambos DataFrames tienen una columna con el mismo nombre (distinta de la clave), Pandas añade sufijos para diferenciarlas. Los valores predeterminados son _x (izquierda) y _y (derecha). Puede personalizarlos con el parámetro suffixes para obtener nombres más descriptivos y evitar confusiones en el resultado.
df_a = pd.DataFrame({'id': [1, 2], 'value': [10, 20]})
df_b = pd.DataFrame({'id': [1, 2], 'value': [100, 200]})
# Default suffixes
print(pd.merge(df_a, df_b, on='id'))
# id value_x value_y
# Custom suffixes
print(pd.merge(df_a, df_b, on='id', suffixes=('_budget', '_actual')))
# id value_budget value_actualComprobar duplicados inesperados
Un problema habitual al combinar es la multiplicación inesperada de filas. Si la columna clave contiene valores duplicados en ambos DataFrames, la combinación produce un producto cartesiano de todas las filas coincidentes. Compruebe siempre el número de filas después de una combinación: si es mayor de lo esperado, investigue los duplicados de la columna clave con df.duplicated(subset=['key']).sum().
# Both tables have duplicate keys -> cartesian product
left = pd.DataFrame({'id': [1, 1], 'val_l': ['a', 'b']})
right = pd.DataFrame({'id': [1, 1], 'val_r': ['x', 'y']})
result = pd.merge(left, right, on='id')
print(len(result)) # 4 rows! (2x2 cartesian product)
print(result)
# id val_l val_r
# 0 1 a x
# 1 1 a y
# 2 1 b x
# 3 1 b yParámetro validate para mayor seguridad
Pase el parámetro validate para imponer restricciones de relación en la combinación y generar un error si se infringen. 'one_to_one' requiere claves únicas en ambas tablas, 'one_to_many' requiere claves únicas solo en la tabla izquierda y 'many_to_one' solo en la derecha. Se trata de una excelente práctica de programación defensiva que detecta pronto los problemas de calidad de los datos.
# Safe merge: validate that customer_id is unique in customers
try:
result = pd.merge(orders, customers,
on='customer_id',
how='inner',
validate='many_to_one')
print('Merge OK, shape:', result.shape)
except Exception as e:
print('Merge error:', e)Comprobar la cobertura con indicator
Pase indicator=True para añadir una columna _merge al resultado que indique de dónde procede cada fila: 'left_only', 'right_only' o 'both'. Esto resulta útil después de una combinación externa para identificar qué registros encontraron una correspondencia y cuáles no, y le ayuda a auditar la calidad de los datos antes de eliminar la columna indicadora.
result = pd.merge(orders, customers, on='customer_id',
how='outer', indicator=True)
print(result['_merge'].value_counts())
# both 3
# left_only 1 <- orders with no customer record
# right_only 1 <- customers with no orders
# Find unmatched orders
print(result[result['_merge'] == 'left_only'])Resumen de las combinaciones internas y externas
En resumen, los dos tipos de combinación funcionan así: la combinación interna proporciona la intersección, es decir, solo las filas con claves coincidentes en ambos DataFrames. La combinación externa proporciona la unión, es decir, todas las filas de ambos DataFrames, con NaN cuando no hay correspondencia. Para completar el resumen: la combinación izquierda conserva todas las filas del DataFrame izquierdo y la combinación derecha conserva todas las filas del DataFrame derecho. Estos conceptos se explican en la siguiente lección.
# Quick reference
# how='inner' -> intersection: only matched rows
# how='outer' -> union: all rows from both, NaN for no match
# how='left' -> all left rows + matched right rows
# how='right' -> all right rows + matched left rows
# Most common: inner (default) for enrichment, left for preserving recordsComprobación rápida
Compruebe lo que ha aprendido sobre las combinaciones internas y externas de pd.merge en esta lección.
Resumen de la lección
En esta lección ha aprendido que pd.merge() con how='inner' conserva únicamente las filas coincidentes de ambos DataFrames, mientras que how='outer' conserva todas las filas y usa NaN para las que no coinciden; on especifica la clave compartida, mientras que left_on/right_on gestionan nombres de columna diferentes; y el parámetro indicator ayuda a auditar qué filas coincidieron. A continuación, exploraremos las combinaciones izquierdas y derechas para conservar todas las filas de uno de los lados.
Preguntas frecuentes
¿La lección «pd.merge: joins internos y externos» es gratis?
Sí — el texto completo de «pd.merge: joins internos y externos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Pandas & NumPy Academy, actualiza a CoddyKit PRO. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.
¿Qué aprenderé en «pd.merge: joins internos y externos»?
Combine dos DataFrames mediante una columna clave compartida usando joins internos y externos, y comprenda qué filas se conservan o descartan. Practicas Pandas & NumPy Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Pandas & NumPy Academy?
No se requiere experiencia previa. Pandas & NumPy Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «pd.merge: joins internos y externos»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Pandas & NumPy Academy?
Sí. Cada lección de Pandas & NumPy Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- pd.concat para apilar DataFrames
- pd.merge: joins internos y externos
- Joins izquierdo y derecho
- Unir por el índice