0Pricing
Pandas & NumPy Academy · Lección

Unir por el índice

Use DataFrame.join() y establezca left_index/right_index=True en merge() para combinar DataFrames alineados por su índice.

Unir por el índice es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 4 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.

Combinaciones basadas en índices

Hasta ahora ha combinado DataFrames haciendo coincidir valores de columnas normales. Sin embargo, a veces la información que desea usar para hacer la correspondencia se almacena en el índice del DataFrame y no en una columna. Pandas admite combinaciones basadas en índices mediante DataFrame.join() y mediante pd.merge() con los parámetros left_index=True o right_index=True.

Método DataFrame.join()

DataFrame.join(other) es un método auxiliar que, de forma predeterminada, combina mediante el índice de ambos DataFrames. Equivale a una llamada a pd.merge() con left_index=True, right_index=True. El tipo de combinación predeterminado es 'left', a diferencia de pd.merge(), cuyo valor predeterminado es 'inner'. Ambos DataFrames deben compartir etiquetas de índice significativas para que la combinación produzca resultados correctos.

import pandas as pd

profiles = pd.DataFrame(
    {'age': [25, 30, 22]},
    index=['alice', 'bob', 'carol']
)

scores = pd.DataFrame(
    {'score': [88, 95, 70]},
    index=['alice', 'carol', 'dave']
)

# join: left join on index (default)
result = profiles.join(scores)
print(result)
#        age  score
# alice   25   88.0
# bob     30    NaN   <- bob has no score
# carol   22   95.0

Controlar el tipo de combinación en join()

Pase el parámetro how a join() para controlar qué filas se conservan, igual que con pd.merge(). Las opciones son 'left' (predeterminada), 'right', 'inner' y 'outer'. Por ejemplo, how='inner' conserva únicamente los índices que aparecen en ambos DataFrames y descarta la fila de alice si no tuviera un índice coincidente en la tabla derecha.

# Inner join on index: only rows present in BOTH indices
print(profiles.join(scores, how='inner'))
#        age  score
# alice   25     88
# carol   22     70

# Outer join: all indices from both
print(profiles.join(scores, how='outer'))
#        age  score
# alice  25.0   88.0
# bob    30.0    NaN
# carol  22.0   70.0
# dave    NaN   95.0

Combinar varios DataFrames a la vez

Una ventaja importante de join() frente a pd.merge() es que acepta una lista de DataFrames y los combina todos con el objeto que realiza la llamada en una sola operación. Todos los DataFrames deben estar alineados por índice. Esto resulta muy práctico cuando tiene muchas tablas de características indexadas por la misma clave, como el identificador de usuario o la fecha, y desea ensamblarlas en un único DataFrame ancho.

emails = pd.DataFrame({'email': ['a@x.com', 'b@x.com', 'c@x.com']},
                      index=['alice', 'bob', 'carol'])
city  = pd.DataFrame({'city': ['NY', 'LA', 'SF']},
                     index=['alice', 'bob', 'carol'])

# Join multiple DataFrames at once
result = profiles.join([emails, city])
print(result)
#        age    email city
# alice   25  a@x.com   NY
# bob     30  b@x.com   LA
# carol   22  c@x.com   SF

Combinar usando una columna en una tabla y el índice en otra

pd.merge() permite combinar coincidencias basadas en columnas y en índices mediante left_on/right_index o left_index/right_on. Esto resulta útil cuando un DataFrame almacena la clave en una columna, pero el otro la utiliza como índice. No puede conseguirlo usando únicamente join().

# orders has customer_id as a column; customers is indexed by customer_id
customers_indexed = pd.DataFrame(
    {'name': ['Alice', 'Bob', 'Carol']},
    index=[101, 102, 103]
)
orders = pd.DataFrame({
    'order_id': [1, 2, 3],
    'customer_id': [101, 102, 101]
})

result = pd.merge(orders, customers_indexed,
                  left_on='customer_id', right_index=True)
print(result)
#    order_id  customer_id   name
# 0         1          101  Alice
# 2         3          101  Alice
# 1         2          102    Bob

Uso de left_index y right_index en merge()

Cuando ambos DataFrames tienen la clave como índice, utilice pd.merge(left, right, left_index=True, right_index=True). Esto equivale a join(), pero con el tipo de unión predeterminado 'inner' y parámetros más explícitos. También obtiene acceso a todos los demás parámetros de pd.merge(), como suffixes e indicator.

# Both DataFrames indexed by user_id
demog = pd.DataFrame({'age': [25, 30]}, index=[1, 2])
behav = pd.DataFrame({'clicks': [10, 5]}, index=[1, 2])

# Equivalent joins
result1 = demog.join(behav)  # left join
result2 = pd.merge(demog, behav, left_index=True, right_index=True)  # inner join

print(result1)
print(result2)

¿Por qué utilizar uniones basadas en índices?

Las uniones basadas en índices son preferibles cuando sus DataFrames tienen de forma natural una clave identificada por un valor significativo, como el ID de un usuario, el SKU de un producto o una fecha. Utilizar el índice para las uniones evita llenar el DataFrame de columnas de clave redundantes y puede ser más rápido, ya que Pandas mantiene estructuras de índices ordenadas para realizar búsquedas en O(log n). Son especialmente habituales en datos de series temporales, donde el DatetimeIndex es la clave natural de unión.

# Time series example: join temperature and humidity by date index
import numpy as np
dates = pd.date_range('2024-01-01', periods=5)
temp = pd.DataFrame({'temp_c': [10, 12, 9, 11, 13]}, index=dates)
humid = pd.DataFrame({'humidity': [65, 70, 60, 75, 68]}, index=dates)

weather = temp.join(humid)
print(weather.head())

Gestión de nombres de columnas coincidentes

Cuando ambos DataFrames tienen columnas con el mismo nombre (excepto la clave), join() genera un ValueError de forma predeterminada, a menos que proporcione los parámetros lsuffix y rsuffix. Estos parámetros funcionan como suffixes en pd.merge(): añaden una cadena al nombre de las columnas coincidentes de los DataFrames izquierdo y derecho, respectivamente.

df_a = pd.DataFrame({'value': [1, 2]}, index=['x', 'y'])
df_b = pd.DataFrame({'value': [10, 20]}, index=['x', 'y'])

# Without suffixes: raises ValueError
# result = df_a.join(df_b)

# With suffixes: disambiguate column names
result = df_a.join(df_b, lsuffix='_left', rsuffix='_right')
print(result)
#    value_left  value_right
# x           1           10
# y           2           20

set_index antes de unir

Un flujo de trabajo habitual consiste en establecer una columna como índice antes de realizar la unión, para poder utilizar la sintaxis de join(). Después de la unión, reset_index() devuelve la clave como una columna normal. Este patrón resulta natural: convertir la clave en índice, unir y volver a convertirla en una columna, lo que deja clara la intención para quienes lean su código posteriormente.

orders_col = pd.DataFrame({'order_id': [1,2,3], 'customer_id': [10,20,10], 'amount': [100,200,150]})
cust_col = pd.DataFrame({'customer_id': [10,20], 'name': ['Alice','Bob']})

result = (
    orders_col.set_index('customer_id')
    .join(cust_col.set_index('customer_id'), how='left')
    .reset_index()
)
print(result)

Alineación de una Series con el índice de un DataFrame

Una Series también tiene un índice, y puede añadirla como una columna nueva a un DataFrame mediante una asignación; Pandas alinea automáticamente los valores de la Series con las etiquetas de índice coincidentes. Se trata de una forma ligera de unión basada en índices, útil cuando desea añadir una sola columna de una Series sin llamar a merge() ni a join().

df = pd.DataFrame({'sales': [100, 200, 150]}, index=['A', 'B', 'C'])
tax_rate = pd.Series({'A': 0.1, 'B': 0.2, 'C': 0.15})

# Index alignment: Series aligns to DataFrame index automatically
df['tax'] = df['sales'] * tax_rate
print(df)
#    sales   tax
# A    100  10.0
# B    200  40.0
# C    150  22.5

Rendimiento de las uniones por índice

Unir mediante un índice ordenado es más rápido que hacerlo mediante una columna normal, porque Pandas utiliza una búsqueda binaria en el índice ordenado. Si va a unir repetidamente por la misma clave, establezca esa clave como índice una sola vez al principio de su flujo de trabajo. Esto es especialmente importante en flujos de trabajo de series temporales, donde se une mediante un DatetimeIndex miles de veces a través de numerosos archivos.

# Sort index before repeated joins for speed
left = left.sort_index()
right = right.sort_index()

# Both sorted -> Pandas uses merge path with binary search
result = left.join(right, how='inner')

# Check if index is sorted
print('Left sorted:', left.index.is_monotonic_increasing)
print('Right sorted:', right.index.is_monotonic_increasing)

Comprobación rápida

Compruebe cuánto ha entendido de las uniones basadas en índices de esta lección.

Resumen de la lección

En esta lección ha aprendido lo siguiente: DataFrame.join() une por el índice de forma predeterminada mediante una unión izquierda; pd.merge() con left_index=True/right_index=True ofrece más control; puede unir varios DataFrames a la vez pasando una lista a join(); y utilizar un índice ordenado mejora el rendimiento de las uniones. A continuación, exploraremos cómo cambiar la forma de los DataFrames con pivot_table.

Preguntas frecuentes

¿La lección «Unir por el índice» es gratis?

Sí — el texto completo de «Unir por el índice» 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 «Unir por el índice»?

Use DataFrame.join() y establezca left_index/right_index=True en merge() para combinar DataFrames alineados por su índice. 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 4 de 4.

¿Cuánto tiempo toma la lección «Unir por el índice»?

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

  1. pd.concat para apilar DataFrames
  2. pd.merge: joins internos y externos
  3. Joins izquierdo y derecho
  4. Unir por el índice
← Volver a Pandas & NumPy Academy