Parcourir les aide-mémoire · Python

Technologie: PythonCatégorie: Nettoyage des donnéesNiveau: IntermédiaireMis à jour

Gérer les valeurs manquantes avec pandas

Inspectez, filtrez, remplissez, supprimez et validez les valeurs manquantes avec pandas sans modifier silencieusement le sens ni le dtype des données de production.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Compter les valeurs manquantes par colonne
  5. 2. Calculer le pourcentage de valeurs manquantes
  6. 3. Trouver les lignes avec une valeur manquante dans une colonne
  7. 4. Trouver les lignes comportant au moins une valeur manquante
  8. 5. Trouver les lignes où tous les champs sélectionnés sont manquants
  9. 6. Supprimer les lignes sans clé métier obligatoire
  10. 7. Exiger au moins N valeurs non nulles
  11. 8. Supprimer les colonnes entièrement vides
  12. 9. Remplir explicitement une valeur catégorielle manquante
  13. 10. Ne remplir les valeurs numériques que lorsque zéro est sémantiquement correct
  14. 11. Remplir à partir d’une autre colonne
  15. 12. Propager les valeurs vers l’avant (forward fill)
  16. 13. Propager les valeurs vers l’arrière (backward fill)
  17. 14. Interpoler des valeurs numériques
  18. 15. Préserver la sémantique des entiers nullables
  19. 16. Utiliser le dtype de chaîne nullable
  20. 17. Convertir les valeurs numériques invalides en valeurs manquantes pour les inspecter
  21. 18. Convertir les dates invalides en NaT et inspecter les échecs
  22. 19. Détecter les chaînes vides séparément des valeurs manquantes
  23. 20. Normaliser avec prudence les chaînes connues assimilables à null
  24. 21. Remplacer les valeurs sentinelles connues par des valeurs manquantes
  25. 22. Remplir par groupe
  26. 23. Comparer avant et après le traitement des valeurs manquantes
  27. 24. Vérifier les champs obligatoires après le nettoyage
  28. Interpréter le résultat
  29. Points à vérifier
  30. Le pourcentage de valeurs nulles a soudainement augmenté
  31. Un identifiant obligatoire est manquant
  32. Des valeurs manquantes n’apparaissent qu’après un merge
  33. Des valeurs nulles numériques apparaissent après une conversion
  34. Des dates nulles apparaissent après l’analyse
  35. Une catégorie contient à la fois des valeurs nulles et "Unknown"
  36. Notes de production
  37. Les valeurs manquantes relèvent de la logique métier
  38. Remplir des valeurs peut détruire de l’information
  39. Le comportement des valeurs nulles dépend du dtype
  40. dropna() peut supprimer de grandes quantités de données
  41. La propagation vers l’avant exige un ordre
  42. L’imputation modifie les données
  43. DataFrames volumineux
  44. Erreurs fréquentes
  45. 1. Remplir toutes les valeurs nulles avec zéro
  46. 2. Appeler dropna() sans subset
  47. 3. Utiliser == np.nan
  48. 4. Traiter automatiquement les chaînes vides comme des valeurs manquantes
  49. 5. Propager vers l’avant des données non triées
  50. 6. Remplir après une jointure défaillante
  51. 7. Écraser immédiatement les conversions en échec
  52. 8. Supprimer une colonne très majoritairement nulle sans vérifier l’importance de ses rares valeurs
  53. Étape suivante
  54. Pour aller plus loin

Problème

Les jeux de données réels contiennent souvent des valeurs manquantes :

  • attributs client absents
  • mesures non communiquées
  • échecs d’analyse (parsing)
  • jointures incomplètes
  • champs facultatifs
  • valeurs sources vides
  • données amont en retard

L’opération technique est simple.

La difficulté consiste à déterminer ce qu’une valeur manquante signifie avant de la modifier.

Vous devez savoir :

  • où se trouvent les valeurs manquantes
  • si elles sont attendues
  • si elles signalent un problème de qualité des données
  • si les lignes doivent être conservées ou supprimées
  • si le remplissage des valeurs modifie leur sens métier
  • si une conversion a créé de nouvelles valeurs manquantes
  • si les valeurs manquantes cassent les jointures, les agrégations ou les types en aval

Réponse rapide

Commencez par profiler les valeurs manquantes.

null_summary = (
    pd.DataFrame(
        {
            "null_count": df.isna().sum(),
            "null_pct": df.isna().mean().mul(100),
        }
    )
    .sort_values("null_pct", ascending=False)
)

print(null_summary)

Filtrez les lignes avec des valeurs manquantes :

missing_email = df.loc[df["email"].isna()]

Ne remplissez que lorsque la valeur de remplacement a un sens métier clair :

df["country"] = df["country"].fillna("Unknown")

Ne supprimez des lignes que lorsque le champ manquant rend la ligne inutilisable :

df = df.dropna(subset=["order_id"])

N’utilisez pas fillna(0) ou dropna() de manière globale sans comprendre la sémantique des données.

Code / commandes

1. Compter les valeurs manquantes par colonne

null_counts = (
    df.isna()
    .sum()
    .sort_values(ascending=False)
)

print(null_counts)

C’est la première vérification la plus rapide.


2. Calculer le pourcentage de valeurs manquantes

null_summary = (
    pd.DataFrame(
        {
            "null_count": df.isna().sum(),
            "null_pct": df.isna().mean().mul(100),
        }
    )
    .sort_values("null_pct", ascending=False)
)

print(null_summary)

Les pourcentages sont plus utiles que les décomptes lorsque la taille des colonnes ou des jeux de données varie fortement.


3. Trouver les lignes avec une valeur manquante dans une colonne

missing_email = df.loc[
    df["email"].isna()
]

Trouvez les lignes où la valeur est présente :

has_email = df.loc[
    df["email"].notna()
]

Utilisez .isna() et .notna() plutôt qu’une comparaison avec None ou np.nan.


4. Trouver les lignes comportant au moins une valeur manquante

rows_with_missing = df.loc[
    df.isna().any(axis=1)
]

Comptez-les :

print(df.isna().any(axis=1).sum())

C’est utile pour une inspection globale, mais ne considérez pas tous les champs manquants comme ayant la même importance.


5. Trouver les lignes où tous les champs sélectionnés sont manquants

cols = ["email", "phone", "mobile"]

no_contact_details = df.loc[
    df[cols].isna().all(axis=1)
]

C’est souvent plus pertinent que de tester la ligne entière.


6. Supprimer les lignes sans clé métier obligatoire

df_clean = df.dropna(
    subset=["order_id"]
)

Pour plusieurs champs obligatoires :

df_clean = df.dropna(
    subset=["order_id", "customer_id"]
)

N’utilisez cette approche que lorsqu’une clé manquante rend réellement l’enregistrement inutilisable.


7. Exiger au moins N valeurs non nulles

df_clean = df.dropna(
    thresh=3
)

Cela conserve les lignes ayant au moins trois valeurs non nulles dans l’ensemble du DataFrame.

Vous pouvez appliquer la règle à des colonnes sélectionnées :

df_clean = df.dropna(
    subset=["email", "phone", "mobile"],
    thresh=1,
)

Cela conserve les lignes où au moins un champ de contact est renseigné.


8. Supprimer les colonnes entièrement vides

df_clean = df.dropna(
    axis="columns",
    how="all",
)

C’est sans risque lorsqu’une colonne ne contient aucune information.

Ne supprimez pas automatiquement une colonne majoritairement nulle si ses rares valeurs sont critiques pour le métier.


9. Remplir explicitement une valeur catégorielle manquante

df["country"] = (
    df["country"]
    .fillna("Unknown")
)

N’utilisez un libellé comme "Unknown" que lorsque cette valeur signifie clairement :

la valeur n’est pas connue

N’utilisez pas une catégorie réelle comme "US" comme valeur par défaut, sauf si la règle métier le garantit.


10. Ne remplir les valeurs numériques que lorsque zéro est sémantiquement correct

df["discount_amount"] = (
    df["discount_amount"]
    .fillna(0)
)

Ce n’est correct que si une valeur manquante signifie :

aucune remise n’a été appliquée

C’est faux si une valeur manquante signifie :

les données de remise n’étaient pas disponibles

Zéro et inconnu sont deux états différents.


11. Remplir à partir d’une autre colonne

df["billing_country"] = (
    df["billing_country"]
    .fillna(df["shipping_country"])
)

N’utilisez cette approche que lorsque la valeur de repli est valide selon la règle métier.


12. Propager les valeurs vers l’avant (forward fill)

df["status"] = df["status"].ffill()

C’est utile lorsque les lignes représentent une séquence ordonnée et qu’une valeur reste valide jusqu’à son remplacement.

Exemple :

df = df.sort_values(
    ["device_id", "event_time"]
)

df["status"] = (
    df.groupby("device_id")["status"]
    .ffill()
)

Définissez toujours le bon ordre de tri et la bonne portée de regroupement avant une propagation vers l’avant.


13. Propager les valeurs vers l’arrière (backward fill)

df["status"] = df["status"].bfill()

N’utilisez la propagation vers l’arrière que lorsqu’une valeur connue ultérieure est un remplacement valide pour les lignes manquantes antérieures.

C’est moins courant dans les données transactionnelles de production et cela doit être justifié explicitement.


14. Interpoler des valeurs numériques

df["temperature"] = (
    df["temperature"]
    .interpolate()
)

Pour des données indexées par le temps :

df = df.sort_values("event_time").set_index("event_time")

df["temperature"] = (
    df["temperature"]
    .interpolate(method="time")
)

L’interpolation convient à certaines mesures continues.

Elle est généralement inadaptée pour :

  • les identifiants
  • les catégories
  • les montants de transactions financières
  • les événements discrets
  • les clés métier

15. Préserver la sémantique des entiers nullables

Une colonne d’entiers NumPy classique ne peut pas représenter NaN.

Utilisez le dtype d’entier nullable de pandas lorsque des entiers manquants sont valides.

df["customer_age"] = (
    pd.to_numeric(
        df["customer_age"],
        errors="coerce",
    )
    .astype("Int64")
)

Cela préserve les valeurs entières tout en autorisant pd.NA.


16. Utiliser le dtype de chaîne nullable

df["customer_name"] = (
    df["customer_name"]
    .astype("string")
)

Cela offre un comportement plus cohérent vis-à-vis des valeurs manquantes que les colonnes object génériques.

Vérifiez :

print(df["customer_name"].dtype)

17. Convertir les valeurs numériques invalides en valeurs manquantes pour les inspecter

parsed_amount = pd.to_numeric(
    df["amount"],
    errors="coerce",
)

Trouvez les lignes dont la conversion a échoué :

failed = df.loc[
    df["amount"].notna()
    & parsed_amount.isna()
]

print(failed)

N’écrasez pas la colonne source tant que vous ne comprenez pas pourquoi l’analyse a échoué.


18. Convertir les dates invalides en NaT et inspecter les échecs

parsed_date = pd.to_datetime(
    df["event_time"],
    errors="coerce",
)

Trouvez les échecs d’analyse :

failed_dates = df.loc[
    df["event_time"].notna()
    & parsed_date.isna()
]

print(failed_dates)

NaT est la valeur datetime manquante de pandas.


19. Détecter les chaînes vides séparément des valeurs manquantes

Une chaîne vide n’est pas nécessairement traitée comme une valeur manquante.

empty_strings = (
    df.select_dtypes(include=["object", "string"])
    .apply(lambda s: s.eq("").sum())
    .sort_values(ascending=False)
)

print(empty_strings)

Inspectez aussi les chaînes composées uniquement d’espaces :

whitespace_only = (
    df.select_dtypes(include=["object", "string"])
    .apply(
        lambda s: (
            s.astype("string")
            .str.strip()
            .eq("")
            .sum()
        )
    )
)

print(whitespace_only)

Ne supposez pas que les systèmes sources encodent l’absence de manière cohérente.


20. Normaliser avec prudence les chaînes connues assimilables à null

Supposons que la source utilise des valeurs comme :

NULL
N/A
None
unknown

Inspectez d’abord :

null_like = {
    "",
    "null",
    "none",
    "n/a",
    "na",
}

for col in df.select_dtypes(
    include=["object", "string"]
).columns:
    normalized = (
        df[col]
        .astype("string")
        .str.strip()
        .str.lower()
    )

    matches = normalized.isin(null_like).sum()

    if matches:
        print(col, matches)

Ne convertissez ces valeurs en valeurs manquantes qu’après avoir confirmé qu’elles représentent réellement une absence dans ce champ.


21. Remplacer les valeurs sentinelles connues par des valeurs manquantes

Exemple :

df["temperature"] = (
    df["temperature"]
    .replace(-9999, pd.NA)
)

Ce n’est approprié que lorsque -9999 est documenté comme valeur sentinelle du système source.

Ne devinez pas les valeurs sentinelles à partir de données d’apparence inhabituelle.


22. Remplir par groupe

Exemple : remplir le responsable régional manquant à partir des valeurs connues dans chaque région.

df["regional_manager"] = (
    df.groupby("region")["regional_manager"]
    .transform(
        lambda s: s.ffill().bfill()
    )
)

N’utilisez cette approche que lorsque les valeurs sont stables au sein du groupe et que l’ordre des lignes est approprié.

Un remplissage au niveau du groupe peut propager silencieusement des données erronées si la clé de regroupement est incorrecte.


23. Comparer avant et après le traitement des valeurs manquantes

before = df["country"].isna().sum()

df["country"] = (
    df["country"]
    .fillna("Unknown")
)

after = df["country"].isna().sum()

print("Before:", before)
print("After:", after)

Les transformations de production doivent rendre explicite l’évolution attendue de la qualité des données.


24. Vérifier les champs obligatoires après le nettoyage

assert df["order_id"].notna().all()
assert df["customer_id"].notna().all()

Pour plusieurs champs :

required = [
    "order_id",
    "customer_id",
    "event_time",
]

assert df[required].notna().all().all()

Les assertions sont utiles dans des pipelines contrôlés, mais les systèmes de production peuvent nécessiter une validation structurée et une gestion des erreurs plutôt qu’un arrêt brutal du processus.

Interpréter le résultat

Valeur / méthode Signification
np.nan Marqueur courant de valeur manquante en virgule flottante.
pd.NA Scalaire de valeur manquante nullable de pandas, utilisé par les dtypes nullables.
NaT Valeur datetime/timedelta manquante.
isna() Détecte les valeurs manquantes reconnues par pandas.
notna() Détecte les valeurs non manquantes.
dropna() Supprime des lignes ou des colonnes selon des règles sur les valeurs manquantes.
fillna() Remplace les valeurs manquantes par des valeurs explicites.
ffill() Propage la dernière valeur valide vers l’avant.
bfill() Propage la valeur valide suivante vers l’arrière.
interpolate() Estime les valeurs intermédiaires selon une méthode.

Le point essentiel est sémantique :

manquant != zéro
manquant != chaîne vide
manquant != faux
manquant != "Unknown"

sauf si vos règles métier les rendent explicitement équivalents.

Points à vérifier

Le pourcentage de valeurs nulles a soudainement augmenté

Causes possibles :

  • changement de schéma en amont
  • jointure en échec
  • erreur d’analyse
  • partition source manquante
  • changement de sémantique de la source

Comparez avec les exécutions précédentes avant de faire disparaître ces valeurs par remplissage.

Un identifiant obligatoire est manquant

C’est généralement plus grave qu’une description facultative manquante.

Hiérarchisez les valeurs manquantes selon leur importance métier, pas seulement selon leur pourcentage.

Des valeurs manquantes n’apparaissent qu’après un merge

Causes probables :

  • clés sans correspondance
  • différences de format des clés
  • table de référence incomplète
  • colonnes de jointure incorrectes

Examinez le merge avant de remplir les champs d’enrichissement.

Des valeurs nulles numériques apparaissent après une conversion

La source contenait probablement des valeurs non numériques.

Inspectez les conversions en échec plutôt que de les traiter comme de véritables valeurs manquantes.

Des dates nulles apparaissent après l’analyse

Inspectez :

  • un format inattendu
  • des dates impossibles
  • du texte de fuseau horaire
  • des conventions de date mélangées

Une catégorie contient à la fois des valeurs nulles et "Unknown"

Ce sont désormais deux états différents.

C’est peut-être correct, mais cela doit être intentionnel.

Notes de production

Les valeurs manquantes relèvent de la logique métier

Il n’existe pas de règle universelle telle que :

< 5 % manquants -> supprimer
> 5 % manquants -> remplir

L’action appropriée dépend :

  • de la sémantique du champ
  • de la fiabilité de la source
  • de l’usage en aval
  • des exigences réglementaires
  • des attentes en matière de reporting

Remplir des valeurs peut détruire de l’information

Une fois les valeurs nulles remplacées par 0, "Unknown" ou une autre valeur, vous risquez de perdre la distinction entre :

  • la valeur observée à l’origine
  • la valeur source manquante
  • la valeur imputée

Pour les données importantes, envisagez de conserver un indicateur :

df["country_was_missing"] = (
    df["country"].isna()
)

df["country"] = (
    df["country"]
    .fillna("Unknown")
)

Le comportement des valeurs nulles dépend du dtype

pandas peut utiliser des marqueurs de valeur manquante différents selon le dtype.

Privilégiez les dtypes nullables modernes lorsque les valeurs manquantes font partie du modèle.

Exemples :

Int64
boolean
string

dropna() peut supprimer de grandes quantités de données

Mesurez toujours l’impact d’abord.

before = len(df)

candidate = df.dropna(
    subset=["customer_id"]
)

removed = before - len(candidate)

print("Rows removed:", removed)

La propagation vers l’avant exige un ordre

Ceci est risqué :

df["status"].ffill()

si les lignes ne sont pas dans la bonne séquence métier.

Triez d’abord.

L’imputation modifie les données

La moyenne, la médiane, l’interpolation, la propagation vers l’avant et les autres méthodes d’imputation produisent des valeurs dérivées.

Si la distinction compte, gardez la trace du fait que la valeur a été imputée.

DataFrames volumineux

Les opérations sur les valeurs manquantes parcourent souvent des colonnes entières.

Sur de gros volumes :

  • inspectez d’abord les colonnes ciblées
  • évitez les parcours répétés de l’ensemble du DataFrame
  • ne sélectionnez que les colonnes nécessaires
  • rapprochez la validation de la source lorsque c’est possible

Erreurs fréquentes

1. Remplir toutes les valeurs nulles avec zéro

Zéro est une valeur réelle.

Une valeur manquante signifie inconnue/absente, sauf si la règle métier en dispose autrement.

2. Appeler dropna() sans subset

Cela peut supprimer des lignes à cause de champs facultatifs sans importance.

Ciblez les champs qui déterminent réellement la validité d’une ligne.

3. Utiliser == np.nan

Cela ne détecte pas les valeurs manquantes de manière fiable.

Utilisez :

isna()

4. Traiter automatiquement les chaînes vides comme des valeurs manquantes

Certains systèmes distinguent :

NULL
""
" "

Ne normalisez que lorsque la sémantique métier le justifie.

5. Propager vers l’avant des données non triées

Cela peut propager des valeurs dans la mauvaise séquence.

Triez et regroupez correctement d’abord.

6. Remplir après une jointure défaillante

Si les valeurs nulles ont été créées parce que des clés n’ont pas trouvé de correspondance, les remplir peut masquer le défaut de jointure.

Corrigez d’abord le problème de correspondance.

7. Écraser immédiatement les conversions en échec

Cela détruit les preuves.

Créez une Series analysée, inspectez les échecs, puis affectez le résultat de manière délibérée.

8. Supprimer une colonne très majoritairement nulle sans vérifier l’importance de ses rares valeurs

Une colonne peut être nulle à 99 % et contenir malgré tout des exceptions critiques.

Vérifiez son utilisation réelle avant de la supprimer.

Étape suivante

Utilisez la répartition observée des valeurs manquantes pour décider de la suite.

  • Des clés obligatoires sont manquantes → remontez à la qualité de la source en amont avant tout traitement en aval.
  • Des valeurs nulles sont apparues après une jointure → inspectez les clés sans correspondance et la cardinalité de la jointure.
  • Des valeurs nulles sont apparues après l’analyse → inspectez les valeurs sources invalides et les règles de conversion de type.
  • La valeur manquante a une valeur par défaut valide → remplissez explicitement et documentez la règle.
  • La valeur manquante signifie inconnue → envisagez de conserver la valeur nulle ou d’utiliser une catégorie clairement libellée.
  • Les lignes sont inutilisables sans le champ → ne supprimez que le sous-ensemble concerné et mesurez l’impact.
  • Des trous dans la série temporelle sont attendus → n’envisagez l’interpolation ou la propagation vers l’avant qu’avec un ordre et une sémantique corrects.
  • Les valeurs manquantes ont une importance opérationnelle → ajoutez des métriques de validation et suivez l’évolution du taux de valeurs nulles dans le temps.

← Tous les aide-mémoire