pandas melt() : la meilleure façon de convertir des données larges en données longues

Le format large est facile à lire, mais de nombreuses tâches d’analyse et de visualisation fonctionnent mieux avec des données au format long.

La fonction pandas.melt() remodèle un DataFrame en transformant une ou plusieurs colonnes en lignes tout en conservant certaines colonnes d’identifiants. Vos données deviennent ainsi plus simples à filtrer, regrouper, visualiser et analyser.

Dans ce tutoriel, je vais vous montrer comment utiliser la fonction pandas.melt(). Je vous expliquerai aussi comment elle se compare à des options comme pivot(), stack() et wide_to_long(). Si vous débutez en Python, je vous recommande de suivre notre Introduction to Python course, qui couvre des compétences comme les types de données, les listes, les fonctions de base et les packages.

Comment utiliser pandas.melt()

La fonction pandas.melt() convertit un DataFrame du format large vers le format long en transformant les en-têtes de colonnes en valeurs dans une nouvelle colonne.

Sa syntaxe est la suivante :

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

Où :

• frame : le DataFrame à remodéler. Obligatoire uniquement lors de l’utilisation de pandas.melt().

• id_vars : colonne ou liste de colonnes à conserver telles quelles. Ces colonnes identifient chaque ligne après le remodelage.

• value_vars : colonne ou liste de colonnes à "déplier". Si omis, pandas fond toutes les colonnes qui ne sont pas dans id_vars.

• var_name : nom de la nouvelle colonne qui stocke les noms des colonnes d’origine. Par défaut, "variable" si non précisé.

• value_name : nom de la nouvelle colonne qui stocke les valeurs. Par défaut, "value" si non précisé.

• col_level : optionnel, indique quel niveau fondre lorsqu’on travaille avec des colonnes MultiIndex.

• ignore_index : si True (par défaut), crée un nouvel index séquentiel. Si False, conserve l’index d’origine.

Voici un exemple pour illustrer comment la syntaxe ci-dessus remodèle les données.

Supposons que vous disposiez du jeu de données ci-dessous, où les ventes mensuelles de chaque produit sont stockées dans des colonnes distinctes.

Vous pouvez utiliser pandas.melt() pour convertir les colonnes de mois en lignes.

# Convertir le DataFrame du format large au format long
products_sales_2025_melted = products_sales_2025.melt(
    # Conserver les colonnes Product et Category
    id_vars=["Product", "Category"],

    # Convertir les colonnes des mois en lignes
    value_vars=["January", "February", "March", "April", "May", "June"],

    # Nom de la nouvelle colonne qui stocke les noms de colonnes d'origine
    var_name="Month",

    # Nom de la nouvelle colonne qui stocke les valeurs de ventes correspondantes
    value_name="Sales"
)

# Afficher le DataFrame remodélé
products_sales_2025_melted.head(10)

Le DataFrame obtenu enregistre désormais chaque mois sur une ligne distincte.

Exemples courants avec pandas.melt()

Maintenant que vous avez compris la syntaxe de pandas.melt(), voyons comment chaque paramètre se comporte isolément. Nous utiliserons le tableau ci-dessus dans les exemples suivants.

Fondre des colonnes sélectionnées

Le paramètre value_vars vous permet de préciser quelles colonnes déployer. Plutôt que de fondre tous les mois, vous pouvez ne convertir que les colonnes nécessaires.

Dans cet exemple, seules les colonnes January et February sont fondues. Les autres colonnes de mois sont ignorées.

# Convertir uniquement les colonnes January et February en lignes
product_sales_3month = products_sales_2025.melt(
    id_vars="Product",
    value_vars=["January", "February",]
)

product_sales_3month.head(20)

Conserver les colonnes d’identifiants

Utilisez le paramètre id_vars pour conserver une ou plusieurs colonnes inchangées tandis que les autres sont remodélées.

Dans l’exemple ci-dessous, « Product » et « Category » restent inchangées, tandis que les colonnes de ventes mensuelles sont converties en lignes.

# Conserver les colonnes Product et Category tout en fondant les ventes mensuelles
product_sales_cat = products_sales_2025.melt(
    id_vars=["Product", "Category"]
)

product_sales_cat.head()

Renommer les colonnes de sortie

Par défaut, les colonnes de sortie s’appellent variable et value. Utilisez les arguments var_name et value_name pour leur donner des noms explicites.

Par exemple, nous avons renommé la colonne des variables en « Month » et celle des valeurs en « Sales » dans la sortie ci-dessous.

# Conserver les colonnes Product et Category tout en fondant les ventes mensuelles
# Renommer les colonnes Month et Sales
product_sales_cat = products_sales_2025.melt(
    id_vars=["Product", "Category"],
    var_name="Month",
    value_name="Sales"
)

product_sales_cat.head()

Préserver l’index d’origine

Par défaut, pandas.melt() crée un nouvel index séquentiel. Définissez ignore_index=False pour conserver l’index des lignes d’origine.

# Conserver l'index d'origine après le remodelage
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)

Dans l’exemple ci-dessus, les étiquettes de lignes d’origine (0–5) sont répétées pour chaque mois au lieu d’être remplacées par un nouvel index séquentiel.

Quand utiliser pandas.melt() ?

pandas.melt() est utile lorsque vos données sont au format large et doivent être converties en format long pour l’analyse ou la visualisation. Je trouve aussi la fonction précieuse dans les cas suivants :

• Convertir des données larges en format long : de nombreux jeux de données stockent des valeurs liées sur plusieurs colonnes. Si ce format est lisible, il complique souvent l’analyse. pandas.melt() regroupe ces colonnes en une seule, tout en préservant les colonnes d’identifiants, pour une structure plus claire avant traitement.

• Préparer les données pour la visualisation : de nombreuses bibliothèques de tracés, comme Seaborn, fonctionnent mieux avec des données au format long. Plutôt que de combiner manuellement plusieurs colonnes, utilisez pandas.melt() pour obtenir le format attendu.

• Préparer les données pour l’analyse statistique : de nombreuses opérations pandas, dont groupby(), les agrégations, les filtres et les statistiques descriptives, sont plus simples lorsque les mesures sont stockées dans une seule colonne plutôt que réparties sur plusieurs. Remodeler avec pandas.melt() réduit la quantité de code nécessaire pour analyser différentes variables.

• Créer des jeux de données "tidy" : un jeu de données rangé stocke chaque variable dans sa propre colonne et chaque observation sur sa propre ligne. Si votre jeu comporte des mesures répétées sur plusieurs colonnes, pandas.melt() est souvent le moyen le plus rapide pour le convertir en format "tidy".

Je vous recommande de suivre notre cours Introduction to Data Visualization with Seaborn pour apprendre à créer et personnaliser différents graphiques en Python, dont nuage de points, diagramme en barres, comptages et boîtes à moustaches.

pandas.melt() vs autres fonctions de remodelage

Pandas propose plusieurs fonctions pour remodéler les données, chacune avec un objectif précis. Voyons les différences entre elles.

pandas.melt() vs pivot()

Le tableau ci-dessous montre la différence entre pandas.melt() et la fonction pivot().

Ainsi, choisissez melt() lorsque vos mesures sont réparties sur plusieurs colonnes, ou pivot() si vous souhaitez répartir des valeurs de lignes sur des colonnes.

pandas.melt() vs stack()

Bien que les deux fonctions remodèlent les données, voici leurs différences.

Vous pouvez utiliser stack() lorsque vous travaillez avec des index hiérarchiques ou des objets MultiIndex.

pandas.melt() vs wide_to_long()

Ces deux fonctions convertissent des données larges en format long, mais elles sont conçues pour des situations différentes, comme indiqué ci-dessous.

Si votre jeu de données a des noms de colonnes irréguliers, utilisez melt(). Si vos colonnes suivent une convention de nommage prévisible, utilisez wide_to_long() pour remodéler les données avec moins de code.

Erreurs courantes avec pandas.melt()

Même si pandas.melt() est simple à utiliser, voici les pièges les plus fréquents que j’ai rencontrés et comment les éviter.

• Oublier id_vars : si vous ne précisez pas id_vars, pandas considère que toutes les colonnes non listées dans value_vars sont des colonnes de valeurs. Vous risquez donc de remodéler des colonnes que vous vouliez garder comme identifiants. Pour corriger cela, identifiez toujours les colonnes qui décrivent de façon unique chaque enregistrement et passez-les à id_vars.

• Fondre des colonnes non souhaitées : si vous omettez value_vars, pandas fond toutes les colonnes qui ne sont pas dans id_vars. Cela peut inclure des colonnes que vous ne vouliez pas remodéler. Spécifiez donc value_vars lorsque vous ne souhaitez fondre qu’un sous-ensemble de colonnes.

• Mal interpréter la forme de sortie : après fusion, le nombre de lignes augmente, car chaque colonne sélectionnée devient une ligne distincte pour chaque enregistrement. Par exemple, un DataFrame avec 10 lignes et 12 colonnes de mois produit 120 lignes après fusion des colonnes de mois. Vérifiez donc toujours la forme avant et après le remodelage pour confirmer que la transformation s’est bien déroulée.

• Confondre formats large et long : retenez que, pour un format large, des valeurs similaires sont stockées sur plusieurs colonnes. Pour un format long, elles sont stockées dans une seule colonne, avec une autre colonne qui identifie la variable.

Bonnes pratiques pour utiliser pandas.melt()

Pour rendre votre code de remodelage plus clair et maintenable, je vous recommande les bonnes pratiques suivantes avec pandas.melt() :

• Identifier d’abord les colonnes d’identifiants : décidez quelles colonnes doivent rester inchangées, puis passez-les à id_vars.

• Renommer la colonne générée : utilisez var_name et value_name au lieu de conserver les noms par défaut variable et value.

• Contrôler le nombre de lignes après fusion : vérifiez que le nombre de lignes correspond à vos attentes, surtout lorsque vous fondez de nombreuses colonnes.

• Utiliser pivot() pour revenir en arrière : si vous devez restaurer le format large d’origine après analyse, utilisez la fonction pivot().

Suivez notre Writing Efficient Python Code course pour apprendre à écrire un code efficace, facile à déboguer et à maintenir.

Conclusion

pandas.melt() est la fonction de référence dans pandas pour convertir des données au format large en format long. Une fois que vous comprenez les rôles de id_vars et value_vars, vous contrôlez précisément quelles colonnes restent des identifiants et lesquelles sont converties en lignes.

Pour approfondir Python, explorez nos parcours de compétences Python Data Fundamentals et Python Programming Fundamentals.