Fonction df.stack() de Pandas
Fonctions courantes de Pandasdf.stack()est une méthode membre de DataFrame, utilisée pourconvertir les index de colonnes en index de lignes. Elle « empile » les colonnes de données au format large en lignes, produisant une Series ou un DataFrame avec un index hiérarchique.
Il s'agit d'une opération importante pour la restructuration des données, généralement utilisée avecunstack()pour réaliser la conversion mutuelle des données.
Définition du mot： stackCela signifie « empiler, entasser » ; ici, cela désigne le fait d'« empiler » les données de colonnes en lignes, convertissant une table large en une table longue.
Syntaxe de base et paramètres
df.stack()est une méthode d’instance de DataFrame, appelée via l’opérateur point.
Format de syntaxe
DataFrame.stack(level=-1, dropna=True)
Description du paramètre
- Paramètre：
level- Type : int, str, liste d'int, ou liste de str.
- Description : Spécifie le niveau à empiler. Pour les index multi-niveaux, vous pouvez spécifier un numéro de niveau spécifique (commençant à 0) ou un nom de niveau. La valeur par défaut est -1, ce qui signifie le niveau le plus interne.
- Paramètre：
dropna- Type : booléen.
- Description : Indique s'il faut supprimer les lignes qui sont entièrement NaN dans le résultat. La valeur par défaut est True, ce qui supprime les lignes où toutes les valeurs sont NaN.
Description de la fonction
- Valeur de retour: Renvoie une Series ou un DataFrame. Si une seule colonne du DataFrame d'origine est empilée, une Series est renvoyée ; sinon, un DataFrame est renvoyé.
- Effet: Convertit les index de colonnes en index de lignes, produisant un format de données plus long. Les données empilées sont au format « long », ce qui est pratique pour l'analyse statistique ou la visualisation.
Exemples
À travers une série d'exemples du simple au complexe, apprenons à maîtriser parfaitementdf.stack()son utilisation.
Exemple 1 : Utilisation de base - Conversion de colonnes en lignes
Exemple
import pandas as pd
import numpy as np
# 1. Créer des données au format large (une colonne par trimestre)
df = pd.DataFrame({
'name': ['Alice', 'Bob', 'Charlie'],
'Q1': [100, 150, 200],
'Q2': [120, 160, 210],
'Q3': [130, 170, 220]
})
print("=== Données originales au format large ===")
print(df)
print(f"Noms des colonnes : {df.columns.tolist()}")
# 2. Utiliser df.stack() pour convertir les colonnes en lignes
stacked = df.stack()
print("n=== résultat de df.stack() ===")
print(stacked)
print(f"nType : {type(stacked)}")
# 3. Convertir le résultat en DataFrame pour inspection
print("n=== Converti en DataFrame ===")
stacked_df = stacked.reset_index()
stacked_df.columns = ['name', 'quarter', 'sales']
print(stacked_df)
import numpy as np
# 1. Créer des données au format large (une colonne par trimestre)
df = pd.DataFrame({
'name': ['Alice', 'Bob', 'Charlie'],
'Q1': [100, 150, 200],
'Q2': [120, 160, 210],
'Q3': [130, 170, 220]
})
print("=== Données originales au format large ===")
print(df)
print(f"Noms des colonnes : {df.columns.tolist()}")
# 2. Utiliser df.stack() pour convertir les colonnes en lignes
stacked = df.stack()
print("n=== résultat de df.stack() ===")
print(stacked)
print(f"nType : {type(stacked)}")
# 3. Convertir le résultat en DataFrame pour inspection
print("n=== Converti en DataFrame ===")
stacked_df = stacked.reset_index()
stacked_df.columns = ['name', 'quarter', 'sales']
print(stacked_df)
Sortie attendue :
=== 原始宽格式数据 ===
name Q1 Q2 Q3
0 Alice 100 120 130
1 Bob 150 160 170
2 Charlie 'Q2', 'Q3'], columns=['name', 'quarter', 'sales']
...
Explication du code :
- Les données d'origine sont au format large, avec Q1, Q2, Q3 comme trois colonnes de données trimestrielles.
stack()Les trois colonnes Q1, Q2, Q3 sont « empilées » en lignes.- Le résultat est de type Series, avec deux niveaux d'index : le niveau externe est l'index de ligne d'origine, et le niveau interne correspond aux noms des colonnes d'origine (trimestres).
- Après l'empilement, les données passent au « format long », chaque ligne ne contenant qu'une seule valeur trimestrielle.
Exemple 2 : Empilement d'index de colonnes à plusieurs niveaux
Lorsqu'un DataFrame possède un index de colonnes à plusieurs niveaux, vous pouvez spécifier le niveau à empiler.
Exemple
import pandas as pd
import numpy as np
# 1. Créer des données avec un index de colonnes à plusieurs niveaux
# Niveau externe : type de produit (Électronique, Mobilier)
# Niveau interne : trimestre (Q1, Q2)
df = pd.DataFrame(
[[100, 110, 200, 210], [150, 160, 180, 190]],
index=['Store_A', 'Store_B'],
columns=pd.MultiIndex.from_tuples([
('Electronics', 'Q1'), ('Electronics', 'Q2'),
('Furniture', 'Q1'), ('Furniture', 'Q2')
], names=['Product', 'Quarter'])
)
print("=== Données d'origine (index de colonnes multi-niveaux) ===")
print(df)
print(f"Niveaux de l'index des colonnes : {df.columns.names}")
# 2. Empiler le niveau de colonne interne (par défaut, level=-1)
print("n=== Empiler le niveau de colonne interne (level=-1) ===")
stacked_inner = df.stack()
print(stacked_inner)
# 3. Empiler le niveau de colonne externe
print("n=== Empiler le niveau de colonne externe (level=0) ===")
stacked_outer = df.stack(level=0)
print(stacked_outer)
# 4. Empiler toutes les colonnes (produit un format plus long)
print("n=== Empiler toutes les colonnes ===")
stacked_all = df.stack(level=[0, 1])
print(stacked_all)
import numpy as np
# 1. Créer des données avec un index de colonnes à plusieurs niveaux
# Niveau externe : type de produit (Électronique, Mobilier)
# Niveau interne : trimestre (Q1, Q2)
df = pd.DataFrame(
[[100, 110, 200, 210], [150, 160, 180, 190]],
index=['Store_A', 'Store_B'],
columns=pd.MultiIndex.from_tuples([
('Electronics', 'Q1'), ('Electronics', 'Q2'),
('Furniture', 'Q1'), ('Furniture', 'Q2')
], names=['Product', 'Quarter'])
)
print("=== Données d'origine (index de colonnes multi-niveaux) ===")
print(df)
print(f"Niveaux de l'index des colonnes : {df.columns.names}")
# 2. Empiler le niveau de colonne interne (par défaut, level=-1)
print("n=== Empiler le niveau de colonne interne (level=-1) ===")
stacked_inner = df.stack()
print(stacked_inner)
# 3. Empiler le niveau de colonne externe
print("n=== Empiler le niveau de colonne externe (level=0) ===")
stacked_outer = df.stack(level=0)
print(stacked_outer)
# 4. Empiler toutes les colonnes (produit un format plus long)
print("n=== Empiler toutes les colonnes ===")
stacked_all = df.stack(level=[0, 1])
print(stacked_all)
Sortie attendue :
=== 原始数据（多层列索引）=== Product Electronics Furniture Quarter Q1 Q2 Q1 Q ...
Explication du code :
- Pour un DataFrame avec un index de colonnes à plusieurs niveaux, les noms de colonnes sont des tuples : (Product, Quarter).
level=-1Empilez le niveau le plus interne (par défaut), c'est-à-dire le niveau Quarter, et le résultat conserve Product comme colonnes.level=0Empilez le niveau externe, c'est-à-dire le niveau Product, et le résultat conserve Quarter comme colonnes.- Cette flexibilité vous permet de choisir le niveau à empiler en fonction de vos besoins d'analyse.
Exemple 3 : Gestion des valeurs manquantes
Utilisez ladropnaparamètre pour contrôler la façon dont les valeurs manquantes sont traitées.
Exemple
import pandas as pd
import numpy as np
# 1. Créer des données contenant des valeurs manquantes
df = pd.DataFrame({
'name': ['Alice', 'Bob'],
'Math': [100, np.nan],
'Anglais': [90, 85],
'Science': [np.nan, 95]
})
print("=== Données originales (contenant des valeurs manquantes) ===")
print(df)
# 2. dropna=True (par défaut), supprimer les lignes qui sont toutes NaN
print("n=== dropna=True (par défaut) ===")
stacked_drop = df.stack(dropna=True)
print(stacked_drop)
# 3. dropna=False, conserver les valeurs NaN
print("n=== dropna=False ===")
stacked_keep = df.stack(dropna=False)
print(stacked_keep)
# 4. Application pratique : organiser le résultat empilé en un format long analysable
print("n=== Organisé en un DataFrame au format long ===")
result = df.set_index('name').stack().reset_index()
result.columns = ['name', 'subject', 'score']
print(result)
# 5. Supprimer les valeurs manquantes
result_clean = result.dropna()
print("n=== Après suppression des valeurs manquantes ===")
print(result_clean)
import numpy as np
# 1. Créer des données contenant des valeurs manquantes
df = pd.DataFrame({
'name': ['Alice', 'Bob'],
'Math': [100, np.nan],
'Anglais': [90, 85],
'Science': [np.nan, 95]
})
print("=== Données originales (contenant des valeurs manquantes) ===")
print(df)
# 2. dropna=True (par défaut), supprimer les lignes qui sont toutes NaN
print("n=== dropna=True (par défaut) ===")
stacked_drop = df.stack(dropna=True)
print(stacked_drop)
# 3. dropna=False, conserver les valeurs NaN
print("n=== dropna=False ===")
stacked_keep = df.stack(dropna=False)
print(stacked_keep)
# 4. Application pratique : organiser le résultat empilé en un format long analysable
print("n=== Organisé en un DataFrame au format long ===")
result = df.set_index('name').stack().reset_index()
result.columns = ['name', 'subject', 'score']
print(result)
# 5. Supprimer les valeurs manquantes
result_clean = result.dropna()
print("n=== Après suppression des valeurs manquantes ===")
print(result_clean)
Sortie attendue :
=== 原始数据（包含缺失值）===
name Math English Science
0 Alice 100.0 90.0 NaN
1 Bob NaN 85.0 95.0
2=== 堆叠内层列 (level=-1) ===
Store_A Electronics Q1 100
Q2 110
Furniture Q1 200
Q2 210
Store_B Electronics Q1 150
...
Explication du code :
dropna=True(Par défaut) supprime les lignes où toutes les valeurs sont NaN.- En analyse de données, il est généralement nécessaire de conserver les données d'origine, puis de supprimer les valeurs manquantes selon les besoins.
- Après l'empilement, utilisez
reset_index()pour convertir l'index hiérarchique en colonnes ordinaires pour faciliter le traitement ultérieur.
Exemple 4 : Utilisation combinée de stack et unstack
stack()etunstack()Ce sont des opérations inverses ; les utiliser ensemble permet de remodeler les données de manière flexible.
Exemple
import pandas as pd
# 1. Créer les données initiales
df = pd.DataFrame({
'product': ['A', 'B', 'C'],
'Nord': [100, 150, 200],
'South': [180, 170, 160],
'Est': [190, 200, 210]
})
print("=== Données originales ===")
print(df)
# 2. Utiliser unstack pour convertir les régions en colonnes (convertir d'abord en index à plusieurs niveaux)
df_indexed = df.set_index('product')
print("n=== Après définition de l'index ===")
print(df_indexed)
# 3. Utiliser stack pour convertir les colonnes en lignes (stack est l'inverse de unstack)
print("n=== aller-retour unstack + stack ===")
# D'abord unstack
unstacked = df_indexed.unstack()
print("résultat de unstack:")
print(unstacked)
# Ensuite, stack à nouveau
restacked = unstacked.stack()
print("nstack à nouveau:")
print(restacked)
# 4. Exemple complet : créer un index multi-niveau puis convertir
print("n=== Conversion d'index multi-niveau ===")
# Créer un DataFrame avec un index multi-niveau
multi_df = pd.DataFrame(
[[100, 110], [150, 160]],
index=pd.MultiIndex.from_tuples([('A', '2023'), ('B', '2023')], names=['product', 'year']),
columns=['North', 'South']
)
print("Données d'index multi-niveaux originales :")
print(multi_df)
# unstack year
print("nunstack year:")
print(multi_df.unstack(level='year'))
# unstack columns
print("nunstack columns (convertir en colonnes) :")
print(multi_df.unstack(level='columns'))
# 1. Créer les données initiales
df = pd.DataFrame({
'product': ['A', 'B', 'C'],
'Nord': [100, 150, 200],
'South': [180, 170, 160],
'Est': [190, 200, 210]
})
print("=== Données originales ===")
print(df)
# 2. Utiliser unstack pour convertir les régions en colonnes (convertir d'abord en index à plusieurs niveaux)
df_indexed = df.set_index('product')
print("n=== Après définition de l'index ===")
print(df_indexed)
# 3. Utiliser stack pour convertir les colonnes en lignes (stack est l'inverse de unstack)
print("n=== aller-retour unstack + stack ===")
# D'abord unstack
unstacked = df_indexed.unstack()
print("résultat de unstack:")
print(unstacked)
# Ensuite, stack à nouveau
restacked = unstacked.stack()
print("nstack à nouveau:")
print(restacked)
# 4. Exemple complet : créer un index multi-niveau puis convertir
print("n=== Conversion d'index multi-niveau ===")
# Créer un DataFrame avec un index multi-niveau
multi_df = pd.DataFrame(
[[100, 110], [150, 160]],
index=pd.MultiIndex.from_tuples([('A', '2023'), ('B', '2023')], names=['product', 'year']),
columns=['North', 'South']
)
print("Données d'index multi-niveaux originales :")
print(multi_df)
# unstack year
print("nunstack year:")
print(multi_df.unstack(level='year'))
# unstack columns
print("nunstack columns (convertir en colonnes) :")
print(multi_df.unstack(level='columns'))
Sortie attendue :
=== unstack + stack 往返 ===
unstack 结果:
product
North A 100
B 150
C 200
South A 180
B 170
...
Explication du code :
stack()Convertit les index de colonnes en index de lignes, transformant une table large en une table longue.unstack()Convertit les index de lignes en index de colonnes, transformant une table longue en une table large.- Utiliser les deux ensemble permet d'obtenir un remodelage arbitraire des données.
- Pour l'analyse de données, il est très important de comprendre la relation inverse entre ces deux opérations.
Autres extensionsAstuce :
stack()etunstack()est un outil essentiel pour le remodelage des données.stack()empile les colonnes en lignes (large vers long),unstack()scinde les lignes en colonnes (long vers large).