Pandas & NumPy Academy · Leçon

Combiner et nettoyer les colonnes de texte

Concaténez plusieurs colonnes en une seule chaîne, supprimez les espaces superflus et uniformisez les libellés de catégories incohérents.

Leçon 4 sur 413 étapes

Combiner et nettoyer les colonnes de texte 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.

Concaténer des colonnes de texte

Une tâche courante de préparation des données consiste à créer une seule chaîne en combinant les valeurs de plusieurs colonnes — par exemple, créer un nom complet à partir du prénom et du nom, ou une adresse à partir de la rue, de la ville et du pays. Dans Pandas, vous concaténez les colonnes de chaînes à l’aide de l’opérateur + entre deux séries (ou entre une série et une chaîne littérale), après avoir converti les colonnes numériques en chaînes avec .astype(str).

import pandas as pd

df = pd.DataFrame({
    'first_name': ['Alice', 'Bob', 'Carol'],
    'last_name': ['Smith', 'Jones', 'White']
})

df['full_name'] = df['first_name'] + ' ' + df['last_name']
print(df['full_name'].tolist())
# ['Alice Smith', 'Bob Jones', 'Carol White']

Concaténer avec des colonnes non textuelles

Lorsque vous combinez une colonne numérique avec une colonne de chaînes, vous devez d’abord convertir la colonne numérique en chaîne à l’aide de .astype(str). L’opérateur + de Python déclenche une erreur TypeError si vous essayez d’additionner une série de chaînes et une série d’entiers. C’est une source fréquente de confusion lors de la création de clés composites ou d’étiquettes à partir de colonnes de types différents.

import pandas as pd

df = pd.DataFrame({
    'product': ['Widget', 'Gadget'],
    'version': [3, 5]
})

# Must convert int to str before concatenating
df['label'] = df['product'] + ' v' + df['version'].astype(str)
print(df['label'].tolist())
# ['Widget v3', 'Gadget v5']

<code>str.cat()</code> pour la concaténation avec séparateur

Series.str.cat(others, sep=) est la méthode native de Pandas pour concaténer plusieurs Series avec un séparateur, tout en gérant correctement les valeurs NaN. Par défaut, un NaN dans une colonne entraîne un résultat NaN pour la ligne correspondante. Transmettez na_rep='?' (ou n’importe quelle chaîne) pour remplacer NaN par un espace réservé au lieu de le propager.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'city': ['NYC', 'LA', None],
    'state': ['NY', None, 'TX'],
    'country': ['USA', 'USA', 'USA']
})

# Join with ', ' — NaN rows produce NaN by default
df['location'] = df['city'].str.cat(
    [df['state'], df['country']],
    sep=', ',
    na_rep='N/A'
)
print(df['location'].tolist())
# ['NYC, NY, USA', 'LA, N/A, USA', 'N/A, TX, USA']

Normaliser des libellés de catégories incohérents

Dans les données réelles, les colonnes de catégories contiennent souvent des libellés incohérents dus à des fautes de frappe, à des différences de casse ou à des abréviations différentes (par exemple, 'US', 'USA', 'United States'). La correction standard consiste à créer un dictionnaire de correspondance qui associe chaque variante à la forme canonique, puis à l’appliquer avec .map() ou .replace().

import pandas as pd

df = pd.DataFrame({
    'country': ['US', 'USA', 'United States', 'uk', 'UK', 'United Kingdom']
})

canonical = {
    'US': 'United States', 'USA': 'United States', 'United States': 'United States',
    'uk': 'United Kingdom', 'UK': 'United Kingdom', 'United Kingdom': 'United Kingdom'
}

df['country_clean'] = df['country'].map(canonical)
print(df['country_clean'].tolist())
# ['United States', 'United States', 'United States',
#  'United Kingdom', 'United Kingdom', 'United Kingdom']

Supprimer les espaces et uniformiser la casse

Avant de comparer ou de regrouper des colonnes de texte, vous devez toujours supprimer les espaces superflus et uniformiser la casse comme première étape du nettoyage. Deux valeurs qui semblent identiques pour un humain (' Active' et 'active') sont considérées comme différentes par Pandas à cause de l’espace initial et de la différence de capitalisation. Une chaîne de deux opérations — suppression des espaces, puis passage en minuscules — corrige ces deux problèmes.

import pandas as pd

df = pd.DataFrame({
    'status': ['  Active', 'INACTIVE', 'active ', ' Pending  ', 'ACTIVE']
})

df['status_clean'] = df['status'].str.strip().str.lower()
print(df['status_clean'].value_counts())
# active      3
# inactive    1
# pending     1

Correspondance approximative pour corriger les fautes de frappe

Lorsque des fautes de frappe empêchent une correspondance exacte, la correspondance approximative calcule des scores de similarité entre les chaînes. La bibliothèque rapidfuzz (ou la bibliothèque classique fuzzywuzzy) fournit une correspondance approximative vectorisée. Une procédure courante consiste, pour chaque valeur unique à nettoyer, à trouver la valeur canonique la plus proche au-dessus d’un seuil de similarité, puis à créer une table de corrections.

# Conceptual example (requires: pip install rapidfuzz)
from rapidfuzz import process

canonical_cities = ['New York', 'Los Angeles', 'Chicago', 'Houston']
dirty_values = ['New Yrok', 'Los Angelas', 'Chicagoo']

for dirty in dirty_values:
    best, score, _ = process.extractOne(dirty, canonical_cities)
    print(f'{dirty!r} -> {best!r} (score={score:.0f}%)')
# 'New Yrok'   -> 'New York'    (score=91%)
# 'Los Angelas'-> 'Los Angeles' (score=96%)
# 'Chicagoo'   -> 'Chicago'     (score=94%)

Séparer les cellules multivaluées avec explode()

Une cellule contient parfois plusieurs valeurs séparées par un délimiteur (par exemple, 'python,sql,pandas'). Séparez la colonne pour obtenir des listes, puis appelez .explode() afin de créer une ligne par valeur. Cela transforme une cellule large et compacte en un format long organisé, dans lequel chaque ligne contient exactement une valeur — ce qui est nécessaire pour les opérations groupby et de jointure sur ces valeurs.

import pandas as pd

df = pd.DataFrame({
    'user_id': [1, 2, 3],
    'skills': ['python,sql', 'java,kotlin,sql', 'python']
})

df['skills'] = df['skills'].str.split(',')
exploded = df.explode('skills')
print(exploded)
#    user_id   skills
# 0        1   python
# 0        1      sql
# 1        2     java
# 1        2   kotlin
# 1        2      sql
# 2        3   python

Gérer les encodages mixtes dans le texte

Les données textuelles provenant de différentes sources peuvent présenter des problèmes d’encodage — caractères inhabituels comme \xa0 (espace insécable), \u2019 (apostrophe courbe) ou caractères accentués déformés. Utilisez .str.encode('ascii', errors='replace').str.decode('ascii') pour un nettoyage rapide limité à ASCII, ou .str.normalize('NFKD') pour décomposer les accents avant de les supprimer.

import pandas as pd
import unicodedata

df = pd.DataFrame({'name': ['Caf\u00e9', 'na\u00efve', 'r\u00e9sum\u00e9']})

# Normalize and strip accents (NFKD decomposition + ascii encoding)
df['name_ascii'] = (
    df['name']
    .str.normalize('NFKD')
    .str.encode('ascii', errors='ignore')
    .str.decode('ascii')
)
print(df)
#       name name_ascii
# 0     Cafe       Cafe
# 1    naive      naive
# 2   resume     resume

Créer des clés composites

Dans de nombreux jeux de données, vous devez créer une clé composite à partir de plusieurs colonnes afin d’identifier de manière unique une ligne lors des jointures ou de la déduplication. La combinaison de colonnes textuelles nettoyées (espaces supprimés, converties en minuscules et normalisées) en une seule chaîne de clé garantit une correspondance cohérente entre les sources de données, même lorsque le même élément est écrit légèrement différemment dans chaque source.

import pandas as pd

df = pd.DataFrame({
    'first': ['  Alice', 'BOB', ' Carol'],
    'last': ['Smith ', 'JONES', 'White  '],
    'dob': ['1990-01-15', '1985-07-22', '1992-11-30']
})

df['match_key'] = (
    df['first'].str.strip().str.lower() + '|' +
    df['last'].str.strip().str.lower() + '|' +
    df['dob']
)
print(df['match_key'].tolist())
# ['alice|smith|1990-01-15', 'bob|jones|1985-07-22', 'carol|white|1992-11-30']

Imposer une liste canonique de catégories

Après le nettoyage, vérifiez que toutes les valeurs d’une colonne de texte catégorielle appartiennent à un ensemble canonique connu. Toute valeur qui n’en fait pas partie peut signaler une nouvelle catégorie légitime ou une erreur dans les données. Consignez ou signalez les valeurs inconnues pour un examen manuel au lieu de les supprimer silencieusement, afin qu’aucune ne passe inaperçue.

import pandas as pd

df = pd.DataFrame({
    'status': ['active', 'inactive', 'active', 'archived', 'unknown_status']
})

canonical = {'active', 'inactive', 'archived'}

unknown = df[~df['status'].isin(canonical)]['status'].unique()
print('Unknown statuses:', unknown.tolist())
# ['unknown_status']

# Flag unknown rows
df['status_valid'] = df['status'].isin(canonical)
print(df)

Chaîne complète de nettoyage du texte

Voici une chaîne complète de nettoyage du texte qui applique toutes les techniques de cette leçon : supprimer les espaces superflus, uniformiser la casse, corriger les abréviations, supprimer les caractères spéciaux et vérifier les valeurs par rapport à une liste canonique. C’est le type de fonction réutilisable que vous pourriez ajouter à n’importe quel module d’ingestion de données.

import pandas as pd

def clean_category_column(series, canonical_map, canonical_set):
    cleaned = (
        series
        .str.strip()
        .str.lower()
        .map(lambda x: canonical_map.get(x, x))  # fix known variants
    )
    unknown = cleaned[~cleaned.isin(canonical_set)]
    if not unknown.empty:
        print('Warning: unknown values:', unknown.unique().tolist())
    return cleaned

cmap = {'eng': 'engineering', 'hr': 'human_resources', 'mktg': 'marketing'}
cset = {'engineering', 'human_resources', 'marketing', 'finance'}

df = pd.DataFrame({'dept': ['Eng', 'HR', 'Marketing', 'MKTG', 'Legal']})
df['dept_clean'] = clean_category_column(df['dept'], cmap, cset)
print(df)

Vérification rapide

Évaluez votre compréhension de la combinaison et du nettoyage des colonnes de texte.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris à concaténer des colonnes avec l’opérateur + après avoir converti les valeurs numériques en chaînes, à utiliser str.cat(sep=) pour joindre des valeurs avec un délimiteur et gérer NaN, à appliquer une correspondance canonique avec .map() pour normaliser des libellés incohérents, et à utiliser explode() pour développer les cellules contenant des listes en lignes. Imposez des ensembles canoniques pour détecter rapidement les problèmes de qualité des données. Ensuite, vous apprendrez à trier les DataFrames selon les valeurs des colonnes.

Gratuit pour commencer

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 « Combiner et nettoyer les colonnes de texte » est-elle gratuite ?

Oui — le texte complet de « Combiner et nettoyer les colonnes de texte » 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 « Combiner et nettoyer les colonnes de texte » ?

Concaténez plusieurs colonnes en une seule chaîne, supprimez les espaces superflus et uniformisez les libellés de catégories incohérents. 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 « Combiner et nettoyer les colonnes de texte » ?

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

  1. L’accesseur .str
  2. Découper et remplacer des chaînes
  3. Recherche de motifs avec les expressions régulières
  4. Combiner et nettoyer les colonnes de texte
← Retour à Pandas & NumPy Academy