Standardiser les catégories incohérentes
Uniformisez les colonnes de catégories en texte libre en associant les alias, en corrigeant les fautes par rapprochement approximatif et en imposant une liste canonique.
Standardiser les catégories incohérentes 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.
Le problème des catégories incohérentes
Lorsque des données catégorielles sont saisies par des personnes, un même concept peut apparaître sous de nombreuses graphies différentes : Electronics, electronics, ELECTRONICS, Electronicss. Un groupby sur cette colonne produit des dizaines de petits groupes au lieu d’un seul groupe pertinent. Standardiser les catégories en une liste canonique est l’une des étapes de nettoyage les plus importantes avant toute agrégation ou création de variables pour l’apprentissage automatique.
import pandas as pd
df = pd.read_csv('products.csv')
print(df['category'].value_counts().head(20))Normaliser la casse et les espaces
La première étape de standardisation, et la plus simple, consiste à normaliser la casse et les espaces. Appliquez .str.strip().str.lower() pour supprimer les espaces de début et de fin et convertir toutes les valeurs en minuscules avant toute autre comparaison. Cette seule étape regroupe de nombreuses variantes : Electronics, electronics et ' Electronics ' deviennent toutes electronics après normalisation.
df['category_clean'] = df['category'].str.strip().str.lower()
print('Before:', df['category'].nunique())
print('After:', df['category_clean'].nunique())Associer les alias avec un dictionnaire
Après la normalisation de la casse, de nombreuses variantes restent distinctes en raison d’abréviations, de synonymes ou d’anciens noms. Construisez un dictionnaire d’association des alias dont les clés sont les graphies variantes et les valeurs, la forme canonique. Appliquez-le avec df['category_clean'].map(alias_map).fillna(df['category_clean']) — fillna conserve les valeurs absentes du dictionnaire au lieu de les remplacer par NaN.
alias_map = {
'elect': 'electronics',
'elec': 'electronics',
'tech': 'electronics',
'clothing': 'apparel',
'clothes': 'apparel',
'garments': 'apparel'
}
df['category_clean'] = df['category_clean'].map(alias_map).fillna(df['category_clean'])
print(df['category_clean'].value_counts().head())Utiliser str.replace pour corriger des motifs
Certains noms de catégories comportent des erreurs de formatage récurrentes, comme des espaces doubles ou des chiffres en fin de chaîne. Utilisez .str.replace() avec une expression régulière pour corriger ces motifs dans toutes les lignes en une seule fois. Par exemple, .str.replace(r'\s+', ' ', regex=True) réduit plusieurs espaces à un seul, tandis que .str.replace(r'\d+$', '', regex=True) supprime les chiffres placés en fin de nom de catégorie.
df['category_clean'] = (
df['category_clean']
.str.replace(r'\s+', ' ', regex=True) # collapse spaces
.str.replace(r'\d+$', '', regex=True) # strip trailing numbers
.str.strip()
)
print(df['category_clean'].value_counts())Recherche approximative avec difflib
Lorsque les fautes de frappe sont imprévisibles, utilisez la recherche approximative pour trouver, pour chaque variante, la catégorie canonique la plus proche. La fonction intégrée à Python difflib.get_close_matches() renvoie les meilleures correspondances parmi une liste de catégories valides, selon la similarité des chaînes. Appliquez-la comme fonction auxiliaire avec df['category'].apply() pour résoudre les variantes que map() ne peut pas détecter seule.
from difflib import get_close_matches
CANONICAL = ['electronics', 'apparel', 'home', 'sports', 'beauty']
def fuzzy_fix(val):
matches = get_close_matches(str(val).lower().strip(), CANONICAL, n=1, cutoff=0.7)
return matches[0] if matches else val
df['category_fuzzy'] = df['category_clean'].apply(fuzzy_fix)
print(df[['category_clean', 'category_fuzzy']].head(10))Construire une liste canonique de catégories
Définissez explicitement vos catégories canoniques plutôt que de les déduire des données. Une liste codée en dur fait passer chaque valeur par une étape de validation ; toute valeur absente de la liste est signalée comme inconnue. Conservez la liste canonique dans un fichier de configuration ou dans une colonne distincte d’un DataFrame afin de pouvoir la mettre facilement à jour lorsque l’entreprise ajoute une nouvelle catégorie de produits, sans modifier le code de nettoyage.
CANONICAL_CATEGORIES = {
'electronics', 'apparel', 'home', 'sports',
'beauty', 'food', 'toys', 'automotive'
}
df['is_known_category'] = df['category_fuzzy'].isin(CANONICAL_CATEGORIES)
unknown = df[~df['is_known_category']]['category_fuzzy'].unique()
print('Unknown categories remaining:', unknown)Gérer les catégories inconnues
Les catégories inconnues qui ne correspondent à aucune valeur canonique après la correction approximative doivent être regroupées sous le libellé Other plutôt que supprimées, afin de ne pas perdre silencieusement des lignes. Définissez-les sur 'other' avec np.where() ou une simple affectation conditionnelle. Consignez le nombre de lignes associées à 'other' et examinez-les pour repérer des motifs pouvant justifier la création d’une nouvelle catégorie canonique.
import numpy as np
df['category_final'] = np.where(
df['category_fuzzy'].isin(CANONICAL_CATEGORIES),
df['category_fuzzy'],
'other'
)
print(df['category_final'].value_counts())Imposer un type Categorical
Après la standardisation, convertissez la colonne de catégories nettoyée en type Pandas Categorical en fournissant explicitement la liste des catégories valides. Cela impose le schéma : toute tentative d'affecter une catégorie invalide déclenche une erreur. Cela réduit également l'utilisation de la mémoire en enregistrant en interne les chaînes de catégories sous forme de codes entiers, et accélère les opérations groupby sur les grands DataFrames.
df['category_final'] = pd.Categorical(
df['category_final'],
categories=list(CANONICAL_CATEGORIES) + ['other']
)
print(df['category_final'].dtype)
print(df['category_final'].cat.categories)Validation de la colonne nettoyée
Après toutes les étapes de standardisation, effectuez une validation finale : vérifiez qu'aucune valeur absente de l'ensemble canonique ne se trouve dans la colonne nettoyée. Utilisez assert df['category_final'].isin(valid_set).all(). Placez cette assertion à la fin de la fonction de nettoyage afin qu'elle soit exécutée à chaque lancement du pipeline et qu'elle détecte les régressions lorsque de nouvelles données brutes contiennent des libellés de catégories encore inconnus.
valid_set = set(CANONICAL_CATEGORIES) | {'other'}
assert df['category_final'].isin(valid_set).all(), 'Invalid category found'
print('All categories valid. Distribution:')
print(df['category_final'].value_counts())Suivi des modifications de standardisation
Créez une table des différences présentant la valeur d'origine et son remplacement nettoyé pour chaque ligne modifiée. Cette piste d'audit permet aux responsables des données d'examiner, puis d'approuver ou de rejeter, des correspondances précises. Utilisez un masque booléen pour sélectionner les lignes modifiées et comparez côte à côte les colonnes d'origine et finales. Exportez les différences au format CSV afin que les parties prenantes non techniques puissent les examiner.
changed = df['category'] != df['category_final']
diff_table = df[changed][['category', 'category_final']].drop_duplicates()
diff_table.columns = ['original', 'mapped_to']
print(f'Unique mappings applied: {len(diff_table)}')
print(diff_table)Enregistrement du jeu de données standardisé
Remplacez la colonne de catégories désordonnée d'origine par la colonne standardisée et supprimez les colonnes de travail intermédiaires avant l'enregistrement. Stockez le dictionnaire de correspondance des alias et le seuil de correction approximative dans la configuration du pipeline afin que la standardisation soit entièrement reproductible. Un nettoyage effectué deux mois plus tard sur un nouveau vidage de données doit produire des résultats identiques pour les mêmes valeurs d'entrée.
df_out = df.drop(columns=['category_clean', 'category_fuzzy', 'is_known_category'])
df_out = df_out.rename(columns={'category_final': 'category'})
df_out.to_parquet('products_clean.parquet', index=False)
print('Saved. Category distribution:')
print(df_out['category'].value_counts())Vérification rapide
Testez votre compréhension des concepts d'analyse de données présentés dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris à : normaliser la casse et les espaces comme première étape de standardisation, faire correspondre les alias et appliquer une correspondance approximative pour corriger les fautes de frappe, et imposer une liste canonique de catégories avec le type Categorical et des assertions. Nous allons maintenant explorer la validation du schéma et les assertions à l'exécution afin de protéger chaque étape du pipeline.
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 « Standardiser les catégories incohérentes » est-elle gratuite ?
Oui — le texte complet de « Standardiser les catégories incohérentes » 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 « Standardiser les catégories incohérentes » ?
Uniformisez les colonnes de catégories en texte libre en associant les alias, en corrigeant les fautes par rapprochement approximatif et en imposant une liste canonique. 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 « Standardiser les catégories incohérentes » ?
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
- Détecter et supprimer les doublons
- Détection et traitement des valeurs aberrantes
- Standardiser les catégories incohérentes
- Validation du schéma et assertions