Sélectionner des colonnes par motif
Utilisez filter(like=), filter(regex=) et les compréhensions de listes pour sélectionner les colonnes dont le nom correspond à un motif.
Sélectionner des colonnes par motif est une leçon Pandas & NumPy Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.
Pourquoi sélectionner les colonnes selon un modèle ?
Les DataFrames provenant de sources réelles comportent souvent des dizaines, voire des centaines de colonnes, et vous en utilisez rarement la totalité. Lorsque les colonnes suivent une convention de nommage — des préfixes comme sales_, des suffixes comme _2023 ou certains modèles de mots-clés — les sélectionner selon un modèle de nom est bien plus facile à maintenir que d’énumérer explicitement chaque colonne. Si le schéma évolue, la sélection fondée sur un modèle s’adapte automatiquement.
Pandas fournit deux outils principaux : la méthode filter() et les compréhensions de liste appliquées à df.columns.
import pandas as pd
df = pd.DataFrame({
'sales_jan': [100, 200],
'sales_feb': [150, 250],
'cost_jan': [50, 80],
'cost_feb': [60, 90],
'profit': [140, 280]
})
print(df.columns.tolist())
# ['sales_jan', 'sales_feb', 'cost_jan', 'cost_feb', 'profit']filter(like=) pour rechercher une sous-chaîne
DataFrame.filter(like='substring') sélectionne les colonnes dont le nom contient la sous-chaîne indiquée, où qu’elle se trouve dans le nom (en respectant la casse). Par défaut, l’opération s’effectue sur l’axe des colonnes et renvoie un nouveau DataFrame contenant uniquement les colonnes correspondantes.
C’est l’outil de sélection selon un modèle le plus simple : aucune connaissance des expressions régulières n’est nécessaire, il suffit d’indiquer la sous-chaîne recherchée.
import pandas as pd
df = pd.DataFrame({
'sales_jan': [100, 200],
'sales_feb': [150, 250],
'cost_jan': [50, 80],
'revenue_q1': [110, 210]
})
# Select columns whose name contains 'sales'
sales_cols = df.filter(like='sales')
print(sales_cols)
# sales_jan sales_feb
# 0 100 150
# 1 200 250filter(regex=) pour rechercher un modèle
DataFrame.filter(regex='pattern') sélectionne les colonnes dont le nom correspond à l’expression régulière indiquée. Cette méthode est plus puissante que like=, car les expressions régulières permettent de rechercher des préfixes, des suffixes, la position de chiffres ou des modèles complexes. L’expression régulière est recherchée n’importe où dans le nom de la colonne ; elle n’est pas limitée au début.
import pandas as pd
df = pd.DataFrame({
'q1_revenue': [100],
'q2_revenue': [200],
'q1_cost': [40],
'q2_cost': [60],
'annual_total': [360]
})
# Select columns ending with '_revenue'
revenue_cols = df.filter(regex='_revenue$')
print(revenue_cols)
# q1_revenue q2_revenue
# 0 100 200
# Select columns starting with 'q' (quarter columns)
quarter_cols = df.filter(regex='^q')
print(quarter_cols.columns.tolist())
# ['q1_revenue', 'q2_revenue', 'q1_cost', 'q2_cost']Compréhension de liste sur df.columns
Pour une flexibilité maximale, parcourez df.columns à l’aide d’une compréhension de liste et appliquez n’importe quelle méthode Python de manipulation des chaînes afin de construire votre liste de colonnes. Cette approche fonctionne avec startswith, endswith, contains, les vérifications de longueur des chaînes ou toute logique personnalisée qu’une expression régulière seule ne permet pas d’exprimer.
import pandas as pd
df = pd.DataFrame({
'age': [25, 30],
'age_group': ['young', 'mid'],
'income': [50000, 70000],
'income_tax': [8000, 12000],
'name': ['Alice', 'Bob']
})
# Select columns that start with 'income'
income_cols = [c for c in df.columns if c.startswith('income')]
print(df[income_cols])
# income income_tax
# 0 50000 8000
# 1 70000 12000Sélectionner selon le suffixe du nom de colonne
La méthode str.endswith() appliquée à l’Index des colonnes est la manière la plus claire de sélectionner des colonnes selon leur suffixe. Les objets Index de Pandas prennent en charge les accesseurs .str, ce qui permet d’appliquer des opérations sur les chaînes à tous les noms de colonnes en une seule fois, puis d’utiliser le tableau booléen obtenu pour sélectionner les colonnes du DataFrame.
import pandas as pd
df = pd.DataFrame({
'revenue_2022': [100],
'cost_2022': [40],
'revenue_2023': [150],
'cost_2023': [55],
'notes': ['ok']
})
# Use Index.str.endswith for suffix selection
cols_2023 = df.columns[df.columns.str.endswith('_2023')]
print(df[cols_2023])
# revenue_2023 cost_2023
# 0 150 55Supprimer des colonnes selon un motif
Il est parfois plus simple d’exclure un ensemble de colonnes plutôt que d’indiquer celles à conserver. Combinez la sélection par motif avec drop() ou utilisez le complément : construisez une liste des colonnes à supprimer, puis appelez df.drop(columns=cols_to_drop). Vous pouvez également récupérer les colonnes que vous ne voulez pas conserver et les transmettre à drop.
import pandas as pd
df = pd.DataFrame({
'id': [1, 2],
'name': ['A', 'B'],
'temp_col1': [0, 0],
'temp_col2': [0, 0],
'score': [90, 80]
})
# Drop columns whose name starts with 'temp_'
temp_cols = [c for c in df.columns if c.startswith('temp_')]
cleaned = df.drop(columns=temp_cols)
print(cleaned)
# id name score
# 0 1 A 90
# 1 2 B 80Sélectionner des colonnes numériques avec select_dtypes
Lorsque vous souhaitez sélectionner des colonnes selon un type de données particulier plutôt que selon un motif de nom, utilisez df.select_dtypes(include=). En passant include='number', vous sélectionnez toutes les colonnes numériques (entiers et nombres à virgule flottante), include='object' sélectionne les colonnes contenant des chaînes, et include='datetime' sélectionne les colonnes de date et d’heure.
C’est particulièrement utile avant d’appliquer des agrégations numériques : vous n’appelez ainsi jamais accidentellement mean() sur une colonne textuelle.
import pandas as pd
df = pd.DataFrame({
'name': ['Alice', 'Bob'],
'age': [25, 30],
'salary': [50000.0, 70000.0],
'dept': ['Eng', 'HR']
})
# Select only numeric columns
numeric_df = df.select_dtypes(include='number')
print(numeric_df)
# age salary
# 0 25 50000.0
# 1 30 70000.0
# Exclude numeric columns
text_df = df.select_dtypes(exclude='number')
print(text_df)
# name dept
# 0 Alice Eng
# 1 Bob HRfilter() sur l’Index des lignes avec axis=0
Par défaut, filter() agit sur les colonnes (axis=1). Vous pouvez toutefois aussi filtrer les lignes selon leur étiquette d’index en passant axis=0. Cette technique est utile lorsque votre DataFrame possède des étiquettes d’index textuelles pertinentes et que vous souhaitez sélectionner les lignes dont l’étiquette d’index correspond à un motif — une astuce moins courante, mais pratique.
import pandas as pd
df = pd.DataFrame({
'value': [10, 20, 30, 40]
}, index=['alpha_a', 'beta_b', 'alpha_c', 'gamma_d'])
# Filter rows by index label pattern
alpha_rows = df.filter(like='alpha', axis=0)
print(alpha_rows)
# value
# alpha_a 10
# alpha_c 30Combiner des motifs de sélection de colonnes
Les tâches réelles de sélection de colonnes combinent souvent plusieurs stratégies : une expression régulière pour trouver un premier ensemble, puis un filtrage supplémentaire avec une compréhension de liste. Construire la liste des colonnes étape par étape et l’examiner avant la sélection permet d’éviter les erreurs silencieuses, comme supprimer accidentellement des colonnes nécessaires ou inclure des colonnes indésirables.
import pandas as pd
df = pd.DataFrame(columns=[
'user_id', 'user_name', 'user_email',
'product_id', 'product_name', 'product_price',
'order_total', 'order_date'
])
# Step 1: columns that start with 'user_' or 'order_'
step1 = [c for c in df.columns if c.startswith('user_') or c.startswith('order_')]
# Step 2: exclude email (PII)
final_cols = [c for c in step1 if 'email' not in c]
print(final_cols)
# ['user_id', 'user_name', 'order_total', 'order_date']Réorganiser les colonnes selon un motif
La sélection fondée sur des motifs est également utile pour réorganiser les colonnes. Sélectionnez d’abord les colonnes souhaitées (par exemple, ID et métadonnées), puis ajoutez les colonnes restantes dans un ordre précis. La réorganisation facilite la lecture des DataFrames et garantit une structure cohérente des résultats.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'metric_b': [1], 'metric_a': [2],
'id': [10], 'label': ['x'],
'metric_c': [3]
})
# Put id and label first, then sort metric columns alphabetically
id_cols = ['id', 'label']
metric_cols = sorted([c for c in df.columns if c.startswith('metric')])
ordered = df[id_cols + metric_cols]
print(ordered.columns.tolist())
# ['id', 'label', 'metric_a', 'metric_b', 'metric_c']Exemple pratique : données d’enquête larges
Un cas d’utilisation classique de la sélection par motif est celui d’un jeu de données d’enquête large, dans lequel chaque question génère plusieurs colonnes comme q1_score, q1_text, q2_score, etc. Vous pouvez extraire toutes les colonnes de scores avec une seule expression régulière, calculer leur moyenne et séparer les colonnes d’analyse des réponses en texte libre.
import pandas as pd
survey = pd.DataFrame({
'respondent_id': [1, 2, 3],
'q1_score': [4, 3, 5],
'q2_score': [3, 4, 4],
'q3_score': [5, 5, 3],
'q1_comment': ['good', 'ok', 'great'],
'q2_comment': ['fine', 'nice', 'meh']
})
# All score columns
score_cols = survey.filter(regex='_score$').columns
survey['avg_score'] = survey[score_cols].mean(axis=1)
print(survey[['respondent_id', 'avg_score']])
# respondent_id avg_score
# 0 1 4.000000
# 1 2 4.000000
# 2 3 4.000000Vérification rapide
Vérifiez votre compréhension de la sélection de colonnes selon un motif.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que filter(like=) sélectionne les colonnes contenant une sous-chaîne, que filter(regex=) utilise des expressions régulières pour une mise en correspondance souple des motifs, et que les compréhensions de liste sur df.columns associées aux méthodes de chaînes de Python offrent une flexibilité maximale. Utilisez select_dtypes() pour sélectionner les colonnes selon leur type de données. Nous allons maintenant voir comment détecter les valeurs manquantes (NaN) dans les DataFrames.
Questions Fréquemment Posées
La leçon « Sélectionner des colonnes par motif » est-elle gratuite ?
Oui — le texte complet de « Sélectionner des colonnes par motif » 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 « Sélectionner des colonnes par motif » ?
Utilisez filter(like=), filter(regex=) et les compréhensions de listes pour sélectionner les colonnes dont le nom correspond à un motif. 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 4 sur 4.
Combien de temps prend la leçon « Sélectionner des colonnes par motif » ?
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
- Indexation booléenne des DataFrames
- La méthode query()
- Filtres isin() et between()
- Sélectionner des colonnes par motif