Pandas & NumPy Academy · Leçon

melt : du format large au format long

Convertissez un DataFrame au format large en format long avec pd.melt en indiquant id_vars et value_vars.

Leçon 2 sur 413 étapes

melt : du format large au format long est une leçon Pandas & NumPy Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Pandas & NumPy Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Pandas & NumPy Academy comprend 4 leçons au total.

Formats de données large et long

Les données peuvent être structurées selon deux formes fondamentales. Le format large comporte une ligne par sujet et répartit les mesures sur plusieurs colonnes, par exemple une colonne distincte pour les ventes de janvier, février et mars. Le format long comporte une ligne par observation, avec une colonne pour le nom de la variable et une autre pour sa valeur. La plupart des fonctions d’analyse de Pandas, des bibliothèques d’apprentissage automatique et des outils de visualisation préfèrent le format long, ce qui fait de melt() un outil de transformation essentiel.

La fonction pd.melt()

pd.melt(df) (également disponible sous la forme df.melt()) convertit un DataFrame large au format long. Les paramètres essentiels sont id_vars (colonnes à conserver comme identifiants, sans modification), value_vars (colonnes à transformer en lignes), var_name (nom de la nouvelle colonne de variables) et value_name (nom de la nouvelle colonne de valeurs).

import pandas as pd

# Wide format: separate columns per month
df_wide = pd.DataFrame({
    'product': ['A', 'B'],
    'Jan':     [100, 150],
    'Feb':     [120, 130],
    'Mar':     [140, 160]
})

print(df_wide)
#   product  Jan  Feb  Mar
# 0       A  100  120  140
# 1       B  150  130  160

Appel de base à melt()

Appelez melt() en définissant id_vars sur les colonnes que vous souhaitez conserver comme identifiants. Toutes les autres colonnes sont transformées : leur nom devient une valeur dans la nouvelle colonne de variables et leurs valeurs de cellule sont déplacées dans la colonne de valeurs. Le nombre de lignes en sortie est égal au nombre de lignes en entrée multiplié par le nombre de colonnes de valeurs transformées.

df_long = df_wide.melt(
    id_vars='product',
    var_name='month',
    value_name='sales'
)
print(df_long)
#   product month  sales
# 0       A   Jan    100
# 1       B   Jan    150
# 2       A   Feb    120
# 3       B   Feb    130
# 4       A   Mar    140
# 5       B   Mar    160

Sélectionner les colonnes à transformer

Par défaut, toute colonne qui ne figure pas dans id_vars est transformée. Utilisez value_vars pour ne transformer qu’un sous-ensemble de colonnes. Les colonnes qui ne figurent ni dans id_vars ni dans value_vars sont supprimées du résultat. C’est utile lorsque votre DataFrame large contient à la fois des colonnes de séries temporelles et d’autres attributs que vous ne souhaitez pas transformer.

df_wide2 = pd.DataFrame({
    'product': ['A', 'B'],
    'category': ['Electronics', 'Clothing'],
    'Jan': [100, 150],
    'Feb': [120, 130],
    'Mar': [140, 160]
})

# Melt only Jan and Feb, keep product and category
df_long2 = df_wide2.melt(
    id_vars=['product', 'category'],
    value_vars=['Jan', 'Feb'],
    var_name='month',
    value_name='sales'
)
print(df_long2)

Réinitialiser l’index après melt()

melt() conserve les index de lignes d’origine en les répétant pour chaque variable. Le résultat possède souvent un index non séquentiel tel que [0, 1, 0, 1, 0, 1]. Il est recommandé d’appeler immédiatement reset_index(drop=True) après melt() afin d’obtenir dans le résultat un index séquentiel propre, allant de 0 à n-1.

df_long = df_wide.melt(id_vars='product', var_name='month', value_name='sales')
print('Before reset:', df_long.index.tolist())
# [0, 1, 0, 1, 0, 1]

df_long = df_long.reset_index(drop=True)
print('After reset:', df_long.index.tolist())
# [0, 1, 2, 3, 4, 5]

melt() est l’inverse de pivot()

melt() est conceptuellement l’opération inverse de pivot() / pivot_table(). Vous pouvez passer du format long au format large avec pivot_table(), puis revenir au format long avec melt(). Cette conversion réversible est souvent utilisée dans les pipelines : recevoir des données au format large, les restructurer au format long pour les graphiques Seaborn ou les caractéristiques destinées à l’apprentissage automatique, puis éventuellement les convertir de nouveau pour une table de rapport.

# long -> wide
table = df_long.pivot_table(values='sales', index='product',
                            columns='month', aggfunc='sum')
print(table)
# product  Feb  Jan  Mar
# A        120  100  140
# B        130  150  160

# wide -> long again
long_again = table.reset_index().melt(id_vars='product', var_name='month', value_name='sales')
print(long_again.head())

Utiliser melt() pour créer des graphiques avec Seaborn

Les graphiques catégoriels et relationnels de Seaborn fonctionnent mieux avec des données au format long. Voici un flux de travail courant : commencez par un DataFrame au format large comportant une colonne par groupe, utilisez melt() pour le convertir au format long afin qu’une colonne identifie le groupe et qu’une autre contienne les valeurs, puis transmettez ces deux colonnes aux paramètres hue et x/y de Seaborn. C’est l’une des raisons les plus courantes d’utiliser melt().

import seaborn as sns
import matplotlib.pyplot as plt

# Long format is required for sns.lineplot with hue
df_long = df_wide.melt(id_vars='product', var_name='month', value_name='sales')

# sns.lineplot(data=df_long, x='month', y='sales', hue='product')
# plt.show()
print('Long data ready for Seaborn:')
print(df_long)

Nommer les colonnes de sortie

Par défaut, melt() nomme la nouvelle colonne de variable 'variable' et la colonne de valeurs 'value'. Remplacez-les toujours par des noms explicites à l’aide de var_name et value_name. Des noms de colonnes descriptifs rendent le code utilisé ensuite plus facile à lire et évitent toute confusion lorsqu’un DataFrame comporte des dizaines de colonnes.

# Default: generic column names 'variable' and 'value'
default = df_wide.melt(id_vars='product')
print(default.columns.tolist())
# ['product', 'variable', 'value']

# Better: descriptive names
good = df_wide.melt(id_vars='product', var_name='month', value_name='revenue_usd')
print(good.columns.tolist())
# ['product', 'month', 'revenue_usd']

Mettre des données d’enquête au format long

Un cas d’utilisation classique de melt() concerne les réponses à une enquête, où chaque colonne correspond à une question et chaque ligne à une personne interrogée. La conversion transforme ce format large en format long, avec des colonnes pour l’identifiant de la personne interrogée, le nom de la question et la valeur de la réponse. Vous pouvez ensuite calculer facilement la répartition des réponses pour chaque question à l’aide de groupby().

survey = pd.DataFrame({
    'respondent': [1, 2, 3],
    'Q1_rating': [5, 3, 4],
    'Q2_rating': [4, 5, 3],
    'Q3_rating': [2, 4, 5]
})

long = survey.melt(id_vars='respondent', var_name='question', value_name='rating')
print(long)
print(long.groupby('question')['rating'].mean())

Trier le résultat de la conversion

Après la conversion, les lignes sont ordonnées selon l’ordre des colonnes d’origine (Jan, Feb, Mar pour chaque ligne). Vous souhaiterez souvent trier d’abord selon la colonne d’identification, puis selon la colonne de variable. Utilisez sort_values() sur le DataFrame obtenu pour définir l’ordre le plus pertinent pour votre analyse ou pour le traitement effectué ensuite.

df_long = df_wide.melt(id_vars='product', var_name='month', value_name='sales')

# Sort by product, then month
df_sorted = df_long.sort_values(['product', 'month']).reset_index(drop=True)
print(df_sorted)
#   product month  sales
# 0       A   Feb    120
# 1       A   Jan    100
# 2       A   Mar    140
# 3       B   Feb    130
# 4       B   Jan    150
# 5       B   Mar    160

melt() dans un pipeline de données

Dans un pipeline de données classique, melt() intervient juste après le chargement ou le nettoyage de données au format large, avant toute étape d’analyse ou de modélisation. Placez-le tôt dans votre pipeline pour passer rapidement au format long ; toutes les opérations suivantes (groupby, Seaborn, sklearn) pourront alors travailler sur ces données propres au format long sans traitement particulier.

def load_and_reshape(filepath):
    raw = pd.read_csv(filepath)
    # Melt all month columns into long format
    month_cols = [c for c in raw.columns if c.startswith('month_')]
    long = raw.melt(
        id_vars=[c for c in raw.columns if c not in month_cols],
        value_vars=month_cols,
        var_name='month',
        value_name='value'
    )
    return long.reset_index(drop=True)

Vérification rapide

Vérifiez votre compréhension de la transformation de données au format large vers le format long avec pd.melt, présentée dans cette leçon.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que melt() convertit le format large en format long en transformant les colonnes en lignes ; que id_vars indique les colonnes qui restent fixes et que value_vars sélectionne les colonnes à convertir ; que var_name et value_name attribuent des noms explicites aux nouvelles colonnes ; et que le format long est privilégié pour Seaborn, groupby et les pipelines d’apprentissage automatique. Nous allons maintenant étudier stack et unstack pour remodeler des DataFrames dotés d’un MultiIndex.

Gratuit pour commencer

Apprends Python avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
30
Leçons
120

Questions Fréquemment Posées

La leçon « melt : du format large au format long » est-elle gratuite ?

Oui — le texte complet de « melt : du format large au format long » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Pandas & NumPy Academy, passe à CoddyKit PRO. Le cours Pandas & NumPy Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « melt : du format large au format long » ?

Convertissez un DataFrame au format large en format long avec pd.melt en indiquant id_vars et value_vars. Tu pratiques Pandas & NumPy Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Pandas & NumPy Academy ?

Aucune expérience préalable n'est requise. Pandas & NumPy Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « melt : du format large au format long » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Pandas & NumPy Academy ?

Oui. Chaque leçon Pandas & NumPy Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. pivot_table : tableau croisé
  2. melt : du format large au format long
  3. stack et unstack avec MultiIndex
  4. crosstab pour les tableaux de fréquences
← Retour à Pandas & NumPy Academy