Nettoyage de données et gestion des dates

Introduction au nettoyage de données et à la gestion des dates

Le nettoyage de données constitue la première étape cruciale d’un projet de data science. Avant de pouvoir appliquer des modèles statistiques ou de visualiser des résultats, il faut s’assurer que le jeu de données est complet, cohérent et correctement typé. Cette leçon couvre les bonnes pratiques d’inspection, de standardisation des noms de colonnes, d’utilisation du package janitor, de manipulation de dates avec lubridate, ainsi que des techniques d’imputation simples.

1. Inspection initiale du jeu de données

Le premier principe à appliquer avant toute transformation est d'inspecter le jeu de données. Cette étape permet de repérer :

• les valeurs manquantes (NA, NULL, ""),
• les incohérences de format (dates sous forme texte, nombres stockés comme caractères),
• les colonnes vides ou redondantes,
• les types de variables (numeric, factor, date, etc.).

En R, les fonctions glimpse() du package tibble ou str() offrent une vue d’ensemble rapide. Une inspection minutieuse guide les actions suivantes : standardisation, conversion de type, imputation ou suppression.

À retenir : Voir d’abord, agir ensuite.

2. Standardisation des noms de colonnes avec janitor

Des noms de colonnes clairs et uniformes facilitent la lecture du code et évitent les erreurs de syntaxe. Le package janitor propose la fonction clean_names() qui :

• convertit tous les caractères en minuscules,
• remplace les espaces, points et caractères spéciaux par des underscores (_),
• supprime les accents et les caractères non alphanumériques.

Exemple d’utilisation :

library(janitor)
raw_data %>%
  clean_names() -> data_clean

Après cette transformation, les colonnes "Nom du client" et "Date de naissance" deviennent respectivement nom_du_client et date_de_naissance.

À retenir : clean_names → minuscules + underscores

3. Chaînage d’opérations avec l’opérateur pipe forward (|>)

Le pipe forward (|>) introduit dans R 4.1 permet de transmettre le résultat d’une expression comme premier argument de la suivante. Cette syntaxe rend le code lisible du haut vers le bas, comme une recette de cuisine :

data %>%
  filter(age > 18) %>%
  mutate(age_group = ifelse(age < 30, "Jeune", "Adulte")) %>%
  arrange(desc(salaire))

L’opérateur |> remplace les pipes traditionnels %>% tout en conservant la même logique de lecture top‑down.

À retenir : pipe forward, lecture top‑down.

4. Analyse descriptive avec tabyl()

Le package janitor propose tabyl(), une fonction qui crée un tableau croisé affichant chaque modalité d’une variable ainsi que son pourcentage du total. Cette vue est idéale pour détecter des étiquettes incohérentes ou des catégories rares.

library(janitor)
my_data %>%
  tabyl(sexe)

Le résultat montre, par exemple, que "F" apparaît 48 % du temps, "Femme" 2 % et "FEMME" 0,5 %, indiquant un besoin de harmonisation.

À retenir : tabyl() = tableau + %

5. Imputation simple : remplacer les valeurs manquantes par la moyenne

L’une des méthodes les plus simples d’imputation consiste à remplacer les valeurs NA d’une variable numérique par la moyenne de la colonne (en excluant les NA).

data %>%
  mutate(salaire = ifelse(is.na(salaire),
                         mean(salaire, na.rm = TRUE),
                         salaire))

Cette approche, bien que basique, conserve la moyenne globale et évite la perte de lignes. Elle est souvent suffisante pour des modèles linéaires ou lorsqu’une proportion faible de valeurs est manquante.

À retenir : Moyenne + ifelse = imputation simple.

6. Conversion de type : as.factor()

Le problème de type le plus fréquent concerne les variables texte qui doivent être traitées comme des catégories. La fonction as.factor() convertit une colonne de caractères en un facteur, attribuant un niveau à chaque valeur distincte.

data$region <- as.factor(data$region)

Après conversion, les opérations de regroupement (group_by()) ou de modélisation (régression logistique) reconnaissent les niveaux comme des catégories fixes, ce qui améliore la stabilité des modèles.

À retenir : facteur = texte → catégories fixes.

7. Gestion des dates avec le package lubridate

7.1. Ajouter des durées à une date

Pour ajouter 30 jours à la date du jour, on utilise la fonction days() combinée à today() :

library(lubridate)
new_date <- today() + days(30)

Cette syntaxe crée un objet Period qui s’ajoute correctement à la date, en tenant compte des années bissextiles et des changements de mois.

À retenir : days() pour ajouter des jours, pas un nombre brut.

7.2. Parser des dates au format jour‑mois‑année

Lorsque les dates sont stockées sous la forme "06/05/1978" (jour/mois/année), la fonction dmy() de lubridate les convertit en objets Date :

raw_dates <- c("06/05/1978", "15/12/2020")
parsed_dates <- dmy(raw_dates)

Le préfixe d indique l’ordre jour‑mois‑année, évitant les confusions avec ymd() (année‑mois‑jour) ou mdy() (mois‑jour‑année).

À retenir : jour‑mois‑année → dmy().

8. Synthèse des bonnes pratiques

• Inspecter le jeu de données avant toute transformation.
• Standardiser les noms de colonnes avec clean_names().
• Utiliser le |> pipe forward pour un code lisible du haut vers le bas.
• Analyser les distributions de catégories avec tabyl().
• Imputer les valeurs manquantes simples avec la moyenne et ifelse().
• Convertir les variables texte en facteurs via as.factor().
• Manipuler les dates avec lubridate : days(), dmy(), today(), etc.

En suivant ces étapes, vous préparez un jeu de données propre, cohérent et prêt pour l’analyse statistique ou le machine learning. La rigueur lors du nettoyage garantit des modèles plus fiables et des insights plus pertinents.