Alineación y reindexación de índices
Alinee dos DataFrames con un índice común mediante reindex(), complete las etiquetas faltantes y comprenda cómo las operaciones aritméticas alinean los índices.
Alineación y reindexación de índices es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 3 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.
Cómo alinea Pandas los índices
Uno de los comportamientos más potentes —y, en ocasiones, sorprendentes— de Pandas es la alineación automática de índices. Cuando suma, resta o combina de cualquier otra forma dos Series o DataFrame, Pandas los alinea primero según las etiquetas de sus índices antes de realizar la operación. Las etiquetas coincidentes se procesan entre sí; las etiquetas que no coinciden producen NaN. Esto evita errores silenciosos causados por datos desalineados y permite combinar de forma segura datos de distintos orígenes sin tener que ordenarlos o reordenarlos manualmente.
import pandas as pd
s1 = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
s2 = pd.Series([1, 2, 3], index=['b', 'c', 'd'])
# Alignment in action: a→NaN, d→NaN
result = s1 + s2
print('s1 + s2 with automatic alignment:')
print(result)NaN debido a índices desalineados
Cuando las etiquetas de los índices no coinciden, Pandas rellena las entradas que faltan con NaN. Esto es intencionado: indica que «no había ningún valor correspondiente en uno de los operandos». Compruebe siempre el resultado de las operaciones aritméticas entre dos Series o DataFrame para detectar valores NaN inesperados; son una señal de desalineación de índices. Use fill_value=0 en el método aritmético (s1.add(s2, fill_value=0)) para tratar los valores alineados que faltan como cero en lugar de propagar NaN.
import pandas as pd
s1 = pd.Series({'a': 10, 'b': 20, 'c': 30})
s2 = pd.Series({'b': 1, 'c': 2, 'd': 3})
# Default: NaN where labels don't match
print('Default (NaN for unmatched):')
print(s1 + s2)
# fill_value=0: treat missing as zero
print('\nWith fill_value=0:')
print(s1.add(s2, fill_value=0))Alineación aritmética de DataFrame
La alineación se aplica tanto a las filas como a las columnas al combinar dos DataFrame. El resultado contiene la unión de ambos conjuntos de índices y de ambos conjuntos de columnas, con NaN donde cualquiera de los dos DataFrame no tenía un valor. Esto equivale a una combinación externa completa sobre los índices y las columnas simultáneamente. Esto significa que puede sumar de forma segura DataFrame de distintos periodos fiscales: los meses que existan en uno, pero no en el otro, reciben NaN, que después puede rellenar o eliminar.
import pandas as pd
df1 = pd.DataFrame({'revenue': [100, 200], 'cost': [80, 150]}, index=['Jan', 'Feb'])
df2 = pd.DataFrame({'revenue': [120, 210], 'headcount': [5, 6]}, index=['Feb', 'Mar'])
result = df1 + df2
print('Combined DataFrame (union of index and columns):')
print(result)El método reindex()
df.reindex(new_index) devuelve un DataFrame nuevo adaptado a la lista de etiquetas new_index. Las etiquetas que existen tanto en el índice original como en el nuevo se conservan; las etiquetas que están en new_index pero no en el original reciben NaN; las etiquetas del original que no están en new_index se eliminan. Esta es la forma explícita de alinear un DataFrame con un conjunto de etiquetas de destino antes de realizar operaciones.
import pandas as pd
s = pd.Series({'a': 10, 'b': 20, 'c': 30})
# Reindex to a new label set
reindexed = s.reindex(['b', 'c', 'd', 'e'])
print('Original:', s.index.tolist())
print('New index: [b, c, d, e]')
print('\nReindexed Series:')
print(reindexed)
# b, c preserved; d, e → NaN; a droppedRelleno de valores ausentes después de reindexar
reindex() acepta un parámetro fill_value para sustituir las etiquetas nuevas por una constante y un parámetro method para el relleno hacia delante ('ffill') o hacia atrás ('bfill'). Estos métodos de relleno resultan especialmente útiles para datos de series temporales cuando reindexa una Series con un intervalo completo de fechas y desea rellenar los días que faltan con el último valor conocido en lugar de NaN.
import pandas as pd
# Sparse daily data with gaps
s = pd.Series(
[10, 20, 30],
index=pd.to_datetime(['2024-01-01', '2024-01-03', '2024-01-07'])
)
# Reindex to complete date range
full_range = pd.date_range('2024-01-01', '2024-01-07')
print('Forward fill (carry last known value):')
print(s.reindex(full_range, method='ffill'))
print('\nFill with 0:')
print(s.reindex(full_range, fill_value=0))Reindexado de columnas
reindex también funciona con columnas: df.reindex(columns=['col1', 'col2', 'new_col']). Las columnas nuevas que no existen en el DataFrame original se añaden con NaN. Las columnas existentes que no aparecen en la lista nueva se eliminan. Esto resulta útil para imponer un esquema de columnas canónico en varios DataFrame procedentes de distintos orígenes que pueden tener conjuntos de columnas incoherentes.
import pandas as pd
df = pd.DataFrame({
'name': ['Alice', 'Bob'],
'age': [30, 25],
'city': ['NY', 'LA']
})
# Enforce a canonical column order and add missing columns
canonical_cols = ['name', 'age', 'email', 'city', 'country']
df_reindexed = df.reindex(columns=canonical_cols)
print(df_reindexed)
# 'email' and 'country' are new → NaNUso de align() para sincronizar dos objetos
s1.align(s2) devuelve dos objetos nuevos con el mismo índice (la unión o la intersección, según el parámetro join), de modo que están preparados para realizar operaciones elemento a elemento. Esto equivale a reindexar simultáneamente ambos objetos con el mismo conjunto de etiquetas. Use join='inner' para conservar solo las etiquetas comunes o join='outer' (valor predeterminado) para conservar todas las etiquetas de ambos objetos, con NaN donde no coincidan.
import pandas as pd
s1 = pd.Series({'a': 10, 'b': 20, 'c': 30})
s2 = pd.Series({'b': 1, 'c': 2, 'd': 3})
# Align to common labels only (inner join)
s1_aligned, s2_aligned = s1.align(s2, join='inner')
print('Inner-aligned s1:')
print(s1_aligned)
print('Inner-aligned s2:')
print(s2_aligned)
print('\nProduct on common labels:')
print(s1_aligned * s2_aligned)Alineación en merge frente a operaciones aritméticas
Pandas ofrece dos enfoques para combinar DataFrame: merge/join (al estilo de SQL, con coincidencia explícita de claves) y operaciones aritméticas con alineación de índices (implícitas y basadas en etiquetas). Use merge cuando combine tablas estructuradas con columnas de claves explícitas. Use la alineación aritmética al realizar cálculos entre DataFrame que deban compartir naturalmente un índice; por ejemplo, al restar un DataFrame de costes de un DataFrame de ingresos, ambos indexados por (region, month).
import pandas as pd
# Two DataFrames sharing the same index
revenue = pd.Series({'North': 500, 'South': 300, 'East': 450})
costs = pd.Series({'North': 350, 'South': 280, 'West': 400})
# Automatic alignment: 'East' and 'West' don't match → NaN
profit = revenue - costs
print('Profit by region:')
print(profit)
# If you want only common regions
profit_inner = revenue.align(costs, join='inner')[0] - revenue.align(costs, join='inner')[1]
print('\nProfit (common regions only):')
print(profit_inner)Comprobación de la igualdad de índices antes de las operaciones
Antes de realizar operaciones sobre dos DataFrame, compruebe si sus índices coinciden con (df1.index == df2.index).all(). Si los índices solo difieren en el orden, ordene ambos antes de compararlos. Para DataFrame cargados desde distintos orígenes, es recomendable alinearlos o reindexarlos explícitamente antes de realizar operaciones aritméticas, con el fin de evitar la propagación accidental de NaN. Documente cualquier suposición sobre la alineación en los comentarios o en los registros del flujo de datos.
import pandas as pd
df1 = pd.DataFrame({'sales': [100, 200, 300]}, index=['Q1', 'Q2', 'Q3'])
df2 = pd.DataFrame({'cost': [80, 160, 240]}, index=['Q1', 'Q2', 'Q3'])
# Check index equality
if (df1.index == df2.index).all():
print('Indices match — safe to combine.')
combined = pd.concat([df1, df2], axis=1)
combined['profit'] = combined['sales'] - combined['cost']
print(combined)
else:
print('Indices differ — align before combining!')Patrón práctico: estandarización de formas
Un patrón habitual al cargar datos desde varios archivos o llamadas a API es que cada lote abarque un subconjunto distinto de claves. Antes de concatenar o agregar, reindexe todos los lotes con el conjunto completo de claves conocido usando fill_value=0. Esto garantiza que todos los lotes tengan la misma forma (los mismos índices y las mismas columnas) antes de realizar operaciones, y evita discrepancias silenciosas de forma que provoquen resultados agregados incorrectos.
import pandas as pd
# Two sales batches with different product sets
batch1 = pd.Series({'laptop': 50, 'phone': 80, 'tablet': 30})
batch2 = pd.Series({'phone': 90, 'tablet': 40, 'headphones': 60})
# Full product catalogue
all_products = ['laptop', 'phone', 'tablet', 'headphones']
# Standardise both to the full catalogue
b1 = batch1.reindex(all_products, fill_value=0)
b2 = batch2.reindex(all_products, fill_value=0)
total = b1 + b2
print('Total sales per product:')
print(total)Casos extremos de alineación de índices
Hay dos casos extremos importantes: Etiquetas duplicadas — si ambas Series tienen etiquetas de índice duplicadas, la alineación produce una expansión similar a un producto cartesiano con muchos valores NaN (Pandas no asume qué duplicados corresponden entre sí). Asegúrese siempre de que los índices sean únicos antes de realizar una alineación aritmética. Índices enteros frente a índices de tipo object — un RangeIndex(0,5) y un Int64Index([0,1,2,3,4]) podrían no alinearse perfectamente después de algunas operaciones, porque uno se infiere y el otro se especifica explícitamente. Use reset_index(drop=True) para normalizarlos.
import pandas as pd
# Duplicate label alignment — produces unexpected expansion
s1 = pd.Series([1, 2, 3], index=['a', 'a', 'b'])
s2 = pd.Series([10, 20], index=['a', 'b'])
result = s1 + s2
print('Result with duplicate indices (unexpected expansion):')
print(result)
print('\nAlways ensure unique indices before arithmetic!')Comprobación rápida
Compruebe su comprensión de la alineación y el reindexado de índices explicados en esta lección.
Resumen de la lección
En esta lección ha aprendido que Pandas realiza una alineación automática de índices en las operaciones aritméticas y produce NaN para las etiquetas que no coinciden; reindex() adapta un DataFrame a un conjunto de etiquetas de destino, con opciones de relleno para las etiquetas ausentes; y align() sincroniza dos objetos con el mismo índice simultáneamente. A continuación, exploraremos las ventajas de rendimiento de los índices ordenados y cómo medirlas con timeit.
Preguntas frecuentes
¿La lección «Alineación y reindexación de índices» es gratis?
Sí — el texto completo de «Alineación y reindexación de índices» 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 «Alineación y reindexación de índices»?
Alinee dos DataFrames con un índice común mediante reindex(), complete las etiquetas faltantes y comprenda cómo las operaciones aritméticas alinean los índices. 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 3 de 4.
¿Cuánto tiempo toma la lección «Alineación y reindexación de índices»?
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
- Crear un MultiIndex
- Seleccionar datos de un MultiIndex
- Alineación y reindexación de índices
- Ventajas de rendimiento de los índices ordenados