Comment automatiser le prétraitement des données en Python ?

J’automatise le prétraitement des données en Python avec des one‑liners pandas fiables (nettoyage des en‑têtes, strip(), pd.to_numeric/to_datetime, imputation, mapping, drop_duplicates) pour réduire erreurs et temps de préparation (pandas documentation). Suivez les exemples pour implémenter un pipeline réutilisable.

Comment standardiser les en-têtes et supprimer les espaces

Standardisez d’abord les noms de colonnes et nettoyez les chaînes pour éviter des bugs en aval.
Je normalise systématiquement les en-têtes parce que cela assure la cohérence entre jeux de données, prévient des erreurs de clé (KeyError) lors des jointures ou des scripts d’automatisation, et facilite l’écriture de pipelines reproductibles.

Par exemple, un petit jeu de données factice :

  Client ID   | Amount € | STATUS
" 123 "       | "100.0"  | " active "
None          | 200      | "inactive"
"

Voici les commandes essentielles à appliquer (insérées telles quelles) :

df.columns = df.columns.str.strip().str.lower().str.replace(‘ ‘, ‘_’)

str_cols = df.select_dtypes(include=[‘object’]).columns
for c in str_cols:
df[c] = df[c].str.strip()

La ligne précédente détecte les colonnes de type object (chaînes de caractères) avec df.select_dtypes, ce qui évite d’appliquer strip() sur des numériques et de provoquer des erreurs ou conversions involontaires.

Voici quelques pièges à surveiller avant et après traitement :

• Différence entre None (valeur Python) et NaN (Not a Number, valeur numpy/pandas) qui se comportent différemment selon les opérations de chaîne.
• Encodages (UTF-8 vs CP1252) pouvant introduire des caractères invisibles ou accents mal décodés.
• Espaces non-breaking (U+00A0) ou caractères Unicode similaires qui ne sont pas supprimés par strip() classique.

Je recommande ces vérifications post-traitement simples pour valider l’opération :

• Contrôler la liste des colonnes : df.columns.tolist()
• Vérifier les longueurs maximales des chaînes sur les colonnes string : df[str_cols].apply(lambda s: s.str.len().max())

df.columns = df.columns.str.strip().str.lower().str.replace(‘ ‘, ‘_’)	Normaliser les noms de colonnes	» Client ID  » → « client_id »
str_cols = df.select_dtypes(include=[‘object’]).columns for c in str_cols: df[c] = df[c].str.strip()	Nettoyer les chaînes sans toucher aux numériques	» active  » → « active »
df.columns.tolist() / df[str_cols].apply(lambda s: s.str.len().max())	Vérifications post-traitement	Confirmer noms et longueurs attendues

Comment convertir chiffres et dates sans provoquer d’erreur

Réponse: Utiliser pd.to_numeric et pd.to_datetime avec errors=’coerce’ pour convertir en toute sécurité et obtenir NaN/NaT plutôt qu’une exception.
Je montre pourquoi c’est important, comment ça marche et quoi faire ensuite.

df[‘amount’] = pd.to_numeric(df[‘amount’].str.replace(‘,’,  »), errors=’coerce’)

df[‘date’] = pd.to_datetime(df[‘date’], errors=’coerce’, dayfirst=False)

Je crée d’abord un exemple concret pour tester les cas courants.

import pandas as pd
# Exemple de DataFrame contenant nombres mal formés et dates hétérogènes
df = pd.DataFrame({
    'amount': ['1,234', 'n/a', '—', '45.6'],
    'date': ['2020-01-01', '01/02/20', 'not a date', '2020-12-31']
})
# Conversion sûre
df['amount'] = pd.to_numeric(df['amount'].str.replace(',', ''), errors='coerce')
df['date'] = pd.to_datetime(df['date'], errors='coerce', dayfirst=False)
print(df)

Je décris les modes d’erreurs disponibles et leur comportement.

• raise: Mode par défaut. Lancer une exception dès qu’une valeur ne peut pas être convertie, ce qui stoppe le pipeline de prétraitement.
• coerce: Remplacer les valeurs impossibles par NaN (Not a Number) pour les numériques ou NaT (Not a Time) pour les dates, permettant de poursuivre le flux.
• ignore: Retourner la série d’origine sans conversion si une erreur est rencontrée, utile pour tests rapides mais risqué en production.

Je précise le comportement des NaN/NaT pour les étapes suivantes.

• Imputation: NaN/NaT doivent être traités explicitement (moyenne, médiane, forward-fill, ou valeur sentinel) car les opérations statistiques ignorent souvent NaN et donnent des résultats biaisés si non documentés.
• Filtrage: Filtrer rows avec df.dropna(subset=[‘amount’,’date’]) ou logger avant suppression pour audit.

Je donne trois bonnes pratiques opérationnelles.

• Garder une copie brute: Conserver les données d’origine pour traçabilité et réconciliation.
• Consigner les lignes converties en NaN/NaT: Conserver un log ou un extrait pour audit et correction manuelle éventuelle.
• Utiliser une inference de dtype contrôlée: Forcer dtype attendu ou valider types après conversion pour éviter surprises (ex: pandas.astype).

Je traite rapidement la question des fuseaux (timezone).

• Convertir en tz-aware si vous travaillez avec plusieurs fuseaux horaires; pandas gère tz-aware avec tz_localize/tz_convert. Mélanger tz-naive et tz-aware entraîne des erreurs et fausse les agrégations temporelles (resample, groupby par période).

Commande	Sortie attendue	Action recommandée
pd.to_numeric(…, errors=’raise’)	Exception si donnée non convertissable	Utiliser en debug; éviter en production
pd.to_numeric(…, errors=’coerce’)	NaN pour valeurs invalides	Logger les lignes et imputer ou filtrer
pd.to_datetime(…, errors=’coerce’)	NaT pour dates invalides	Localiser fuseau si nécessaire puis agréger

Source: Documentation pandas (pandas.to_numeric et pandas.to_datetime) pour le comportement exact des paramètres.

Comment imputer et normaliser les catégories

Remplir intelligemment les manques et regrouper variantes textuelles améliore la qualité analytique.
Je privilégie des règles simples et reproductibles : médiane pour les numériques, mode pour les catégorielles, et un mapping pour standardiser les libellés.

df[‘price’] = df[‘price’].fillna(df[‘price’].median())

mode_city = df[‘city’].mode()
if not mode_city.empty:
df[‘city’] = df[‘city’].fillna(mode_city[0])

mapping = {‘nyc’: ‘new york’, ‘new york city’: ‘new york’, ‘ny’: ‘new york’}
df[‘city’] = df[‘city’].str.strip().str.lower().map(mapping).fillna(df[‘city’].str.strip().str.lower())

Je recommande la médiane pour les colonnes numériques parce qu’elle est résiliente aux outliers, contrairement à la moyenne qui peut être tirée vers les extrêmes.
Je recommande le mode pour les colonnes catégorielles puisque c’est la valeur la plus fréquente.
Je signale que pandas.Series.mode() peut retourner plusieurs valeurs en cas d’égalité ; mode()[0] prend la première valeur retournée — choix déterministe mais arbitraire si plusieurs modalités sont ex æquo.

Je propose de standardiser les catégories via un dictionnaire de mapping afin de regrouper les variantes textuelles (orthographe, abréviations, casse).
Je préserve les autres valeurs non mappées en appliquant fillna() sur la version nettoyée (strip + lower) pour éviter de perdre des modalités inconnues.

Je valide systématiquement après imputation : comptage des valeurs manquantes (isna().sum()), distribution avant/après (value_counts(normalize=True) ou hist() pour numériques).
Je conserve un log d’imputation contenant la colonne, la méthode utilisée, la valeur appliquée, le pourcentage d’éléments imputés et un horodatage.
Je conseille d’enregistrer ces logs en CSV ou dans un système d’observabilité.

Méthode	Commande	Quand l’utiliser
Médiane	df[‘col’] = df[‘col’].fillna(df[‘col’].median())	Numeriques avec outliers
Mode	mode = df[‘cat’].mode(); df[‘cat’] = df[‘cat’].fillna(mode[0])	Catégorielles fréquentes; tie-break arbitraire si égalité
Mapping + normalisation	map(mapping).fillna(df[‘cat’].str.strip().str.lower())	Regrouper variantes textuelles sans perdre valeurs inconnues

Comment dédupliquer et automatiser un pipeline réutilisable

Dédupliquez de façon ciblée puis enchaînez les étapes en pipeline pour reproductibilité.
La déduplication doit refléter la logique métier plutôt qu’une suppression aveugle.
L’argument subset de pandas.DataFrame.drop_duplicates permet de contrôler quelles colonnes définissent l’unicité ; par exemple subset=[‘user_name’] va supprimer les lignes où le nom d’utilisateur se répète, alors que subset=[‘user_name’,’email’] exige qu’à la fois le nom et l’email soient identiques pour être considérés comme doublons.
Le paramètre keep indique quelle occurrence conserver : ‘first’ conserve la première, ‘last’ conserve la dernière et False supprime toutes les occurrences doublonnées.
Utilisez le paramètre keep pour préserver la ligne la plus fraîche ou enrichie selon vos règles métier.

df = df.drop_duplicates(subset=[‘user_name’], keep=’last’)

Signature : def preprocess(df): # Pseudocode : NormaliserEnTetes -> StripStrings -> ConvertirTypes -> ImputerValeurs -> MapperValeurs -> Deduplicater -> Retourner df.
Chaque étape doit être encapsulée en petite fonction pure pour faciliter les tests et la réutilisabilité.

Ajoutez des checkpoints entre étapes pour valider l’intégrité des transformations.
Parmi les contrôles simples à placer : assertions de taille (rows/cols), comptage des valeurs nulles sur colonnes critiques, vérification qu’il n’existe plus de doublons selon subset choisi.
Écrivez des tests unitaires (pytest) qui alimentent le pipeline avec jeux de données minimalistes (cas limite, valeurs manquantes, doublons) et valident l’effet attendu.

Générez un rapport de traitement à la fin du pipeline contenant : nombre initial de lignes, nombre final de lignes, doublons supprimés, colonnes modifiées, valeurs imputées par colonne.
Sérialisez ce rapport en JSON ou CSV pour traçabilité et audit.

Normaliser en-têtes	lower(), replace spaces	Colonnes conformes au schéma attendu
Strip	df[col]=df[col].str.strip()	Pas d’espaces en tête/fin
Conversions types	astype(), to_datetime()	Types matchent le schéma
Imputation	fillna(), SimpleImputer	Nb valeurs imputées par colonne
Mapping	map(), replace()	Valeurs normalisées
Déduplication	drop_duplicates(subset=…, keep=…)	Doublons restants = 0 selon subset

Prêt à nettoyer vos données pour des analyses fiables et rapides ?

En synthèse, un prétraitement automatisé repose sur quelques règles simples : standardiser noms et chaînes, convertir chiffres et dates avec pd.to_numeric/to_datetime en mode ‘coerce’, imputer par médiane/mode, normaliser catégories via mapping et supprimer les doublons ciblés. J’insiste sur la reproductibilité : versionner le pipeline, journaliser les imputations et valider chaque étape. Vous gagnerez du temps, réduirez les erreurs analytiques et rendrez vos datasets exploitables immédiatement pour le reporting ou le machine learning.

FAQ

• Que signifie errors=’coerce’ dans pd.to_numeric et pd.to_datetime ?
  errors=’coerce’ convertit les valeurs non convertibles en NaN (pour numeric) ou NaT (pour datetime) au lieu de lever une exception, ce qui permet de continuer le pipeline et d’identifier ensuite ces valeurs pour imputation ou contrôle.
• Quelle méthode d’imputation choisir pour les colonnes numériques ?
  La médiane est souvent préférable car elle est robuste aux outliers. Utilisez la moyenne si la distribution est proche d’une loi normale et que les outliers ont été gérés.
• Comment standardiser des variantes textuelles de mêmes catégories ?
  Normalisez la casse et les espaces puis appliquez un dictionnaire de mapping (ex: ‘nyc’,’new york city’ → ‘new york’). Complétez avec fillna pour garder les valeurs non mappées.
• Faut-il conserver une copie brute des données avant nettoyage ?
  Oui. Conserver l’original permet d’auditer les transformations, retracer les imputations et reproduire les analyses. Versionnez le dataset et journalisez les modifications.
• Combien de temps prend habituellement le prétraitement des données ?
  Plusieurs études estiment que les data practitioners passent une part majoritaire de leur temps au nettoyage (fréquemment citée entre 60 et 80%). Automatiser les étapes répétitives réduit fortement ce coût et les erreurs humaines.

 

 

A propos de l’auteur

Franck Scandolera — expert & formateur en tracking server-side, Analytics Engineering, automatisation No/Low Code (n8n) et intégration de l’IA en entreprise. Responsable de l’agence webAnalyste et de l’organisme de formation Formations Analytics. Références clients : Logis Hôtel, Yelloh Village, BazarChic, Fédération Française de Football, Texdecor. Disponible pour aider les entreprises : contactez‑moi.