0Pricing
Pandas & NumPy Academy · Lección

pd.concat para apilar DataFrames

Apile DataFrames vertical u horizontalmente con pd.concat, alinéelos por índice o columnas y gestione los índices duplicados.

pd.concat para apilar DataFrames es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 1 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.

¿Por qué concatenar DataFrames?

En los proyectos reales, los datos rara vez llegan en un único archivo. Puede tener archivos de ventas mensuales, exportaciones de encuestas regionales o resultados de consultas a bases de datos divididos en varias consultas. La concatenación apila estos DataFrames independientes en una sola tabla combinada. Pandas proporciona pd.concat() para este fin y permite apilar tanto verticalmente, por filas, como horizontalmente, por columnas.

Concatenación vertical básica

El uso más habitual de pd.concat() consiste en apilar DataFrames verticalmente, es decir, añadir más filas. Pase una lista de DataFrames y la función los añadirá uno debajo de otro. Ambos DataFrames deben tener columnas compatibles para obtener un resultado limpio. Pandas los alinea automáticamente según los nombres de las columnas y rellena con NaN las columnas que falten.

import pandas as pd

jan = pd.DataFrame({'product': ['A', 'B'], 'sales': [100, 200]})
feb = pd.DataFrame({'product': ['A', 'C'], 'sales': [150, 120]})

combined = pd.concat([jan, feb])
print(combined)
#   product  sales
# 0       A    100
# 1       B    200
# 0       A    150
# 1       C    120

Restablecer el índice después de concat

Observe que pd.concat() conserva los índices originales de cada DataFrame, lo que puede producir valores de índice duplicados, como ocurre arriba con dos filas en el índice 0 y dos en el índice 1. Pase ignore_index=True para crear un índice entero secuencial nuevo en el resultado combinado, que es casi siempre lo que desea.

combined = pd.concat([jan, feb], ignore_index=True)
print(combined)
#   product  sales
# 0       A    100
# 1       B    200
# 2       A    150
# 3       C    120

print(combined.index)
# RangeIndex(start=0, stop=4, step=1)

Rastrear el origen con keys

Al concatenar datos de varias fuentes, es posible que quiera saber de qué DataFrame original procede cada fila. Pase el parámetro keys con una lista de etiquetas. Pandas crea un MultiIndex cuyo nivel externo identifica la fuente. Después puede usar .loc['label'] para acceder a las filas de una fuente específica.

combined = pd.concat([jan, feb], keys=['January', 'February'])
print(combined)
#                product  sales
# January   0         A    100
#           1         B    200
# February  0         A    150
#           1         C    120

# Access only February rows
print(combined.loc['February'])

Concatenación horizontal con axis=1

Pase axis=1 para concatenar DataFrames uno al lado del otro, es decir, añadir más columnas. Pandas los alinea según el índice de las filas, por lo que ambos DataFrames deberían tener el mismo índice para obtener un resultado limpio. Si los índices difieren, las filas que no coincidan se rellenarán con NaN. Esto resulta útil para combinar características calculadas a partir del mismo conjunto de datos en pasos separados.

names = pd.DataFrame({'name': ['Alice', 'Bob', 'Carol']}, index=[1, 2, 3])
scores = pd.DataFrame({'score': [95, 88, 72]}, index=[1, 2, 3])

combined = pd.concat([names, scores], axis=1)
print(combined)
#     name  score
# 1  Alice     95
# 2    Bob     88
# 3  Carol     72

Gestionar columnas no coincidentes

Si los DataFrames que se van a concatenar tienen columnas diferentes, Pandas conserva todas las columnas y rellena con NaN los valores que falten. Este es el comportamiento predeterminado de join='outer'. Si quiere conservar únicamente las columnas que aparecen en todos los DataFrames, pase join='inner', que elimina cualquier columna que no esté presente en todas las fuentes.

df1 = pd.DataFrame({'a': [1, 2], 'b': [3, 4]})
df2 = pd.DataFrame({'b': [5, 6], 'c': [7, 8]})

# Outer join (default): keeps all columns
print(pd.concat([df1, df2], ignore_index=True))
#      a  b    c
# 0  1.0  3  NaN
# 1  2.0  4  NaN
# 2  NaN  5  7.0
# 3  NaN  6  8.0

# Inner join: keeps only shared columns
print(pd.concat([df1, df2], join='inner', ignore_index=True))
#    b
# 0  3
# 1  4
# 2  5
# 3  6

Concatenar muchos archivos en un bucle

Un patrón habitual al cargar varios archivos consiste en recopilar todos los DataFrames en una lista y llamar a pd.concat() una sola vez al final. Evite concatenar dentro de un bucle, por ejemplo, df = pd.concat([df, new_chunk]), porque esto crea una nueva copia del DataFrame en cada iteración y provoca una complejidad temporal cuadrática en colecciones grandes.

import glob

# Efficient: collect first, concat once
files = glob.glob('data/sales_*.csv')
frames = [pd.read_csv(f) for f in files]
combined = pd.concat(frames, ignore_index=True)

# Inefficient (avoid):
# result = pd.DataFrame()
# for f in files:
#     result = pd.concat([result, pd.read_csv(f)])  # slow!

Concatenar Series

pd.concat() funciona tanto con Series como con DataFrames. Al concatenar verticalmente una lista de Series se obtiene una Series más larga. Concatenar con axis=1 produce un DataFrame en el que cada Series se convierte en una columna. Las Series se alinean según su índice, por lo que las etiquetas del índice deben coincidir para obtener una concatenación horizontal limpia.

s1 = pd.Series([1, 2, 3], name='x')
s2 = pd.Series([4, 5, 6], name='y')

# Vertical: one long Series
print(pd.concat([s1, s2]))
# 0    1
# 1    2
# ...

# Horizontal: a DataFrame with two columns
print(pd.concat([s1, s2], axis=1))
#    x  y
# 0  1  4
# 1  2  5
# 2  3  6

Verificar el resultado concatenado

Después de concatenar, verifique siempre que el resultado tenga la forma esperada y que no contenga valores NaN inesperados. Un patrón rápido de comprobación consiste en comparar el número de filas combinadas con la suma de los recuentos individuales y llamar a isna().sum() para detectar valores ausentes no deseados introducidos por una desalineación de columnas. Estas comprobaciones evitan que problemas silenciosos de calidad de datos se propaguen al análisis.

combined = pd.concat([jan, feb], ignore_index=True)

# Sanity checks
assert len(combined) == len(jan) + len(feb), 'Row count mismatch'
print('Missing values per column:')
print(combined.isna().sum())
print('Shape:', combined.shape)

concat frente a append (en desuso)

El código antiguo de Pandas puede usar df.append(other), que era un envoltorio práctico de pd.concat(). Este método quedó obsoleto en Pandas 1.4 y se eliminó en Pandas 2.0. En el código moderno, use siempre pd.concat([df, other], ignore_index=True). El comportamiento es idéntico, pero pd.concat es más explícito y permite concatenar más de dos DataFrames a la vez.

# Old (removed in Pandas 2.0):
# combined = jan.append(feb, ignore_index=True)

# Modern equivalent:
combined = pd.concat([jan, feb], ignore_index=True)
print(combined)

Ejemplo práctico: informe anual de ventas

Este es un patrón realista: cargar DataFrames mensuales, añadir una etiqueta de origen, concatenarlos y calcular un resumen de todo el año. El parámetro keys facilita rastrear cada fila hasta su mes, y la combinación de ignore_index=True con una columna del mes proporciona un DataFrame plano y limpio para realizar análisis mediante agrupaciones.

months = ['jan', 'feb', 'mar']
frames = []
for m in months:
    df = pd.DataFrame({'product': ['A', 'B'], 'sales': [100, 200]})
    df['month'] = m
    frames.append(df)

yearly = pd.concat(frames, ignore_index=True)
print(yearly.groupby('month')['sales'].sum())

Comprobación rápida

Compruebe cuánto ha entendido de pd.concat para apilar DataFrames en esta lección.

Resumen de la lección

En esta lección ha aprendido a apilar DataFrames verticalmente con pd.concat() e ignore_index=True, a realizar el seguimiento de las fuentes mediante el parámetro keys y a entender cómo join='inner' frente a 'outer' controla el tratamiento de las columnas cuando los esquemas difieren. A continuación exploraremos pd.merge() para realizar joins internos y externos al estilo de SQL sobre columnas de clave compartidas.

Preguntas frecuentes

¿La lección «pd.concat para apilar DataFrames» es gratis?

Sí — el texto completo de «pd.concat para apilar DataFrames» 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.concat para apilar DataFrames»?

Apile DataFrames vertical u horizontalmente con pd.concat, alinéelos por índice o columnas y gestione los índices duplicados. 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 1 de 4.

¿Cuánto tiempo toma la lección «pd.concat para apilar DataFrames»?

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