Ajouter et supprimer des colonnes
Ajoutez de nouvelles colonnes calculées, renommez celles qui existent et supprimez les colonnes ou lignes indésirables avec drop().
Ajouter et supprimer des colonnes est une leçon Pandas & NumPy Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.
Ajouter une nouvelle colonne par affectation
La manière la plus simple d’ajouter une colonne consiste à effectuer une affectation directe : df['new_col'] = values. Le membre de droite peut être un scalaire (diffusé sur toutes les lignes), une liste de même longueur, un tableau NumPy, une série Pandas (alignée sur l’index) ou une expression calculée utilisant des colonnes existantes. Les nouvelles colonnes sont ajoutées à droite du DataFrame.
import pandas as pd
df = pd.DataFrame({'price': [10.0, 20.0, 15.0], 'qty': [3, 5, 2]})
df['revenue'] = df['price'] * df['qty']
df['currency'] = 'USD'
print(df)Ingénierie des variables : colonnes calculées
L’une des opérations les plus courantes sur un DataFrame consiste à créer des variables dérivées à partir de colonnes existantes. Vous pouvez calculer des totaux cumulés, des ratios, des indicateurs ou encoder des valeurs catégorielles dans une seule expression vectorisée. Ces colonnes calculées se mettent automatiquement à jour lorsque les colonnes sources changent, à condition de les recalculer, ce qui facilite la reproductibilité des pipelines d’ingénierie des variables.
import pandas as pd
df = pd.DataFrame({'salary': [50000, 80000, 60000],
'bonus': [5000, 12000, 7000]})
df['total_comp'] = df['salary'] + df['bonus']
df['bonus_pct'] = (df['bonus'] / df['salary'] * 100).round(1)
print(df)Utiliser assign() pour chaîner les méthodes
df.assign(new_col=expression) renvoie un nouveau DataFrame avec la colonne ajoutée, sans modifier l’original. Contrairement à l’affectation directe, cette méthode s’intègre naturellement dans une chaîne de méthodes. Vous pouvez ajouter plusieurs colonnes en un seul appel, et les expressions des colonnes suivantes peuvent faire référence aux colonnes précédentes définies dans le même appel à assign() à l’aide de fonctions lambda.
import pandas as pd
df = pd.DataFrame({'x': [1, 2, 3], 'y': [4, 5, 6]})
result = (df
.assign(sum_xy=lambda d: d['x'] + d['y'])
.assign(ratio=lambda d: d['x'] / d['sum_xy'])
)
print(result)Renommer des colonnes avec rename()
df.rename(columns={'old': 'new'}) renvoie un nouveau DataFrame dont les colonnes ont été renommées. Transmettez un dictionnaire pour renommer certaines colonnes sans modifier les autres. Vous pouvez également renommer avec une fonction : df.rename(columns=str.upper) met en majuscules tous les noms de colonnes. Renommez toujours les colonnes avant de fusionner des DataFrames provenant de sources différentes afin de garantir l’alignement des colonnes clés.
import pandas as pd
df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [5, 6]})
renamed = df.rename(columns={'a': 'alpha', 'b': 'beta'})
print(renamed.columns.tolist()) # ['alpha', 'beta', 'c']
# Rename all columns to uppercase
print(df.rename(columns=str.upper).columns.tolist()) # ['A', 'B', 'C']Nettoyer les noms de colonnes
Dans les données réelles, les noms de colonnes contiennent souvent des espaces, des caractères spéciaux ou des majuscules incohérentes. Une étape courante de prétraitement consiste à les normaliser : supprimer les espaces superflus, les convertir en minuscules et remplacer les espaces par des caractères de soulignement. Les colonnes deviennent ainsi accessibles avec la notation par points et les problèmes de guillemets dans les chaînes de requête de type SQL sont évités.
import pandas as pd
df = pd.DataFrame(columns=['First Name', 'Last Name', 'Email Address'])
df.columns = (df.columns
.str.strip()
.str.lower()
.str.replace(' ', '_', regex=False)
)
print(df.columns.tolist()) # ['first_name', 'last_name', 'email_address']Insérer une colonne à une position précise
df.insert(loc, column, value) insère une colonne à la position entière loc et décale les autres colonnes vers la droite. Cette méthode est utile lorsque vous souhaitez placer la nouvelle colonne à côté de colonnes associées plutôt qu’à la fin. Elle modifie le DataFrame sur place, contrairement à assign().
import pandas as pd
df = pd.DataFrame({'name': ['A', 'B'], 'score': [80, 90]})
df.insert(1, 'grade', ['B', 'A'])
print(df)
# name grade score
# 0 A B 80
# 1 B A 90Supprimer des colonnes avec drop()
df.drop(columns=['col1', 'col2']) renvoie un nouveau DataFrame sans ces colonnes. L’ancienne syntaxe df.drop(['col1', 'col2'], axis=1) fonctionne également, mais elle est moins lisible. Pour supprimer les colonnes sur place, transmettez inplace=True. Dans les pipelines, préférez toujours renvoyer un nouveau DataFrame afin de conserver l’original pour le comparer ou revenir en arrière.
import pandas as pd
df = pd.DataFrame({'a': [1,2], 'b': [3,4], 'c': [5,6], 'd': [7,8]})
cleaned = df.drop(columns=['b', 'd'])
print(cleaned.columns.tolist()) # ['a', 'c']Supprimer des lignes avec drop()
df.drop(index=['r1', 'r2']) supprime des lignes par étiquette. df.drop([0, 2]) supprime les lignes 0 et 2 d’un index entier par défaut. La suppression de lignes sert couramment à retirer des enregistrements incorrects connus, des valeurs aberrantes ou des lignes de test après le nettoyage des données. Pour une suppression conditionnelle, préférez l’indexation booléenne afin de conserver un code lisible.
import pandas as pd
df = pd.DataFrame({'x': [10, 20, 30, 40]}, index=['a', 'b', 'c', 'd'])
trimmed = df.drop(index=['b', 'd'])
print(trimmed)
# x
# a 10
# c 30pop() pour supprimer et renvoyer une colonne
df.pop('col') supprime la colonne du DataFrame sur place et la renvoie sous forme de série. Cette méthode est utile lorsque vous devez extraire une colonne cible (étiquette) d’une matrice de variables : vous la supprimez du DataFrame et la conservez séparément pour l’utiliser comme variable y dans un modèle.
import pandas as pd
df = pd.DataFrame({'feature1': [1,2], 'feature2': [3,4], 'target': [0,1]})
y = df.pop('target') # removes column and returns as Series
X = df # remaining features
print(y.tolist()) # [0, 1]
print(X.columns.tolist()) # ['feature1', 'feature2']Réordonner les colonnes
Pour réordonner les colonnes, sélectionnez-les dans l’ordre souhaité avec df[['col3', 'col1', 'col2']]. Pour les grands DataFrames, lorsque vous souhaitez seulement déplacer quelques colonnes, calculez l’ordre souhaité par programmation : placez les colonnes prioritaires au début et laissez les autres suivre. Il s’agit d’une étape courante de préparation des rapports avant une exportation vers Excel.
import pandas as pd
df = pd.DataFrame({'id': [1,2], 'score': [80,90], 'name': ['A','B']})
# Move 'name' and 'id' to front
cols = ['name', 'id'] + [c for c in df.columns if c not in ['name', 'id']]
df = df[cols]
print(df.columns.tolist()) # ['name', 'id', 'score']Mettre à jour les valeurs d’une colonne existante
La mise à jour de toutes les valeurs d’une colonne existante utilise la même syntaxe d’affectation que l’ajout d’une nouvelle colonne : df['col'] = new_values. Utilisez df.loc[mask, 'col'] = value pour ne mettre à jour que les lignes correspondant à une condition. N’utilisez jamais l’indexation chaînée pour les mises à jour : utilisez toujours .loc afin d’éviter le SettingWithCopyWarning.
import pandas as pd
df = pd.DataFrame({'name': ['Alice', 'Bob', 'Carol'], 'score': [45, 80, 92]})
# Set scores below 50 to 50 (floor)
df.loc[df['score'] < 50, 'score'] = 50
print(df['score'].tolist()) # [50, 80, 92]Vérification rapide
Testez votre compréhension de l’ajout et de la suppression de colonnes dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que les nouvelles colonnes sont ajoutées par affectation ou avec assign(), qui se prête au chaînage de méthodes, que rename() modifie les noms de colonnes sans changer les données et que drop() supprime des colonnes ou des lignes et renvoie par défaut un nouveau DataFrame. Ensuite, nous utiliserons head(), tail(), info() et describe() pour établir rapidement le profil de n’importe quel DataFrame.
Questions Fréquemment Posées
La leçon « Ajouter et supprimer des colonnes » est-elle gratuite ?
Oui — le texte complet de « Ajouter et supprimer des colonnes » 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 « Ajouter et supprimer des colonnes » ?
Ajoutez de nouvelles colonnes calculées, renommez celles qui existent et supprimez les colonnes ou lignes indésirables avec drop(). 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 3 sur 4.
Combien de temps prend la leçon « Ajouter et supprimer des colonnes » ?
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
- Créer des DataFrames
- Sélectionner des colonnes et des lignes
- Ajouter et supprimer des colonnes
- Inspection de base des DataFrames