Skip to content

Pandas Drop Column : Comment supprimer des colonnes d'un DataFrame

Soren Atelier
Name
Soren Atelier

Updated on

Les DataFrames provenant de sources réelles arrivent rarement avec uniquement les colonnes dont vous avez besoin. Les exports CSV incluent des colonnes de métadonnées, les requêtes de base de données récupèrent des champs supplémentaires, et les réponses API contiennent des données imbriquées que vous avez déjà aplaties. Avant toute analyse significative, vous devez supprimer les colonnes non pertinentes. Se tromper -- supprimer accidentellement la mauvaise colonne ou modifier le DataFrame original quand vous vouliez créer une copie -- cause des bugs de perte de données difficiles à retracer.

Pandas fournit plusieurs méthodes pour supprimer des colonnes, chacune adaptée à différentes situations. La méthode drop() est la plus polyvalente, mais del, pop() et la sélection de colonnes offrent des alternatives utiles. Ce guide couvre chaque approche avec des exemples clairs montrant quand utiliser chacune.

📚

    Utiliser df.drop() -- L'approche standard

    La méthode drop() est la façon principale de supprimer des colonnes. Passez les noms de colonnes et définissez axis=1 (ou utilisez le paramètre columns).

    Supprimer une seule colonne

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'salary': [50000, 60000, 70000],
    'department': ['Engineering', 'Marketing', 'Sales'],
})
 
# Méthode 1 : Utiliser le paramètre columns (recommandé)
df_clean = df.drop(columns=['salary'])
print(df_clean)
 
# Méthode 2 : Utiliser axis=1
df_clean = df.drop('salary', axis=1)

    Supprimer plusieurs colonnes

    import pandas as pd
 
df = pd.DataFrame({
    'id': [1, 2, 3],
    'name': ['Alice', 'Bob', 'Charlie'],
    'email': ['a@test.com', 'b@test.com', 'c@test.com'],
    'temp_col': [None, None, None],
    'internal_id': ['X1', 'X2', 'X3'],
})
 
# Supprimer plusieurs colonnes à la fois
df_clean = df.drop(columns=['temp_col', 'internal_id', 'email'])
print(df_clean)
#    id     name
# 0   1    Alice
# 1   2      Bob
# 2   3  Charlie

    Le paramètre inplace

    Par défaut, drop() retourne un nouveau DataFrame. Utilisez inplace=True pour modifier l'original :

    import pandas as pd
 
df = pd.DataFrame({'a': [1], 'b': [2], 'c': [3]})
 
# Retourne un nouveau DataFrame (original inchangé)
new_df = df.drop(columns=['b'])
print(df.columns.tolist())      # ['a', 'b', 'c'] (inchangé)
print(new_df.columns.tolist())  # ['a', 'c']
 
# Modifie le DataFrame original
df.drop(columns=['b'], inplace=True)
print(df.columns.tolist())  # ['a', 'c']

    Gestion des colonnes manquantes avec le paramètre errors

    import pandas as pd
 
df = pd.DataFrame({'a': [1], 'b': [2], 'c': [3]})
 
# Par défaut : lève KeyError si la colonne n'existe pas
# df.drop(columns=['d'])  # KeyError: "['d'] not found in axis"
 
# Ignorer les colonnes manquantes
df_clean = df.drop(columns=['b', 'd'], errors='ignore')
print(df_clean.columns.tolist())  # ['a', 'c']

    Utiliser l'instruction del

    L'instruction del supprime une colonne en place. Elle est concise mais limitée à une colonne à la fois.

    import pandas as pd
 
df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [5, 6]})
 
del df['b']
print(df.columns.tolist())  # ['a', 'c']

    Limitations : Ne peut pas supprimer plusieurs colonnes à la fois. Ne peut pas ignorer les colonnes manquantes (lève KeyError). Modifie toujours en place.

    Utiliser df.pop()

    pop() supprime une colonne et la retourne comme Series. Utile quand vous avez besoin de la colonne supprimée pour un usage ultérieur.

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob'],
    'target': [1, 0],
    'feature1': [10, 20],
    'feature2': [30, 40],
})
 
# Extraire la colonne cible tout en la supprimant du DataFrame
y = df.pop('target')
X = df
 
print(y)
# 0    1
# 1    0
# Name: target, dtype: int64
 
print(X)
#     name  feature1  feature2
# 0  Alice        10        30
# 1    Bob        20        40

    Sélectionner des colonnes (inverse de la suppression)

    Parfois, il est plus facile de sélectionner les colonnes souhaitées plutôt que de lister celles à supprimer.

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob'],
    'age': [25, 30],
    'salary': [50000, 60000],
    'dept': ['Eng', 'Mkt'],
    'internal_id': ['X1', 'X2'],
})
 
# Garder uniquement des colonnes spécifiques
df_clean = df[['name', 'age', 'salary']]
 
# Supprimer des colonnes en sélectionnant tout sauf elles
df_clean = df.loc[:, df.columns != 'internal_id']
 
# Garder les colonnes selon une condition
df_numeric = df.select_dtypes(include='number')
print(df_numeric)
#    age  salary
# 0   25   50000
# 1   30   60000

    Supprimer des colonnes par motif ou condition

    Supprimer des colonnes par motif de nom

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice'], 'age': [25],
    'temp_1': [None], 'temp_2': [None],
    'internal_flag': [True],
})
 
# Supprimer les colonnes commençant par 'temp_'
cols_to_drop = [c for c in df.columns if c.startswith('temp_')]
df_clean = df.drop(columns=cols_to_drop)
print(df_clean.columns.tolist())  # ['name', 'age', 'internal_flag']
 
# Supprimer les colonnes contenant 'internal'
cols_to_drop = [c for c in df.columns if 'internal' in c]
df_clean = df.drop(columns=cols_to_drop)
 
# Utiliser filter() pour garder les colonnes correspondantes
df_temps = df.filter(like='temp')  # Garde uniquement les colonnes contenant 'temp'
df_no_temps = df.drop(columns=df.filter(like='temp').columns)

    Supprimer des colonnes par type de données

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob'],
    'age': [25, 30],
    'score': [95.5, 87.3],
    'active': [True, False],
})
 
# Supprimer toutes les colonnes non numériques
df_numeric = df.select_dtypes(include='number')
 
# Supprimer toutes les colonnes object (chaîne)
df_no_strings = df.select_dtypes(exclude='object')
print(df_no_strings.columns.tolist())  # ['age', 'score', 'active']

    Supprimer les colonnes avec trop de valeurs manquantes

    import pandas as pd
import numpy as np
 
df = pd.DataFrame({
    'a': [1, 2, 3, 4, 5],
    'b': [1, np.nan, np.nan, np.nan, np.nan],
    'c': [1, 2, np.nan, 4, 5],
    'd': [np.nan, np.nan, np.nan, np.nan, np.nan],
})
 
# Supprimer les colonnes où plus de 50% des valeurs manquent
threshold = len(df) * 0.5
df_clean = df.dropna(axis=1, thresh=int(threshold))
print(df_clean.columns.tolist())  # ['a', 'c']

    Comparaison des méthodes

    MéthodeRetourneEn placeColonnes multiplesGestion col manquante
    df.drop(columns=...)Nouveau DataFrameOptionnel (inplace)Ouierrors='ignore'
    del df[col]RienToujoursNon (une à la fois)Lève KeyError
    df.pop(col)Series suppriméeToujoursNon (une à la fois)Lève KeyError
    df[cols_to_keep]Nouveau DataFrameNonOui (inverse)Lève KeyError
    df.select_dtypes()Nouveau DataFrameNonPar dtypeN/A

    Visualiser votre DataFrame nettoyé

    Après avoir supprimé des colonnes et nettoyé vos données, PyGWalker (opens in a new tab) fournit une interface interactive de type Tableau pour explorer le DataFrame nettoyé directement dans Jupyter :

    import pygwalker as pyg
 
# Après le nettoyage de votre DataFrame
walker = pyg.walk(df_clean)

    Cela vous permet de glisser-déposer les colonnes restantes pour créer des graphiques sans écrire de code de visualisation.

    FAQ

    Comment supprimer une colonne dans pandas ?

    Utilisez df.drop(columns=['nom_colonne']) pour supprimer une colonne et retourner un nouveau DataFrame. Pour une suppression en place, ajoutez inplace=True. Vous pouvez aussi utiliser del df['nom_colonne'] pour une suppression rapide en place, ou df.pop('nom_colonne') pour supprimer et retourner la colonne comme Series.

    Comment supprimer plusieurs colonnes à la fois ?

    Passez une liste de noms de colonnes à df.drop(columns=['col1', 'col2', 'col3']). Cela supprime toutes les colonnes spécifiées en une seule opération et retourne un nouveau DataFrame.

    Comment supprimer des colonnes conditionnellement (par motif ou type de données) ?

    Pour les motifs de nom, utilisez une compréhension de liste : df.drop(columns=[c for c in df.columns if c.startswith('temp_')]). Pour les types de données, utilisez df.select_dtypes(exclude='object') pour supprimer les colonnes texte, ou df.select_dtypes(include='number') pour ne garder que les colonnes numériques.

    Quelle est la différence entre drop() et del pour supprimer des colonnes ?

    df.drop() retourne un nouveau DataFrame par défaut, peut gérer plusieurs colonnes à la fois, et dispose d'une option errors='ignore' pour les colonnes manquantes. del df[col] modifie toujours en place, ne fonctionne que sur une colonne à la fois, et lève KeyError si la colonne n'existe pas.

    Comment supprimer des colonnes avec des valeurs manquantes ?

    Utilisez df.dropna(axis=1) pour supprimer toute colonne ayant au moins un NaN. Utilisez df.dropna(axis=1, thresh=n) pour ne garder que les colonnes avec au moins n valeurs non nulles. Pour des seuils personnalisés, filtrez par le pourcentage de nulls : df.loc[:, df.isnull().mean() < 0.5] garde les colonnes avec moins de 50% de données manquantes.

    Conclusion

    Pour la plupart des situations, df.drop(columns=[...]) est le bon choix -- c'est explicite, gère plusieurs colonnes et retourne un nouveau DataFrame par défaut. Utilisez del pour une suppression rapide en place d'une seule colonne, pop() quand vous avez besoin de la colonne supprimée, et la sélection de colonnes ou select_dtypes() quand il est plus facile de spécifier ce que vous voulez garder plutôt que ce que vous voulez supprimer.

    📚