Parcourir les aide-mémoire · Python
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
- Problème
- Réponse rapide
- Code / commandes
- 1. Compter les valeurs manquantes par colonne
- 2. Calculer le pourcentage de valeurs manquantes
- 3. Trouver les lignes avec une valeur manquante dans une colonne
- 4. Trouver les lignes comportant au moins une valeur manquante
- 5. Trouver les lignes où tous les champs sélectionnés sont manquants
- 6. Supprimer les lignes sans clé métier obligatoire
- 7. Exiger au moins N valeurs non nulles
- 8. Supprimer les colonnes entièrement vides
- 9. Remplir explicitement une valeur catégorielle manquante
- 10. Ne remplir les valeurs numériques que lorsque zéro est sémantiquement correct
- 11. Remplir à partir d’une autre colonne
- 12. Propager les valeurs vers l’avant (forward fill)
- 13. Propager les valeurs vers l’arrière (backward fill)
- 14. Interpoler des valeurs numériques
- 15. Préserver la sémantique des entiers nullables
- 16. Utiliser le dtype de chaîne nullable
- 17. Convertir les valeurs numériques invalides en valeurs manquantes pour les inspecter
- 18. Convertir les dates invalides en NaT et inspecter les échecs
- 19. Détecter les chaînes vides séparément des valeurs manquantes
- 20. Normaliser avec prudence les chaînes connues assimilables à null
- 21. Remplacer les valeurs sentinelles connues par des valeurs manquantes
- 22. Remplir par groupe
- 23. Comparer avant et après le traitement des valeurs manquantes
- 24. Vérifier les champs obligatoires après le nettoyage
- Interpréter le résultat
- Points à vérifier
- Le pourcentage de valeurs nulles a soudainement augmenté
- Un identifiant obligatoire est manquant
- Des valeurs manquantes n’apparaissent qu’après un merge
- Des valeurs nulles numériques apparaissent après une conversion
- Des dates nulles apparaissent après l’analyse
- Une catégorie contient à la fois des valeurs nulles et "Unknown"
- Notes de production
- Les valeurs manquantes relèvent de la logique métier
- Remplir des valeurs peut détruire de l’information
- Le comportement des valeurs nulles dépend du dtype
- dropna() peut supprimer de grandes quantités de données
- La propagation vers l’avant exige un ordre
- L’imputation modifie les données
- DataFrames volumineux
- Erreurs fréquentes
- 1. Remplir toutes les valeurs nulles avec zéro
- 2. Appeler dropna() sans subset
- 3. Utiliser == np.nan
- 4. Traiter automatiquement les chaînes vides comme des valeurs manquantes
- 5. Propager vers l’avant des données non triées
- 6. Remplir après une jointure défaillante
- 7. Écraser immédiatement les conversions en échec
- 8. Supprimer une colonne très majoritairement nulle sans vérifier l’importance de ses rares valeurs
- Étape suivante
- 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.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.