¿Cómo encuentro las filas sin pareja al hacer un merge?

Añade indicator=True y filtra la columna _merge: las filas con left_only solo están en la tabla de la izquierda y las de right_only, solo en la de la derecha.

¿En qué se diferencian merge(), join() y concat() en pandas?

merge() une por columnas clave, join() une por el índice y concat() apila tablas una debajo o al lado de otra sin buscar coincidencias. Para relacionar tablas como clientes y pedidos, usa merge().

¿Qué son las columnas _x y _y después de un merge?

Son columnas que tenían el mismo nombre en las dos tablas y no eran clave. pandas les añade esos sufijos para distinguirlas. Puedes cambiarlos con suffixes=("_2025", "_2026").

¿Por qué merge() me devuelve más filas de las esperadas?

Porque hay claves repetidas: cada combinación de filas con la misma clave crea una fila nueva. Revisa los duplicados con df.duplicated("id").sum() y usa validate="one_to_one" o "one_to_many" para que pandas te avise.

¿Cómo hago un merge con columnas que se llaman distinto?

Usa left_on y right_on: df1.merge(df2, left_on="id", right_on="cliente_id"). Las dos columnas se quedan en el resultado, así que borra la que sobra con drop(columns="cliente_id").

¿Qué diferencia hay entre inner, left, right y outer en pandas merge()?

inner conserva solo las claves que están en las dos tablas; left, todas las filas de la izquierda; right, todas las de la derecha, y outer, todas las de las dos. Cuando una fila no tiene pareja, sus columnas nuevas se llenan con NaN.

¿Qué hace merge() en pandas?

Une dos DataFrames por una o varias columnas en común, igual que un JOIN de SQL. Con on indicas la columna clave y con how el tipo de unión: inner, left, right, outer o cross.

4Geeks chosen to deliver AI education in the Bahamas alongside Harvard, Oxford, and Columbia.See more

ACCEDER

Cómo usar merge en Pandas para combinar datos

Une DataFrames como un JOIN de SQL, elige el tipo de unión correcto y evita filas duplicadas, NaN y otros errores típicos.

8 min readLast updated 9 nov 2026

¿Cómo combinar DataFrames con merge() en pandas?

Respuesta corta: merge() une dos DataFrames por una o varias columnas en común, igual que un JOIN de SQL. Indicas la columna con on y el tipo de unión con how: "inner" (por defecto), "left", "right", "outer" o "cross".

python

import pandas as pd
 
clientes = pd.DataFrame({"id": [1, 2, 3], "nombre": ["Ana", "Luis", "Marta"]})
pedidos = pd.DataFrame({"id": [1, 1, 3, 4], "total": [50, 20, 80, 35]})
 
print(clientes.merge(pedidos, on="id"))

   id nombre  total
0   1    Ana     50
1   1    Ana     20
2   3  Marta     80

Ana aparece dos veces porque tiene dos pedidos. Luis no sale porque no tiene pedidos, y el pedido del cliente 4 tampoco, porque ese cliente no existe. pd.merge(clientes, pedidos, on="id") hace exactamente lo mismo.

El parámetro how decide qué filas se quedan cuando una clave solo existe en una de las dos tablas.

Sintaxis de merge()

python

izquierda.merge(
    derecha,
    how="inner",
    on=None,
    left_on=None,
    right_on=None,
    left_index=False,
    right_index=False,
    suffixes=("_x", "_y"),
    indicator=False,
    validate=None,
)

Parámetro	Qué hace
`derecha`	El segundo DataFrame que quieres unir
`how`	El tipo de unión: `"inner"`, `"left"`, `"right"`, `"outer"` o `"cross"`
`on`	La columna o la lista de columnas que tienen las dos tablas
`left_on` / `right_on`	Las columnas clave cuando tienen nombres distintos en cada tabla
`left_index` / `right_index`	Usa el índice como clave en lugar de una columna
`suffixes`	Los sufijos de las columnas repetidas que no son clave
`indicator`	Añade la columna `_merge` con el origen de cada fila
`validate`	Comprueba la relación: `"one_to_one"`, `"one_to_many"`, `"many_to_one"`

Tipos de merge: inner, left, right, outer y cross

Con las tablas del ejemplo, 3 clientes (ids 1, 2 y 3) y 4 pedidos (ids 1, 1, 3 y 4):

`how`	Qué filas conserva	Filas del resultado
`"inner"`	Solo las claves que están en las dos tablas	3
`"left"`	Todas las de la izquierda, con `NaN` si no hay pareja	4
`"right"`	Todas las de la derecha, con `NaN` si no hay pareja	4
`"outer"`	Todas las de las dos tablas	5
`"cross"`	Cada fila de la izquierda con cada fila de la derecha	12

El left es el más usado, porque conserva toda tu tabla principal:

python

print(clientes.merge(pedidos, on="id", how="left"))

   id nombre  total
0   1    Ana   50.0
1   1    Ana   20.0
2   2   Luis    NaN
3   3  Marta   80.0

La columna total pasa a ser decimal porque NaN es un número decimal en pandas.

Ejemplos de merge() en pandas

Unir columnas con nombres distintos

python

ventas = pd.DataFrame({"cliente_id": [1, 3], "importe": [100, 60]})
 
resultado = clientes.merge(ventas, left_on="id", right_on="cliente_id")
print(resultado.drop(columns="cliente_id"))

   id nombre  importe
0   1    Ana      100
1   3  Marta       60

Con left_on y right_on las dos columnas clave se quedan en el resultado. Borra la que sobra con drop().

Unir por varias columnas

python

ventas = pd.DataFrame({"tienda": ["Centro", "Centro", "Norte"],
                       "mes": ["ene", "feb", "ene"],
                       "ventas": [100, 120, 90]})
gastos = pd.DataFrame({"tienda": ["Centro", "Norte"],
                       "mes": ["ene", "ene"],
                       "gastos": [40, 30]})
 
print(ventas.merge(gastos, on=["tienda", "mes"], how="left"))

   tienda  mes  ventas  gastos
0  Centro  ene     100    40.0
1  Centro  feb     120     NaN
2   Norte  ene      90    30.0

Columnas repetidas: _x, _y y suffixes

python

precios_2025 = pd.DataFrame({"producto": ["Café", "Té"], "precio": [2.5, 2.0]})
precios_2026 = pd.DataFrame({"producto": ["Café", "Té"], "precio": [2.8, 2.1]})
 
print(precios_2025.merge(precios_2026, on="producto", suffixes=("_2025", "_2026")))

  producto  precio_2025  precio_2026
0     Café          2.5          2.8
1       Té          2.0          2.1

Sin suffixes, las columnas se llamarían precio_x y precio_y.

Saber de qué tabla viene cada fila

python

todo = clientes.merge(pedidos, on="id", how="left", indicator=True)
 
sin_pedidos = todo[todo["_merge"] == "left_only"]
print(sin_pedidos)

   id nombre  total     _merge
2   2   Luis    NaN  left_only

indicator=True añade la columna _merge con both, left_only o right_only. Es la forma más rápida de encontrar registros sin pareja.

Unir por el índice

python

clientes_idx = clientes.set_index("id")
ciudades = pd.DataFrame({"ciudad": ["Madrid", "Lima"]}, index=[1, 3])
 
print(clientes_idx.join(ciudades))

   nombre  ciudad
id
1     Ana  Madrid
2    Luis     NaN
3   Marta    Lima

join() une por el índice y hace un left por defecto. Con merge() obtienes lo mismo usando left_index=True y right_index=True.

Carrera · Ingeniería de IA

Ya unes tus tablas, ahora crea algo con tus datos

De cero a AI Engineer junior: Python, datos, agentes de IA y RAG con mentores y proyectos reales.

Quiero más información Ver el programa

Comprueba la relación con validate

Si esperas que cada cliente aparezca una sola vez en la otra tabla, validate lo comprueba y para el código si no se cumple:

python

clientes.merge(pedidos, on="id", validate="one_to_one")
# MergeError: Merge keys are not unique in right dataset; not a one-to-one merge

Con validate="one_to_many" el mismo merge funciona, porque un cliente puede tener muchos pedidos. Úsalo para detectar duplicados antes de que te multipliquen las filas.

merge() frente a join() y concat()

Método	Cómo une	Úsalo para
`merge()`	Por columnas clave, como un JOIN de SQL	Combinar tablas relacionadas, como clientes y pedidos
`join()`	Por el índice, `left` por defecto	Añadir columnas de otra tabla con el mismo índice
`concat()`	Pega tablas una debajo de otra o una al lado de otra	Juntar archivos con las mismas columnas, como ventas de varios meses

Si quieres apilar DataFrames en lugar de cruzarlos, mira cómo usar concat() en pandas.

merge() y los JOIN de SQL

pandas	SQL
`how="inner"`	`INNER JOIN`
`how="left"`	`LEFT JOIN`
`how="right"`	`RIGHT JOIN`
`how="outer"`	`FULL OUTER JOIN`
`how="cross"`	`CROSS JOIN`

Usa merge() con IA

Un asistente como ChatGPT, Claude o GitHub Copilot escribe el merge() correcto en segundos si le das las columnas reales y el resultado que esperas. Estos tres prompts están listos para copiar.

1. Escribe el merge() para tus tablas

Tengo dos DataFrames de pandas:
df1 con columnas [pega df1.columns] y df2 con columnas [pega df2.columns].
Quiero [todas las filas de df1 con los datos de df2 / solo las que coinciden / encontrar las de df1 sin pareja].
Escribe el merge() y explícame qué how usas y por qué.

2. Arregla un merge() con filas de más o con NaN

Mi merge() devuelve [más filas de las esperadas / columnas llenas de NaN / un DataFrame vacío]:
[pega tu código y df1.head(), df2.head() y df1.dtypes, df2.dtypes]
Explícame la causa y dame la corrección.

3. Tradúcelo desde SQL

Convierte esta consulta SQL a pandas con merge(): [pega tu consulta]
Explícame cada parámetro.

Comprueba siempre el resultado con len(), head() e indicator=True antes de seguir trabajando con los datos.

Aprende con un mentor

De combinar DataFrames a aplicaciones con IA

En la carrera de Ingeniería de IA de 4Geeks empiezas sin experiencia y terminas con agentes de IA y sistemas RAG en tu portafolio.

Habla con un asesor Ver el programa

Errores comunes con merge()

Lo que ves	Por qué pasa	Solución
`KeyError: 'id'`	La columna no existe en una de las tablas, se llama distinto o tiene espacios	Revisa `df.columns` y usa `left_on` y `right_on`
`ValueError: You are trying to merge on int64 and str columns for key 'id'`	La clave es número en una tabla y texto en la otra (en pandas 2 dice `object`)	Iguala los tipos con `astype(int)` o `astype(str)`
El resultado tiene muchas más filas	Hay claves repetidas en las dos tablas y cada combinación crea una fila	Quita duplicados con `drop_duplicates()` o usa `validate`
Columnas `_x` y `_y`	Las dos tablas tienen columnas con el mismo nombre que no son clave	Usa `suffixes` o quédate solo con las columnas que necesitas
Muchos `NaN` tras un `left`	Las claves no coinciden, por ejemplo por espacios o mayúsculas	Limpia con `df["clave"].str.strip().str.lower()` y revisa con `indicator=True`
El resultado está vacío	Con `inner`, ninguna clave coincide	Comprueba tipos y valores, o usa `how="left"` para ver qué falla
`MergeError: Merge keys are not unique...`	`validate` encontró duplicados donde no los esperabas	Revisa la tabla con `df[df.duplicated("id", keep=False)]`

Guías relacionadas

Descarga gratis

pandas merge(), en una chuleta de 2 páginas

Los tipos de unión y su equivalencia en SQL, los parámetros clave, recetas listas para copiar, los errores más comunes y prompts para ChatGPT, Claude o Copilot. Gratis, en PDF.

Chuleta: pandas merge()

2 páginas · PDF · 4Geeks

inner, left, right, outer y cross con su JOIN de SQL
Recetas para claves distintas, sufijos, índices y filas sin pareja
Los 6 errores más comunes y prompts para resolverlos con IA

Consíguela gratis

Tu PDF al instante

Preguntas frecuentes sobre pandas merge()

¿Quieres pasar de analizar datos con pandas a crear aplicaciones con IA, con proyectos reales y mentores?

Ver la carrera de Ingeniería de IA