Nettoyage des données

Un tableau qui semble exact peut tout de même donner une mauvaise réponse. Le nettoyage commence par le sens des enregistrements : ce qui s’est passé, qui ou quoi chaque ligne décrit et les champs nécessaires à l’analyse.

Ce que signifie l’intégrité des données

L’intégrité des données désigne leur exactitude, leur complétude, leur cohérence et leur fiabilité tout au long de leur cycle de vie. Les valeurs doivent correspondre aux faits qu’elles sont censées enregistrer. Les informations nécessaires doivent être présentes et un même fait doit conserver le même sens lorsqu’il passe d’un système à l’autre.

L’intégrité peut être compromise lors de la saisie, du stockage, du transfert ou de l’analyse. Une personne peut se tromper en saisissant une quantité. Les copies de deux systèmes peuvent diverger, un problème lié à la réplication. Un transfert interrompu peut ne charger que la moitié d’un fichier. Trier une seule colonne peut associer chaque montant à la mauvaise commande. Les pannes de système et les modifications non autorisées peuvent aussi endommager les enregistrements.

Reconnaître le problème avant de le corriger

Les données sales sont incomplètes, incorrectes, incohérentes ou sans rapport avec la question. Des problèmes différents nécessitent des actions différentes.

Un format soigné ne garantit pas l’exactitude. Une date de livraison peut ressembler à une date tout en étant antérieure à la date de commande. Un client de test peut avoir un enregistrement complet sans être pertinent pour les ventes aux clients réels.

Suivre l’effet sur une réponse

Supposons que la commande 1003, d’un montant de 250,00, apparaisse deux fois dans un export. Compter les lignes ajoute une commande de trop et additionner les montants ajoute 250,00 de trop. Les formules peuvent fonctionner parfaitement alors que les données fournies donnent un résultat faux. Les variantes textuelles créent un autre problème : un graphique peut répartir les ventes de Lisbonne entre plusieurs libellés de ville.

Les données propres conviennent à l’analyse effectuée. Un deuxième prénom manquant n’a aucun effet sur les ventes par région. Un montant de commande manquant affecte en revanche le total des ventes. Évalue la complétude en fonction des champs nécessaires à la question, puis consigne les manques qui subsistent.

Protéger le point de départ

Conserve une copie brute intacte avant d’effectuer des modifications. Utilise un autre fichier, une feuille distincte ou la table de base de données d’origine, et nettoie une copie de travail. Un outil comme Supprimer les doublons efface des lignes de la plage sélectionnée ; la copie brute te donne une référence pour comparer et un moyen de reprendre une décision.

Suis cinq étapes : examiner, décider, appliquer, documenter et vérifier. Consigne un problème avant de choisir son traitement. Consigne chaque traitement lorsque tu l’appliques, puis vérifie le résultat par rapport aux données brutes. Les données internes nécessitent la même inspection qu’un fichier externe : des imports répétés et des changements de sens des champs se produisent aussi dans les organisations. Informe le responsable des données des problèmes récurrents de saisie ou d’export afin d’améliorer la prochaine livraison.

Le profilage des données est un examen systématique d’un jeu de données avant sa modification. Il te donne un état de référence et une liste de problèmes : la taille du tableau, le contenu de chaque colonne, les manques, les clés répétées et les valeurs à examiner.

Commencer par la structure du tableau

Détermine ce que représente une ligne, par exemple une commande ou un client. Vérifie qu’il y a une seule ligne d’en-tête et un seul type d’information par colonne. Trouve la clé, c’est-à-dire la colonne ou la combinaison de colonnes qui doit identifier un enregistrement. Un identifiant de commande répété doit être examiné ; des noms de villes répétés sont attendus.

Consigne le nombre initial de lignes. Examine ensuite le type attendu de chaque colonne, son caractère obligatoire et les valeurs autorisées. Un dictionnaire de données ou le responsable des données fournit ces informations. Les valeurs minimale et maximale peuvent révéler une date hors de la période étudiée ou une valeur de substitution comme 999 dans une colonne d’âges.

Examiner un tableur

Trie et filtre le tableau en gardant les lignes entières groupées. Trie par ordre croissant et décroissant pour trouver les cellules vides, les textes inattendus et les valeurs extrêmes. Les listes déroulantes des filtres révèlent les écritures des catégories. Les filtres d’Excel ignorent la casse : une seule catégorie affichée peut donc masquer des différences de majuscules ; utilise EXACT lorsque la casse elle-même doit être vérifiée. La mise en forme conditionnelle peut mettre en évidence les clés répétées et les valeurs hors d’un intervalle.

Pour les lignes 2 à 501, voici des contrôles utiles :

• =NBVAL(B2:B501) compte les cellules non vides.
• =NB.VIDE(B2:B501) compte les cellules vides, y compris les formules qui renvoient un texte vide.
• =NB(B2:B501) compte les cellules numériques.
• =MIN(B2:B501) et =MAX(B2:B501) donnent les valeurs numériques minimale et maximale.
• =NB.SI(C2:C501;"Lisbon") compte les entrées correspondantes sans tenir compte de la casse.

Si le nombre de cellules numériques d’une colonne de montants est inférieur au nombre de cellules non vides, examine la différence. Certaines saisies peuvent être des nombres sous forme de texte ; d’autres peuvent être des mentions comme « N/A ». Une cellule ne contenant qu’une espace mérite aussi une vérification, même si elle paraît vide.

Examiner les données avec SQL

Ces requêtes lisent les données sans les modifier :

SELECT COUNT(*) AS rows_total,
       COUNT(amount) AS amounts_present,
       COUNT(*) - COUNT(amount) AS amounts_missing,
       MIN(order_date) AS first_date,
       MAX(order_date) AS last_date
FROM orders;

COUNT(*) compte les lignes. COUNT(amount) compte les montants non NULL. Leur différence compte les montants manquants représentés par NULL, mais ne détecte pas les valeurs de substitution textuelles.

Pour examiner les valeurs des catégories et leur effectif :

SELECT city, COUNT(*) AS n
FROM orders
GROUP BY city
ORDER BY city;

GROUP BY rassemble les valeurs égales ; COUNT(*) compte les lignes de chaque groupe. NULL forme son propre groupe. L’égalité des textes suit les paramètres de comparaison de la base, appelés classement. PostgreSQL et SQLite séparent habituellement les variantes de casse ; les paramètres courants de MySQL les regroupent.

Transformer les contrôles en liste de problèmes

Pour les six montants 40, NULL, 25, 60, NULL et 35, le nombre de lignes est de 6 et le nombre de montants présents de 4 : deux montants demandent une attention particulière. Pour les villes « Lisbon », « lisbon », « Porto », NULL, « LISBON » et « Porto », une comparaison textuelle exacte trouve quatre écritures non NULL, alors que seules deux villes sont représentées.

Consigne les deux constats, ainsi que la colonne concernée et le nombre de valeurs touchées. Examine les valeurs fréquentes et extrêmes à la recherche de valeurs de substitution masquées, d’enregistrements de test et de dates comme « 1900-01-01 ». Effectuer d’abord le profilage de tout le tableau révèle aussi les dépendances : supprimer les espaces superflues peut modifier le nombre de doublons ; il faut donc attendre que les champs de comparaison soient standardisés avant de supprimer les doublons.

La validation des données vérifie que les saisies respectent les règles définissant les données acceptables. Une saisie peut être présente et bien affichée tout en enfreignant une règle. Une quantité de -3 reste invalide lorsque les quantités commandées doivent être positives.

Choisir les règles selon le sens des données

Lis le dictionnaire de données ou interroge le responsable des données. Une réservation d’hôtel à la journée peut autoriser zéro nuit ; un autre système de réservation peut en exiger au moins une. Consigne la borne réelle et indique si le champ est obligatoire.

Un contrôle du format vérifie une structure, pas la véracité du fait sous-jacent. Un contrôle élémentaire d’adresse e-mail qui cherche un « @ » et du texte de chaque côté ne peut pas confirmer qu’une boîte aux lettres existe.

Repérer les échecs dans un tableur

Place un test dans une colonne auxiliaire et recopie-le vers le bas. Pour un pourcentage numérique obligatoire en B2, =ET(ESTNUM(B2);B2>=0;B2<=100) vérifie à la fois le type et les bornes. Le contrôle du type est important, car une cellule vide peut se comporter comme zéro dans une comparaison.

Avec de véritables dates en C et D, =SI(D2<C2;"check";"ok") repère une livraison antérieure à sa commande. Vérifie séparément que les dates obligatoires ne sont pas vides. Pour les identifiants de la colonne A, =NB.SI($A$2:$A$501;A2)>1 repère les valeurs répétées. Filtre les résultats auxiliaires pour voir tous les échecs.

Lister les échecs avec SQL

SELECT * FROM orders
WHERE quantity <= 0 OR quantity IS NULL;

Cette requête trouve les quantités nulles ou négatives et les quantités manquantes. Pour vérifier les statuts :

SELECT * FROM orders
WHERE status NOT IN ('open', 'shipped', 'returned')
   OR status IS NULL;

Le contrôle explicite de NULL est important. NOT IN seul ne renvoie pas une ligne dont le statut est NULL, car le résultat de la comparaison est inconnu. Un contrôle entre champs comme delivery_date < order_date nécessite aussi des contrôles de présence séparés pour les dates obligatoires.

Prévenir les nouvelles erreurs et résoudre les anciennes

La validation des données d’Excel et de Google Sheets peut fournir une liste déroulante, limiter un intervalle de nombres ou avertir lors d’une saisie. Les types de données et les contraintes de base de données comme NOT NULL et UNIQUE imposent des règles apparentées. L’ajout d’une règle ne répare pas les anciens enregistrements ; examine-les séparément. La commande Entourer les données non valides d’Excel peut marquer les échecs existants.

Considère les âges 34, 0, 41, 230 et « forty » d’une enquête auprès d’adultes, avec une règle exigeant un nombre entier compris entre 18 et 120. « forty » échoue au contrôle du type ; 0 et 230 échouent au contrôle des bornes. Le mot a clairement pour valeur numérique 40. La valeur voulue pour 230 est incertaine : ne choisis donc pas au hasard entre 23 et 30. Récupère une valeur fiable, marque-la comme manquante ou exclus l’enregistrement, puis consigne la décision.

Une valeur inhabituelle est différente d’une valeur invalide. Une commande de 500 unités peut être réelle. Vérifie-la par rapport aux règles de commande et à l’enregistrement d’origine avant de conclure à une erreur.

Deux lignes similaires ne sont pas nécessairement un même enregistrement saisi deux fois. Un doublon décrit la même entité ou le même événement réel qu’une autre ligne. Commence par déterminer ce qui identifie cette entité ou cet événement.

Définir la clé et les règles de comparaison

Un identifiant de commande peut identifier une commande. Un nom seul est généralement une mauvaise clé client, car plusieurs personnes peuvent le partager. Même deux achats identiques le même jour peuvent être des événements réels distincts. Vérifie le sens des lignes et la clé définie par le responsable des données avant de supprimer des lignes qui se ressemblent.

Les doublons exacts correspondent dans toutes les colonnes. Les quasi-doublons désignent la même chose mais présentent de petites différences, comme une espace supplémentaire ou un numéro de téléphone modifié. Nettoie les champs de comparaison avant la recherche. Si l’adresse e-mail est la clé retenue, uniformise les espaces et la casse dans une colonne auxiliaire.

Pour les cinq adresses « ana@example.com », « ben@example.com », « Ana@Example.com », « chen@example.com » et « ben@example.com », une comparaison exacte des valeurs brutes trouve l’entrée répétée de Ben. La suppression des espaces superflues et la mise en minuscules révèlent aussi l’entrée répétée d’Ana. Trois clés client restent après la suppression de deux copies supplémentaires.

Marquer les lignes avant de les supprimer

Pour les clés nettoyées dans B2:B501 :

• =NB.SI($B$2:$B$501;B2)>1 marque chaque ligne dont la clé est répétée.
• =NB.SI($B$2:B2;B2)>1 ne marque que la deuxième occurrence et les suivantes.

La deuxième plage s’agrandit à mesure que tu recopies la formule vers le bas : la première occurrence a donc un décompte de un. NB.SI ignore la casse ; supprime d’abord les espaces superflues. Examine les groupes marqués pour repérer les informations contradictoires avant d’appliquer une règle de conservation.

Choisir ce qui est conservé

Les outils Supprimer les doublons d’Excel et de Google Sheets comparent les colonnes sélectionnées. Sélectionner uniquement l’adresse e-mail peut supprimer une ligne dont le numéro de téléphone est différent. Sélectionner toutes les colonnes conserve cette divergence, car les lignes complètes diffèrent. Les deux outils utilisent leurs propres règles de correspondance, notamment des comparaisons insensibles à la casse : ils ne conviennent donc pas pour imposer une distinction de casse caractère par caractère sans contrôle supplémentaire.

Excel conserve la première occurrence. Si l’enregistrement le plus récent doit être conservé, trie d’abord les lignes complètes par date de mise à jour, de la plus récente à la plus ancienne. Traite explicitement les enregistrements à égalité ou contradictoires. Une règle documentée peut consister à conserver l’enregistrement confirmé le plus récemment ou à fusionner les champs vérifiés. Consigne les colonnes choisies et le nombre de lignes supprimées.

=UNIQUE(A2:C501) renvoie les lignes distinctes dans une nouvelle plage dans les versions actuelles d’Excel et dans Google Sheets. La fonction préserve la source et permet de prévisualiser un résultat.

Trouver les clés répétées avec SQL

SELECT email, COUNT(*) AS n
FROM customers
GROUP BY email
HAVING COUNT(*) > 1;

GROUP BY crée un groupe pour chaque adresse e-mail ; HAVING conserve les groupes dont l’effectif dépasse un. WHERE filtre les lignes individuelles avant le regroupement. Effectue le contrôle sur des clés standardisées, en utilisant une table nettoyée ou en regroupant selon l’expression de nettoyage.

SELECT DISTINCT email, name FROM customers; renvoie une fois chaque combinaison d’adresse e-mail et de nom. Cette requête ne garantit pas l’unicité des adresses e-mail : deux lignes avec une même adresse et des noms différents restent toutes deux présentes. Vérifie la clé retenue après le dédoublonnage.

Les imports répétés et les exports qui se chevauchent créent souvent des doublons. Consigne la cause avec le responsable des données afin qu’une correction du tableau actuel améliore aussi le prochain export.

Une donnée manquante peut être visible sous forme de cellule vide ou masquée derrière une valeur d’apparence plausible. Détermine comment la source enregistre les informations manquantes avant de les compter. Un zéro enregistré peut être réel, tandis que « unknown » peut être une valeur de substitution.

Distinguer cellules vides, texte et NULL

Dans un tableur, une cellule vide, une cellule contenant une espace et une formule renvoyant "" peuvent avoir la même apparence. ESTVIDE n’est vrai que pour une cellule réellement vide. Une espace est du texte. NB.VIDE compte aussi les formules qui renvoient un texte vide, mais ne compte pas une cellule contenant une espace. Pour les espaces ordinaires, =SUPPRESPACE(B2)="" détecte à la fois les entrées vides et celles ne contenant que des espaces.

Dans une plage référencée, les fonctions de tableur SOMME, MOYENNE et NB ignorent les cellules vides et le texte. Elles incluent le zéro numérique. Pour les montants 48, 52, une cellule vide, 45, une cellule vide, 55, 50 et 46, la somme des montants connus est de 296. MOYENNE divise par six, ce qui donne environ 49,33. Remplacer les cellules vides par zéro fait passer le dénominateur à huit et la moyenne à 37.

En SQL, NULL marque une valeur inconnue ou absente. Zéro est un nombre connu. La chaîne vide '' est un texte sans caractère dans PostgreSQL, MySQL, SQL Server et SQLite. Les champs vides importés peuvent apparaître sous l’une ou l’autre forme : vérifie donc leur représentation stockée :

SELECT * FROM orders
WHERE city IS NULL OR TRIM(city) = '';

Utilise IS NULL et IS NOT NULL. amount = NULL ne trouve pas les montants manquants : une comparaison avec NULL produit un résultat inconnu, que WHERE ne retient pas.

Connaître le dénominateur

COUNT(*) compte toutes les lignes. COUNT(amount), SUM, AVG, MIN et MAX ignorent les montants NULL. Pour 40, NULL, 25, 60, NULL et 35, il y a six lignes mais quatre montants connus. SUM vaut 160 et AVG vaut 40, car la fonction divise 160 par quatre.

Ces fonctions ne peuvent pas identifier une valeur de substitution numérique comme -1 ou 999. Confirme le sens des valeurs de substitution auprès du responsable des données, puis compte-les séparément ou transforme-les en valeurs manquantes. Examine aussi les effectifs des codes inhabituels, en plus du nombre de cellules vides.

Rechercher des régularités dans les données manquantes

Compte les entrées manquantes par colonne et calcule leur proportion parmi les lignes. Deux montants manquants sur huit représentent 25 %. Examine ensuite si les manques se concentrent par magasin, source ou mois. Un champ manquant limité à une source d’export peut indiquer un problème d’import qui peut être corrigé.

La raison de l’absence compte :

• Données manquantes complètement au hasard : un événement sans rapport avec les données, comme un échec d’enregistrement aléatoire, cause le manque.
• Données manquantes au hasard : la probabilité d’un manque dépend d’informations enregistrées, par exemple lorsque les clients plus âgés ignorent plus souvent un champ facultatif en ligne.
• Données manquantes non au hasard : la probabilité dépend de la valeur manquante elle-même, par exemple lorsque les personnes aux revenus très élevés ne renseignent pas leurs revenus.

Dans le cas des revenus, la moyenne des répondants peut être inférieure à celle de l’ensemble des personnes. Remplacer les valeurs manquantes par un même nombre ne supprime pas ce problème de sélection. Indique ce qui manque et qui est décrit par les valeurs restantes avant d’interpréter une moyenne.

Les valeurs manquantes nécessitent une décision liée à la question étudiée. Un client dont l’âge manque peut tout de même contribuer au total des ventes. Une commande sans montant ne peut pas apporter de valeur connue au chiffre d’affaires.

Choisir une action

Essaie d’abord de récupérer la valeur. Consulte une facture, le formulaire d’origine ou le système de référence. Un total de ligne calculé à partir d’une quantité et d’un prix unitaire vérifiés est une information récupérée. Une valeur estimée à partir d’autres clients est une estimation ; son remplacement est appelé imputation.

Préserver le sens d’un nombre

Remplacer une catégorie par « Unknown » conserve la ligne dans les décomptes tout en laissant le manque visible. Remplacer un champ numérique par zéro n’est justifié que lorsque l’absence signifie réellement zéro. Un nombre de retours manquant peut signifier zéro si le processus source confirme cette convention ; un montant de vente inconnu n’a pas ce sens.

Pour les montants connus 48, 52, 45, 55, 50 et 46, la somme est de 296 et la moyenne d’environ 49,33. Si deux cellules vides sont remplacées par zéro, la somme reste égale à 296 mais la moyenne descend à 37. Les lignes supplémentaires comptent désormais comme des observations égales à zéro.

Le remplacement par la moyenne ou la médiane modifie aussi les données. La médiane des six montants connus est de 49. Remplacer les deux valeurs manquantes par 49 ajoute 98, ce qui porte la moyenne des huit entrées à 49,25. Ces deux valeurs ajoutées n’ont pas été observées. La répétition de valeurs centrales donne l’impression que les données sont moins dispersées : conserve donc un marqueur pour les identifier. Pour des valeurs dont la distribution est fortement asymétrique, comme les revenus, la médiane décrit souvent mieux une valeur typique que la moyenne.

Appliquer la règle de façon visible

En SQL, COALESCE(city, 'Unknown') renvoie le premier argument non NULL. Cette fonction remplace les villes NULL mais laisse une chaîne vide inchangée. NULLIF(city, 'N/A') transforme précisément cette valeur de substitution en NULL. Combiner la normalisation et le remplacement rend le traitement explicite :

COALESCE(NULLIF(TRIM(city), ''), 'Unknown') AS city

Dans un tableur, une colonne auxiliaire de catégorie peut utiliser =SI(SUPPRESPACE(B2)="";"Unknown";B2). Une colonne de marqueurs distincte peut utiliser =SUPPRESPACE(B2)="" pour que le caractère manquant de la valeur d’origine reste visible après le remplacement.

Adapter les exclusions à l’analyse

Pour calculer le chiffre d’affaires total de 1 000 commandes dont trois montants manquent, recherche d’abord les factures. Si la récupération échoue, indique que le total exclut 3 commandes sur 1 000, soit 0,3 %. Ne supprime pas une ligne parce qu’un champ inutilisé est vide.

Si 400 âges de clients sur 1 000 manquent, leur remplacement par la moyenne transformerait 40 % de la colonne en estimations. Une analyse des 600 âges connus doit indiquer clairement sa couverture. Vérifie pourquoi ces âges sont absents : supprimer des lignes peut aussi fausser les résultats lorsque les clients concernés diffèrent des autres. Garde un traitement cohérent et documente toute modification ultérieure.

Le nettoyage du texte rend comparables les valeurs qui ont le même sens. Commence par lister les valeurs distinctes et leurs effectifs. Cela montre si une colonne nécessite une modification des espaces, une casse cohérente ou une correspondance entre plusieurs écritures et un seul libellé.

Supprimer les espaces et les caractères masqués

Dans Excel et Google Sheets, =SUPPRESPACE(A2) supprime les espaces aux deux extrémités et réduit les espaces internes répétées à une seule. La fonction transforme « Ana Silva » en « Ana Silva ». =EPURAGE(A2) supprime les caractères non imprimables comme les sauts de ligne.

Une espace insécable copiée depuis une page web peut subsister après TRIM. Remplace d’abord le caractère 160 par une espace ordinaire :

=SUPPRESPACE(SUBSTITUE(A2;CAR(160);" "))

Lis les fonctions imbriquées de l’intérieur vers l’extérieur : SUBSTITUE s’exécute d’abord, puis TRIM agit sur son résultat. Examine des exemples nettoyés, car la suppression d’un saut de ligne peut joindre des mots qui devraient rester séparés.

En SQL, TRIM(city) supprime les espaces aux extrémités mais laisse les espaces internes répétées. TRIM(' Ana Silva ') conserve donc trois espaces entre les noms. LTRIM agit sur l’extrémité gauche et RTRIM sur la droite. Choisis une expression de nettoyage adaptée aux caractères trouvés.

Standardiser la casse en connaissance de cause

UPPER et LOWER fonctionnent dans les deux outils. Les minuscules peuvent être utiles pour les adresses e-mail ; les majuscules peuvent convenir aux codes pays. La fonction PROPER d’un tableur met les mots en majuscules initiales, mais ne peut pas déterminer l’orthographe correcte d’un nom : « mcdonald » devient « Mcdonald » et « PT123 » devient « Pt123 ». Vérifie les noms et conserve la casse voulue pour les codes.

Les comparaisons de texte suivent les paramètres de l’outil. NB.SI, RECHERCHEV et les filtres d’Excel ignorent la casse. PostgreSQL considère habituellement « Lisbon » et « LISBON » comme des valeurs textuelles différentes. Dans un tableur, =EXACT(A2;B2) vérifie l’identité des textes en tenant compte de la casse. Standardise explicitement lorsqu’une même catégorie doit être traitée de façon cohérente entre les outils, tout en préservant les différences de casse qui ont un sens dans les identifiants sensibles à la casse.

Associer des valeurs entières à une catégorie

La suppression des espaces superflues et les changements de casse ne corrigent pas les différentes écritures. Une table de correspondance peut associer chaque variante à un libellé standard. Recherche la valeur nettoyée complète par correspondance exacte et examine les valeurs sans correspondance.

En SQL, CASE peut exprimer la même correspondance :

CASE
  WHEN UPPER(TRIM(country)) IN
       ('NL', 'NETHERLANDS', 'THE NETHERLANDS', 'HOLLAND')
    THEN 'Netherlands'
  ELSE TRIM(country)
END AS country

ELSE conserve les valeurs sans correspondance pour examen. Compte les catégories restantes après la mise en correspondance ; ne suppose pas que les premières lignes représentent toutes les écritures.

Éviter les remplacements dommageables

SUBSTITUE, Rechercher et remplacer et REPLACE en SQL peuvent remplacer du texte à l’intérieur d’une valeur plus longue. Remplacer « NY » partout transforme « Store NYC, NY » en « Store New YorkC, New York ». Pour les libellés de catégories, recherche une correspondance avec la cellule entière ou utilise une table de correspondance. Pour les adresses et les noms, examine la portée voulue de chaque remplacement.

Pour les villes « Lisbon », « lisbon », « Porto », une valeur manquante, « LISBON » et « Porto », UPPER(TRIM(city)) produit LISBON trois fois et PORTO deux fois, avec une valeur manquante. Analyse la colonne nettoyée, puis utilise-la pour les recherches de correspondance et les contrôles de doublons. Conserver la colonne auxiliaire tout en regroupant selon la ville brute laisserait subsister le problème initial.

Une valeur textuelle combinée peut masquer des informations nécessaires au tri ou à la recherche de correspondances. Place chaque élément nécessaire dans sa propre colonne, tout en conservant l’original jusqu’à ce que le fractionnement soit vérifié.

Fractionner à un séparateur fiable

Un délimiteur marque la frontière entre les parties. Une virgule dans « Silva, Ana » sépare le nom de famille du prénom. L’outil Convertir d’Excel et l’outil Scinder le texte en colonnes de Google Sheets permettent de choisir ce séparateur. Insère des colonnes vides à droite avant de fractionner pour que le résultat n’écrase pas d’autres champs.

Google Sheets peut utiliser =SPLIT(A2;",") ; les versions actuelles d’Excel peuvent utiliser =FRACTIONNER.TEXTE(A2;","). Supprime les espaces superflues des parties obtenues si une espace suit la virgule. Vérifie les lignes où le délimiteur manque ou apparaît plusieurs fois avant d’appliquer une même règle à toute la colonne.

Ne fractionne pas chaque nom à chaque espace. « Ana Maria Silva » comporte plus de parties qu’un nom en deux mots, et une espace seule ne permet pas de déterminer quels mots appartiennent au prénom ou au nom de famille. Utilise une structure source définie ou conserve un champ de nom complet lorsque la structure est incertaine.

Extraire par position lorsque la structure est fixe

Pour le code produit « PT-LIS-0042 », le pays occupe les positions 1 à 2, le lieu les positions 4 à 6 et le code final les positions 8 à 11.

Le décompte des positions commence à un. Conserve le code extrait sous forme de texte pour garder ses zéros initiaux. Les positions fixes ne fonctionnent que lorsque la structure du champ est cohérente.

Pour un texte de longueur variable, repère le délimiteur. Dans « Silva, Ana », TROUVE(",";A2) renvoie 6. =GAUCHE(A2;TROUVE(",";A2)-1) prend les cinq caractères qui précèdent la virgule. La soustraction exclut la virgule elle-même. FIND est sensible à la casse ; SEARCH l’ignore lors de la recherche de lettres.

Utiliser la fonction SQL équivalente

SUBSTRING(code, 4, 3) extrait le code de lieu situé au milieu dans PostgreSQL ; certaines bases utilisent SUBSTR. Les fonctions de longueur de caractères varient aussi : PostgreSQL et SQLite utilisent LENGTH, MySQL utilise CHAR_LENGTH et SQL Server utilise LEN, qui ignore les espaces finales. Dans MySQL, LENGTH compte les octets et peut donc donner un résultat différent du nombre de caractères pour un texte comme « é ».

Dans PostgreSQL, le contrôle WHERE LENGTH(code) <> 11 trouve les codes dont la longueur est incorrecte. Un contrôle de longueur seul ne vérifie pas que les lettres, les chiffres et les tirets sont aux bonnes positions.

Combiner les parties avec un séparateur clair

=A2&" "&B2 ou =CONCATENER(A2;" ";B2) réunit deux champs de tableur avec une espace. =JOINDRE.TEXTE(" ";VRAI;A2:C2) réunit une plage en ignorant les cellules vides. CONCAT dans Excel accepte plusieurs arguments ; CONCAT dans Google Sheets en accepte exactement deux.

Dans PostgreSQL, first_name || ' ' || last_name concatène du texte. Avec cet opérateur, une partie NULL rend le résultat NULL. CONCAT traite NULL différemment selon les dialectes : MySQL le propage, tandis que PostgreSQL et SQL Server l’ignorent. Traite les parties facultatives de façon explicite avec COALESCE et vérifie les séparateurs obtenus.

Un affichage cohérent n’est utile que si les valeurs ont le même sens. Les dates exigent un ordre connu, les nombres des séparateurs connus et les mesures une seule unité avant le début des calculs.

Déterminer la convention de la source

Le texte « 03/04/2025 » peut signifier le 4 mars ou le 3 avril. Une date comme « 25/03/2025 » établit que le jour vient en premier pour cette entrée, mais un fichier combiné peut contenir plusieurs formats. Confirme la convention auprès du responsable des données ou dans les paramètres d’export et recherche les sources mélangées avant de convertir les entrées ambiguës.

Utilise l’ordre de date ISO 8601, AAAA-MM-JJ, pour des échanges sans ambiguïté : « 2025-03-04 » désigne le 4 mars. Des dates textuelles uniformes au format ISO se trient aussi par ordre chronologique. Utilise le format horaire sur 24 heures, par exemple « 14:30 », et indique un fuseau horaire lorsque les événements couvrent plusieurs fuseaux.

Distinguer les valeurs stockées de l’affichage

Les tableurs stockent les véritables dates sous forme de numéros de série. Dans le système de dates par défaut d’Excel et dans Google Sheets, le 1er janvier 2025 correspond à 45 658 et le 4 mars 2025 à 45 720. Afficher cette date numérique au format AAAA-MM-JJ change son apparence, mais pas le jour enregistré.

Un texte qui ressemble à une date est différent. Appliquer un format de date à du texte ne crée pas une véritable valeur de date. Vérifie le type et convertis le texte selon la structure confirmée de la source avant de le mettre en forme. L’alignement peut être un indice, mais les contrôles de type et le comportement dans les calculs fournissent des preuves plus solides, car l’alignement peut être modifié manuellement.

La mise en forme des nombres fonctionne de la même façon. Une valeur stockée de 0,125 peut s’afficher sous la forme 0,13 avec deux décimales, tandis que les calculs utilisent toujours 0,125. =ARRONDI(A2;2) modifie le résultat numérique pour le limiter à deux décimales. Garde toutes les décimales pendant le nettoyage, sauf si la définition du champ exige une valeur arrondie : trois tiers arrondis séparément à 0,33 donnent une somme de 0,99.

Lire correctement les séparateurs numériques

« 1,234.5 » et « 1.234,5 » expriment le même nombre selon des conventions différentes. Un import avec des paramètres régionaux incorrects peut changer l’ordre de grandeur ou laisser une valeur sous forme de texte. Compare plusieurs valeurs importées avec leur source, notamment celles qui comportent des séparateurs décimaux et de milliers.

Dans Excel, =NUMBERVALUE("1.234,5",",",".") indique explicitement la virgule décimale et le point de regroupement et renvoie 1 234,5. Dans les autres outils, configure correctement les paramètres régionaux de l’import. Ne supprime pas toutes les virgules sans vérifier leur rôle : une virgule peut séparer les milliers ou marquer la partie décimale.

Convertir les unités avant de combiner les valeurs

Une colonne de poids contenant "2.5 kg", "750 g" et "1.2 kg" mélange les mentions et les unités. Extrais le nombre et l’unité, convertis les grammes en kilogrammes et stocke 2,5, 0,75 et 1,2 dans une colonne numérique weight_kg.

Additionner les nombres bruts donne 753,7, qui n’a pas d’unité cohérente. Indique une seule unité dans l’en-tête de colonne et place les nombres dans les cellules. De même, une colonne monétaire doit utiliser une seule devise pour que les totaux ou les moyennes aient un sens commun ; consigne toute règle de conversion utilisée.

Après la conversion, examine les dates et les mesures minimales et maximales. Vérifie les dates ambiguës individuellement par rapport à la source, même lorsqu’elles se situent dans la période autorisée : inverser le mois et le jour peut produire une date valide mais incorrecte.

Un type de données indique au logiciel comment traiter une valeur. Les quantités numériques permettent les opérations arithmétiques, les dates permettent le tri et le calcul d’écarts entre dates, le texte contient des libellés et des identifiants, et les champs booléens contiennent TRUE ou FALSE. Les imports transforment souvent en texte des nombres ou des dates attendus comme tels.

Diagnostiquer le type avant de le modifier

Un nombre sous forme de texte peut être aligné à gauche par défaut, afficher un avertissement dans Excel ou être trié avec « 10 » avant « 9 ». Vérifie toute la colonne avec NB et NBVAL. Dans une plage référencée contenant le nombre 120, le texte « 80 » et le nombre 45, SOMME donne 165 et NB donne 2. Le total attendu est de 245 : l’erreur de type affecte donc le calcul.

Changer le format d’affichage en Nombre ne convertit pas le texte existant. Crée une colonne auxiliaire, effectue-y la conversion et compare le résultat à la saisie brute.

Convertir du texte dans un tableur

=CNUM(A2) interprète un texte numérique selon les paramètres régionaux du tableur. =DATEVAL(A2) interprète une date textuelle selon les conventions de date reconnues. Confirme d’abord les séparateurs et l’ordre des dates.

Pour une valeur connue écrite avec le jour en premier, « 04.03.2025 », construis une date à partir de ses éléments. Des appels explicites à CNUM rendent les entrées numériques dans Excel comme dans Google Sheets :

=DATE(CNUM(DROITE(A2;4));CNUM(STXT(A2;4;2));CNUM(GAUCHE(A2;2)))

RIGHT renvoie le texte de l’année « 2025 », MID renvoie le texte du mois « 03 » et LEFT renvoie le texte du jour « 04 ». VALUE convertit chaque partie ; DATE construit le 4 mars 2025. Valide d’abord les parties : DATE peut reporter un jour ou un mois impossible sur une date ultérieure au lieu de signaler une erreur.

Pour une valeur comme « 1250 kg », supprime la mention d’unité connue et les espaces avant la conversion : =CNUM(SUPPRESPACE(SUBSTITUE(A2;"kg";""))). Ne supprime pas arbitrairement les lettres de tous les champs, car elles peuvent avoir un sens ou indiquer une saisie invalide. =SIERREUR(CNUM(A2);"check") laisse visibles les conversions échouées pour examen.

Conserver les identifiants sous forme de texte

Le code « 00427 » identifie quelque chose ; ce n’est pas une quantité à additionner. Sa conversion en nombre donne 427 et fait perdre les zéros initiaux. Les numéros de téléphone, de nombreux codes postaux et les identifiants de compte ont aussi leur place dans des colonnes textuelles. Définis le type avant l’import. Excel ne conserve que 15 chiffres significatifs dans le stockage numérique : un identifiant de 16 chiffres peut donc perdre des informations avant que tu le remarques. Le mettre ensuite au format texte ne peut pas récupérer les chiffres perdus.

Convertir avec SQL et examiner les échecs

Dans des bases de données comme PostgreSQL, CAST(amount_text AS DECIMAL(10,2)) interprète un texte numérique et renvoie un nombre décimal à deux décimales. CAST(quantity_text AS INTEGER) demande un nombre entier. Dans de nombreux dialectes, un texte ISO peut être converti en DATE ; les autres structures de date nécessitent une fonction d’analyse adaptée, comme TO_DATE dans PostgreSQL, STR_TO_DATE dans MySQL ou PARSE_DATE dans BigQuery.

Un texte invalide arrête souvent une requête CAST. TRY_CAST dans SQL Server et SAFE_CAST dans BigQuery renvoient à la place NULL lorsque les conversions ordinaires échouent. Compte ces échecs séparément des valeurs déjà manquantes. Par exemple, dans SQL Server :

SELECT amount_text FROM sales
WHERE TRY_CAST(amount_text AS DECIMAL(10,2)) IS NULL
  AND amount_text IS NOT NULL;

SQLite peut convertir sans avertissement « 12abc » en 12 et « abc » en 0. Une requête exécutée avec succès ne prouve donc pas que la conversion est correcte. Vérifie les chaînes d’origine, les valeurs converties, les décomptes et les valeurs minimale et maximale avant d’accepter la colonne propre.

Une procédure dans un tableur rend chaque modification visible et conserve suffisamment d’éléments pour la répéter. Utilise une feuille brute, une feuille de travail avec des colonnes auxiliaires et un tableau propre vérifié.

Préparer et ordonner le travail

Garde les données brutes intactes. Fige la ligne d’en-tête et utilise un tableau ou des filtres pour sélectionner toute la plage de données. Lors du tri, déplace les lignes entières ensemble pour que les noms, les identifiants et les montants restent liés.

Voici un ordre pratique :

1. Effectue le profilage du tableau et rédige une liste des problèmes.
2. Corrige les en-têtes et fractionne les champs qui contiennent plusieurs éléments nécessaires.
3. Supprime les espaces superflues, standardise la casse et établis les correspondances entre variantes de catégories.
4. Convertis les types et uniformise les formats de dates, de nombres et d’unités.
5. Traite les valeurs manquantes en conservant des marqueurs si nécessaire.
6. Supprime les doublons selon la clé et la règle de conservation retenues.
7. Valide le résultat, effectue les rapprochements et les contrôles ponctuels.

Cet ordre tient compte des dépendances. Un contrôle des doublons sur les clés brutes peut manquer des espaces supplémentaires. Un contrôle des bornes sur des nombres sous forme de texte risque de ne pas vérifier les valeurs voulues. Consigne l’effet après chaque étape pour pouvoir remonter à la cause d’un écart ultérieur.

Construire et examiner les colonnes auxiliaires

Si B2 contient « ana SILVA », =NOMPROPRE(SUPPRESPACE(B2)) renvoie « Ana Silva ». Recopie la formule sur tout le tableau et compare les noms bruts et nettoyés. Vérifie les écritures que PROPER ne peut pas déduire correctement.

Une formule auxiliaire comme =MAJUSCULE(SUPPRESPACE(SUBSTITUE(B2;CAR(160);" "))) fonctionne de l’intérieur vers l’extérieur : elle remplace les espaces insécables, supprime les espaces ordinaires superflues, puis modifie la casse. Utilise des en-têtes auxiliaires descriptifs comme city_clean pour que les formules suivantes pointent vers la colonne voulue.

Filtre les résultats et vérifie les valeurs au début, au milieu et à la fin de la plage. Une formule recopiée sur une partie seulement du tableau laisse une colonne mixte. Recherche les erreurs ainsi que les cellules vides.

Associer les catégories par recherche exacte

Conserve une table de correspondance à deux colonnes : variante et libellé standard. Avec une variante préparée en B2, =RECHERCHEV(B2;Map!$A$2:$B$50;2;FAUX) trouve le libellé correspondant. Les références absolues maintiennent la plage de correspondance fixe lors de la recopie vers le bas. FALSE demande une correspondance exacte ; une correspondance approximative peut renvoyer une catégorie plausible mais incorrecte pour une valeur absente de la liste.

RECHERCHEX peut utiliser des plages distinctes pour la recherche et le résultat. La correspondance exacte est son réglage par défaut. Une variante sans correspondance doit rester visible sous forme d’erreur pour être examinée. Ajoute ou corrige sa correspondance au lieu de transformer chaque échec de recherche en une catégorie connue.

Finaliser et documenter

Après vérification des colonnes auxiliaires, copie leurs résultats et utilise Collage spécial > Valeurs dans Excel ou Collage spécial > Valeurs uniquement dans Google Sheets pour créer le tableau propre. Vérifie qu’il est indépendant avant de supprimer les colonnes sources : les formules qui font encore référence à des cellules supprimées peuvent renvoyer #REF!.

Les outils intégrés comme Supprimer les doublons, Rechercher et remplacer et Convertir le texte en colonnes peuvent modifier de nombreuses cellules à la fois. Consigne leurs options, la plage sélectionnée et le nombre de valeurs concernées tant que ces informations sont visibles. Les colonnes auxiliaires à formule montrent directement leur logique ; conserve cette feuille de travail avec le journal.

Les formules en anglais présentées ici utilisent des virgules. La langue et les paramètres régionaux du tableur peuvent modifier les noms de fonctions et les séparateurs ; par exemple, Excel en néerlandais utilise SPATIES.WISSEN pour TRIM, et les paramètres régionaux à virgule décimale utilisent souvent des points-virgules entre les arguments.

Excel autorise 1 048 576 lignes et 16 384 colonnes par feuille ; Google Sheets limite le nombre de cellules par fichier. Les performances peuvent devenir problématiques bien avant une limite stricte. Pour des données fréquemment actualisées ou déjà présentes dans une base, une procédure SQL enregistrée convient souvent mieux que des modifications manuelles répétées dans un tableur.

Une requête de nettoyage SQL peut renvoyer des données utilisables sans modifier la table brute. Chaque expression rend une règle explicite et un alias nomme le résultat nettoyé.

Construire le résultat colonne par colonne

La requête suivante convient à PostgreSQL lorsque les textes du montant et de la date ont déjà passé les contrôles de conversion et que la quantité est numérique :

SELECT DISTINCT
  order_id,
  LOWER(TRIM(email)) AS email,
  COALESCE(NULLIF(UPPER(TRIM(city)), ''), 'UNKNOWN') AS city,
  CAST(amount AS DECIMAL(10,2)) AS amount,
  CAST(order_date AS DATE) AS order_date
FROM raw_orders
WHERE order_id IS NOT NULL
  AND quantity > 0;

Les espaces superflues de l’adresse e-mail sont supprimées et l’adresse est mise en minuscules. Pour la ville, TRIM supprime les espaces aux extrémités, UPPER standardise la casse, NULLIF transforme le texte vide en NULL et COALESCE fournit « UNKNOWN ». Les conversions renvoient des montants numériques et des dates. WHERE exclut les identifiants manquants et les quantités nulles, négatives ou NULL. DISTINCT supprime les lignes de résultat sélectionnées qui sont répétées.

Effectue le profilage du résultat après chaque expression ajoutée. Une requête complexe peut s’exécuter avec succès alors qu’une correspondance ou une conversion est incorrecte.

Comprendre l’ordre du filtrage

L’ordre logique à retenir est FROM, WHERE, SELECT, DISTINCT, ORDER BY. WHERE voit les colonnes sources avant que les expressions SELECT produisent leurs alias. Un alias ne rend pas une colonne brute propre dans la clause WHERE de la même requête.

Pour filtrer une ville brute de manière cohérente, utilise WHERE UPPER(TRIM(city)) = 'LISBON', ou enregistre le résultat nettoyé et filtre-le dans une requête ultérieure. Filtrer la ville brute avec city = 'LISBON' peut manquer des variantes, même si SELECT nettoie la ville affichée.

CASE vérifie les conditions dans l’ordre et renvoie le premier résultat correspondant :

CASE
  WHEN LOWER(TRIM(status)) IN ('shipped', 'sent') THEN 'shipped'
  WHEN status IS NULL THEN 'unknown'
  ELSE LOWER(TRIM(status))
END AS status

Sans ELSE, une valeur sans correspondance devient NULL. Laisse les statuts sans correspondance visibles jusqu’à ce que leur sens soit déterminé.

Choisir entre filtrer et marquer

WHERE retire une ligne du résultat. Un marqueur conserve la ligne et indique un problème, par exemple CASE WHEN delivery_date < order_date THEN 1 ELSE 0 END AS date_issue. Vérifie séparément que les dates obligatoires ne sont pas NULL.

Compte explicitement les lignes exclues :

SELECT COUNT(*) FROM raw_orders
WHERE order_id IS NULL
   OR quantity <= 0
   OR quantity IS NULL;

Cela prend en compte toutes les raisons pour lesquelles le filtre précédent rejette une ligne, y compris les quantités manquantes. Après DISTINCT, vérifie la clé métier avec GROUP BY et HAVING. Les lignes qui partagent un identifiant mais ont des montants différents subsistent après DISTINCT et doivent encore être traitées.

Enregistrer la méthode et choisir le bon dialecte

CREATE VIEW clean_orders AS SELECT ... enregistre une requête qui lit les données sources actuelles à chaque utilisation de la vue. CREATE TABLE clean_orders AS SELECT ... crée un résultat stocké dans de nombreux dialectes ; SQL Server utilise couramment SELECT INTO. Conserve la requête et les commentaires pour pouvoir reconstruire ce résultat lorsque les données d’entrée changent.

Les noms et le comportement des fonctions varient selon les systèmes SQL. Vérifie le dialecte pour l’analyse des dates, la longueur des caractères et la conversion sécurisée. UPDATE et DELETE modifient les enregistrements stockés : examine la même condition WHERE avec SELECT et dispose d’une sauvegarde avant d’appliquer l’une ou l’autre instruction. Sans WHERE, elles affectent toutes les lignes. Nettoyer au moyen de SELECT est un choix par défaut utile pour les analystes disposant d’un accès en lecture seule.

Un tableau propre doit être accompagné d’une explication de sa préparation. La documentation permet à une autre personne de retracer l’origine d’une valeur présentée, de juger une décision et de répéter le travail sur la prochaine livraison.

Rédiger une entrée utile dans le journal des modifications

Un journal des modifications est un relevé daté des changements. Chaque entrée doit indiquer :

• La date et l’auteur.
• Le jeu de données et la colonne ou la plage concernée.
• Le problème et son ampleur initiale.
• L’action, y compris la formule, la requête ou les options de l’outil.
• Le nombre de lignes ou de valeurs concernées.
• La raison et toute source utilisée pour confirmer une correction.

Par exemple : « 2025-03-10, A. Silva, orders.city : espaces superflues supprimées et mise en majuscules de 412 valeurs avec UPPER(TRIM(city)) ; 9 écritures ramenées à 4 villes ; nécessaire pour les ventes par ville. »

Cette entrée explique la méthode et son objectif. « Villes nettoyées » ne précise ni la règle de comparaison, ni le périmètre, ni le nombre de valeurs concernées. Rédige les entrées pendant le travail, tant que le message de l’outil indiquant le nombre de lignes concernées et la raison d’une décision sont encore disponibles.

Consigner les décisions ainsi que les opérations

Une formule n’explique pas pourquoi elle était appropriée. Pour les doublons, indique les colonnes clés et l’enregistrement conservé. Pour les montants manquants, précise s’ils ont été récupérés, exclus, remplacés ou laissés manquants. Si tu as remplacé des valeurs, consigne la règle d’estimation et la colonne de marqueurs. Pour une correction, indique la facture ou l’enregistrement source qui a fourni la valeur réelle.

Consigne aussi les lignes signalées mais conservées. Une personne qui vérifie le travail doit pouvoir distinguer un problème connu laissé visible d’un problème manqué par le nettoyage. Si un traitement change ultérieurement, ajoute une entrée datée expliquant la nouvelle décision.

Conserver la méthode et son historique

Les notes de cellule d’un tableur peuvent expliquer une correction, tandis qu’une feuille consacrée au journal des modifications contient la séquence complète. L’historique des versions de Google Sheets peut restaurer des états antérieurs du fichier. L’historique des versions d’Excel est disponible pour les fichiers stockés dans OneDrive ou SharePoint. L’historique aide à récupérer un fichier, mais un journal distinct explique l’intention des modifications.

Les commentaires SQL peuvent expliquer une règle à côté de son expression. Utilise -- pour une ligne ou /* ... */ pour un commentaire plus long. Conserve les versions des requêtes dans un système de gestion de versions ou un espace de stockage doté d’un historique des versions. Un simple dossier partagé rend la requête actuelle accessible mais ne conserve pas les versions antérieures.

Permettre la réexécution

Un processus est reproductible lorsque les mêmes données brutes et les mêmes règles produisent le même résultat propre. Les requêtes enregistrées et les formules auxiliaires conservées montrent leurs règles. Pour qu’une modification manuelle de cellule puisse être répétée avec exactitude, il faut consigner l’identifiant de l’enregistrement, l’ancienne valeur, la nouvelle valeur et la raison.

Conserve ensemble la copie brute, les étapes de transformation, les tables de correspondance et le journal. Si une règle dépend d’un ordre de conservation, par exemple conserver l’enregistrement client le plus récent, enregistre aussi la règle de tri ou de sélection. Reproduire un résultat exige de conserver les décisions ainsi que les expressions utilisées dans le logiciel.

Partage le journal et un court bilan du nettoyage avec les personnes qui utilisent les données. Une personne qui interprète les résultats doit savoir que des commandes de test ont été supprimées ou que l’âge manque pour une partie des clients. Signale les erreurs récurrentes à la source au responsable des données afin qu’il puisse corriger le formulaire, l’import ou l’export qui les crée.

La vérification consiste à déterminer si le nettoyage a corrigé les problèmes sans en créer de nouveaux. Elle contrôle aussi que les données restantes répondent toujours à la question d’origine. Utilise des tests et des comparaisons sur des colonnes entières, puis examine des enregistrements individuels.

Rapprocher les nombres de lignes étape par étape

Pars du nombre de lignes brutes. Soustrais les lignes supprimées à chaque étape, en ne comptant chaque suppression qu’une fois. Pour 1 250 lignes brutes, 37 copies en double supprimées et 12 lignes invalides exclues ultérieurement :

Le nombre attendu de lignes propres est de 1 201. Un nombre différent doit être expliqué avant la diffusion. Vérifie l’étape à laquelle le nombre a divergé pour la première fois. Un filtre a pu masquer des lignes lors d’une opération dans le tableur, ou une plage sélectionnée a pu omettre une partie du tableau.

Si une ligne présente plusieurs problèmes, ne la soustrais pas plusieurs fois. Utilise le nombre réel de lignes avant et après chaque opération. Garde des décomptes distincts pour les lignes supprimées et les cellules corrigées : modifier dix cellules de ville ne supprime pas dix lignes.

Répéter le profilage et les contrôles des règles

Effectue les contrôles d’origine sur le résultat propre. Compare chaque résultat à la décision consignée dans le journal :

• Les nombres de valeurs manquantes correspondent aux valeurs laissées manquantes, récupérées ou remplacées.
• Les listes de catégories présentent les écritures standard voulues.
• Les valeurs minimales et maximales des nombres et des dates sont valides.
• La clé ne présente aucun doublon non résolu.
• Les contrôles du type, de présence, des bornes et de cohérence ne présentent aucun échec inexpliqué.

Un nombre nul de cellules vides après remplacement ne signifie pas qu’aucune valeur ne manquait. Vérifie aussi les marqueurs. Une clé métier répétée peut subsister après DISTINCT lorsqu’un champ sélectionné diffère : contrôle donc directement cette clé.

Rapprocher les montants et examiner les enregistrements

Si aucune valeur n’a été corrigée ou remplacée, le total propre doit être égal au total brut moins les montants des lignes supprimées. Un total brut de 152 400 moins 3 100 de commandes en double supprimées doit laisser 149 300. Si des valeurs ont été corrigées ou remplacées, inclus séparément ces modifications dans le rapprochement.

Compare des enregistrements de plusieurs parties du tableau aux données brutes et, si possible, à la source d’origine. Cible les lignes touchées par des étapes risquées : remplacements, fractionnement, analyse des valeurs et conversion de type. Vérifie que les noms n’ont pas subi de remplacement trop large, que les résultats du fractionnement ne sont pas décalés dans les colonnes, que les identifiants n’ont pas perdu de zéros et que les dates n’ont pas leur jour et leur mois inversés. Une date plausible peut tout de même être incorrecte.

Vérifier la couverture nécessaire à la question

Assure-toi que les données propres couvrent toujours la période, les régions, les magasins, les produits et les champs nécessaires. Supprimer toutes les commandes d’un magasin parce que ses dates utilisent une autre structure modifie la population analysée. Corrige la règle d’analyse si possible et indique toute partie de la couverture qui reste manquante.

Rédige un court rapport indiquant la source et la période, les problèmes et leurs décomptes, les actions menées, les exclusions ou les remplacements, les résultats de la vérification et les limites restantes. Par exemple : « L’âge manque pour 12 % des clients ; les résultats par âge décrivent les 88 % restants. » Un résultat doit être interprété en tenant compte de cette couverture.

Répète le nettoyage et la vérification lorsque de nouvelles données brutes arrivent. Les règles enregistrées rendent le processus reproductible, mais les nouvelles catégories, les formats modifiés et les nouvelles régularités dans les valeurs manquantes doivent toujours être examinés.