pandas melt(): la mejor forma de convertir datos en formato ancho a largo

El formato ancho se lee fácil, pero muchos análisis y visualizaciones funcionan mejor con datos en formato largo.

La función pandas.melt() reestructura un DataFrame convirtiendo una o varias columnas en filas mientras mantiene sin cambios las columnas identificadoras que elijas. Así, tus datos serán más fáciles de filtrar, agrupar, visualizar y analizar.

En este tutorial, te mostraré cómo usar pandas.melt(). También verás cómo se compara con opciones como pivot(), stack() y wide_to_long(). Si estás empezando con Python, te recomiendo nuestro curso de Introduction to Python, que cubre habilidades como tipos de datos, listas, funciones básicas y paquetes.

Cómo usar pandas.melt()

La función pandas.melt() convierte un DataFrame de formato ancho a formato largo transformando los nombres de columna en valores dentro de una nueva columna.

Su sintaxis es la siguiente:

pandas.melt(
    frame,
    id_vars=None,
    value_vars=None,
    var_name=None,
    value_name="value",
    col_level=None,
    ignore_index=True
)

Donde:

• frame: el DataFrame a reestructurar. Solo es obligatorio cuando usas pandas.melt().

• id_vars: columna o lista de columnas que se mantienen sin cambios. Estas columnas identifican cada fila tras la transformación.

• value_vars: columna o lista de columnas que se van a deshacer (unpivot). Si se omite, pandas convierte todas las columnas que no estén en id_vars.

• var_name: nombre de la nueva columna que almacena los nombres originales de las columnas. Por defecto es "variable" si no se especifica.

• value_name: nombre de la nueva columna que almacena los valores. Por defecto es "value" si no se especifica.

• col_level: opcional, especifica qué nivel fundir cuando se trabaja con columnas MultiIndex.

• ignore_index: si es True (por defecto), crea un índice secuencial nuevo. Si es False, conserva el índice original.

Veamos un ejemplo para ilustrar cómo esta sintaxis reestructura los datos.

Imagina que tienes el siguiente conjunto de datos, donde las ventas mensuales de cada producto están en columnas separadas.

Puedes usar pandas.melt() para convertir las columnas de meses en filas.

# Convertir el DataFrame de formato ancho a formato largo
products_sales_2025_melted = products_sales_2025.melt(
    # Mantener sin cambios las columnas Product y Category
    id_vars=["Product", "Category"],

    # Convertir las columnas de meses en filas
    value_vars=["January", "February", "March", "April", "May", "June"],

    # Nombre de la nueva columna que almacena los nombres originales de las columnas
    var_name="Month",

    # Nombre de la nueva columna que almacena los valores de ventas correspondientes
    value_name="Sales"
)

# Mostrar el DataFrame reestructurado
products_sales_2025_melted.head(10)

El DataFrame resultante ahora almacena cada mes como una fila independiente.

Ejemplos comunes de pandas.melt()

Ahora que ya entiendes cómo funciona la sintaxis de pandas.melt(), veamos cómo se comporta cada parámetro por separado. Usaremos la tabla anterior en los siguientes ejemplos.

Fundir columnas seleccionadas

El parámetro value_vars te permite indicar qué columnas deshacer. En lugar de fundir todos los meses, puedes convertir solo las columnas que necesites.

En este ejemplo, solo se funden las columnas January y February. El resto de meses se ignoran.

# Convertir solo las columnas de January y February en filas
product_sales_3month = products_sales_2025.melt(
    id_vars="Product",
    value_vars=["January", "February",]
)

product_sales_3month.head(20)

Mantener columnas identificadoras

Usa el parámetro id_vars para conservar una o varias columnas sin cambios mientras el resto se reestructura.

En el ejemplo siguiente, "Product" y "Category" se mantienen, mientras que las columnas de ventas mensuales se convierten en filas.

# Mantener las columnas Product y Category mientras se funden las ventas mensuales
product_sales_cat = products_sales_2025.melt(
    id_vars=["Product", "Category"]
)

product_sales_cat.head()

Renombrar las columnas de salida

Si te fijas, las columnas de salida se llaman por defecto variable y value. Usa los argumentos var_name y value_name para darles nombres más descriptivos.

Por ejemplo, hemos renombrado la columna de variables a "Month" y la de valores a "Sales" en la siguiente salida.

# Mantener las columnas Product y Category mientras se funden las ventas mensuales
# Renombrar las columnas Month y Sales
product_sales_cat = products_sales_2025.melt(
    id_vars=["Product", "Category"],
    var_name="Month",
    value_name="Sales"
)

product_sales_cat.head()

Conservar el índice original

Por defecto, pandas.melt() crea un índice secuencial nuevo. Establece ignore_index=False para mantener el índice original de las filas.

# Mantener el índice original de las filas tras la transformación
product_sales_index = products_sales_2025.melt(
    id_vars=["Product", "Category"],
    var_name="Month",
    value_name="Sales",
    ignore_index=False
)

product_sales_index.head(10)

En el ejemplo anterior, las etiquetas de fila originales (0–5) se repiten para cada mes en lugar de ser sustituidas por un índice secuencial nuevo.

¿Cuándo deberías usar pandas.melt()?

pandas.melt() es útil cuando tus datos están en formato ancho y necesitas transformarlos a formato largo para analizarlos o visualizarlos. Además, considero la función clave en estos casos de uso:

• Convertir datos anchos a formato largo: muchos datasets guardan valores relacionados en múltiples columnas. Aunque este formato se lee bien, complica el análisis. pandas.melt() combina esas columnas en una sola manteniendo las columnas identificadoras, creando una estructura más limpia para seguir trabajando.

• Preparar datos para gráficas: muchas librerías de gráficos, como Seaborn, funcionan mejor con datos en formato largo. En lugar de combinar columnas a mano, usa pandas.melt() para darles el formato que esperan.

• Preparar datos para análisis estadístico: muchas operaciones de pandas, como groupby(), agregaciones, filtrados y estadísticas resumen, son más sencillas cuando las medidas están en una sola columna en lugar de repartidas. Si reestructuras con pandas.melt(), reduces el código necesario para analizar distintas variables.

• Crear datasets ordenados (tidy): un dataset ordenado guarda cada variable en su propia columna y cada observación en su propia fila. Si tu dataset contiene medidas repetidas en varias columnas, pandas.melt() suele ser la vía más rápida para convertirlo a un formato ordenado.

Te recomiendo nuestro curso Introduction to Data Visualization with Seaborn para aprender a crear y personalizar distintos tipos de gráficos en Python, incluidos de dispersión, recuento, barras y cajas.

pandas.melt() frente a otras funciones de reestructuración

Pandas ofrece varias funciones para reestructurar datos, cada una con un propósito distinto. Veamos en qué se diferencian.

pandas.melt() vs. pivot()

La tabla siguiente muestra la diferencia entre las funciones pandas.melt() y pivot().

Por lo tanto, elige melt() cuando tus medidas estén repartidas en varias columnas o pivot() cuando quieras expandir valores de fila en columnas.

pandas.melt() vs. stack()

Aunque ambas funciones reestructuran datos, así es como se diferencian.

Puedes usar stack() cuando necesites trabajar con índices jerárquicos o objetos MultiIndex.

pandas.melt() vs. wide_to_long()

Ambas funciones convierten datos anchos a formato largo, pero están pensadas para situaciones distintas, como verás a continuación.

Si tu dataset tiene nombres de columna irregulares, usa melt(). Si tus columnas siguen una convención predecible, usa wide_to_long() para reestructurar con menos código.

Errores comunes con pandas.melt()

Aunque pandas.melt() es fácil de usar, estos son los fallos más habituales que me he encontrado y cómo solucionarlos.

• Olvidar id_vars: si no especificas id_vars, pandas trata como columnas de valores todas las que no estén en value_vars. Esto puede transformar columnas que querías mantener como identificadores. Para evitarlo, identifica siempre las columnas que describen de forma única cada registro y pásalas a id_vars.

• Fundir columnas no deseadas: si omites value_vars, pandas funde todas las columnas que no están en id_vars. Esto puede incluir columnas que no pretendías reestructurar. Por tanto, especifica value_vars siempre que quieras fundir solo un subconjunto.

• Malinterpretar la forma de salida: tras fundir, el número de filas aumenta porque cada columna seleccionada pasa a ser una fila independiente por registro. Por ejemplo, un DataFrame con 10 filas y 12 columnas de meses producirá 120 filas tras fundir los meses. Revisa siempre la forma antes y después para confirmar que la transformación es correcta.

• Confundir formatos ancho y largo: recuerda que en formato ancho los valores similares se reparten por varias columnas; en formato largo, esos valores están en una sola columna y otra columna identifica la variable.

Buenas prácticas al usar pandas.melt()

Para que tu código de reestructuración sea más claro y mantenible, te recomiendo seguir estas buenas prácticas cuando uses pandas.melt():

• Identifica primero las columnas identificadoras: decide qué columnas deben permanecer sin cambios y pásalas a id_vars.

• Renombra la columna generada: usa var_name y value_name en lugar de quedarte con los nombres por defecto variable y value.

• Revisa el recuento de filas tras fundir: verifica que el número de filas coincide con lo esperado, especialmente cuando fundes muchas columnas.

• Usa pivot() para volver al formato original: si necesitas restaurar el formato ancho tras el análisis, utiliza la función pivot().

Haz nuestro Writing Efficient Python Code para aprender a escribir código eficiente, fácil de depurar y mantener.

Conclusión

pandas.melt() es la función estándar de pandas para convertir datos en formato ancho a formato largo. Y cuando entiendes el papel de id_vars y value_vars, puedes controlar qué columnas permanecen como identificadoras y cuáles se convierten en filas.

Para dominar Python a fondo, puedes aprender más en nuestros itinerarios de habilidades Python Data Fundamentals y Python Programming Fundamentals.