Supprimer les NaN d'une liste Python - La méthode fiable

Retirer les valeurs NaN d’une liste Python paraît trivial, mais le détail compte vite dès que les données deviennent réelles: quelques flottants invalides, des valeurs None, un export CSV ou un tableau issu d’un calcul. Derrière la requête remove nan from list python, il y a presque toujours un besoin très concret: nettoyer une séquence avant un calcul, un affichage ou une exportation. Ici, je montre la méthode la plus fiable, les variantes utiles quand les données sont mixtes, et les pièges qui font échouer un simple remove().

Pourquoi un NaN ne se traite pas comme une valeur classique

Le point de départ est simple: NaN signifie “Not a Number”. En Python, comme dans les standards flottants IEEE-754, un NaN n’est pas égal à une autre valeur, y compris lui-même. C’est pour cela qu’un test comme x == x ne permet pas de l’identifier, et qu’une suppression basée sur l’égalité, comme remove(), peut échouer ou donner un résultat trompeur.

Je vois souvent des listes construites à partir de calculs, d’API ou de fichiers CSV dans lesquelles un NaN arrive sans prévenir. Une division impossible, une colonne vide, une agrégation partielle, et le flottant invalide se retrouve au milieu de la séquence. La documentation de Python recommande explicitement de tester un NaN avec isnan() plutôt qu’avec == ou is, et c’est cette règle qui évite la plupart des erreurs de filtrage.

Autrement dit, avant de “supprimer” un NaN, il faut d’abord accepter qu’il ne se comporte pas comme une valeur ordinaire. C’est précisément ce qui pousse à utiliser un vrai prédicat de filtrage, ce que je montre juste après.

La méthode la plus simple en Python pur

Si votre liste contient surtout des flottants, la solution la plus lisible est une compréhension de liste avec math.isnan(). C’est court, explicite, et cela garde le code facile à relire dans six mois.

import math

values = [12.5, float('nan'), 8.0, math.nan, 0.0, 7.3]
clean = [x for x in values if not math.isnan(x)]

print(clean)
# [12.5, 8.0, 0.0, 7.3]

Ici, je préfère cette forme parce qu’elle fait une seule chose: parcourir la liste et garder ce qui n’est pas un NaN. La complexité reste linéaire, donc le coût de traitement évolue simplement avec la taille de la liste. Pour une liste que vous voulez modifier sur place, vous pouvez aussi faire:

values[:] = [x for x in values if not math.isnan(x)]

Le découpage values[:] est utile si d’autres parties du programme pointent déjà vers la même liste. Vous gardez alors le même objet, mais avec un contenu nettoyé. Si vos éléments ne sont pas tous des nombres réels, il faut toutefois sécuriser le test, sinon math.isnan() peut lever une erreur. C’est le sujet de la section suivante.

Gérer les listes mixtes sans lever d’erreur

Dès qu’une liste peut contenir autre chose que des flottants, je deviens plus strict dans le test. None, une chaîne de caractères, un entier ou un objet personnalisé n’ont pas le même comportement face à math.isnan(). Le bon réflexe consiste donc à protéger l’appel, ou à utiliser une fonction qui sait reconnaître les valeurs manquantes de façon plus large.

import math

def est_nan(value):
    try:
        return math.isnan(value)
    except TypeError:
        return False

values = [10, None, "texte", float('nan'), 4.2]
clean = [x for x in values if not est_nan(x)]

print(clean)
# [10, None, 'texte', 4.2]

Cette version est pratique quand vous voulez supprimer uniquement les NaN numériques sans toucher au reste. Si, en revanche, votre logique métier considère aussi None comme une valeur à retirer, je préfère alors passer par un test plus large, par exemple avec pandas.isna(), qui reconnaît plusieurs formes de valeurs manquantes.

import pandas as pd

values = [10, None, "texte", float('nan'), 4.2]
clean = [x for x in values if not pd.isna(x)]

print(clean)
# [10, 'texte', 4.2]

La différence est importante: un filtre strict garde ce qui n’est pas un NaN, tandis qu’un filtre plus large retire aussi les valeurs considérées comme manquantes par l’outillage de données. Le bon choix dépend donc moins de NaN lui-même que du contrat de vos données.

Quand NumPy ou pandas deviennent le meilleur choix

Si vos données sont déjà dans un tableau NumPy ou une Series pandas, je n’essaie pas de revenir à une logique de liste Python pure. Ces bibliothèques ont déjà les bons outils, et leur filtrage vectorisé est généralement plus naturel sur des volumes de données réels.

Exemple côté NumPy:

import numpy as np

arr = np.array([1.0, np.nan, 2.5, np.nan, 4.0])
clean = arr[~np.isnan(arr)]

print(clean)
# array([1. , 2.5, 4. ])

Exemple côté pandas:

import pandas as pd

s = pd.Series([1.0, None, float('nan'), 2.0])
clean = s[~s.isna()]

print(clean.tolist())
# [1.0, 2.0]

Un point que je rappelle souvent: inf n’est pas un NaN. En pandas, les infinis ne sont pas considérés comme des valeurs manquantes par défaut. Si vous voulez aussi les exclure, il faut ajouter une règle séparée. C’est un détail, mais il change vite le résultat final dans un pipeline de données.

Le bon seuil de décision est simple pour moi: si vous êtes déjà dans NumPy ou pandas, restez-y. Vous gagnerez en clarté et vous éviterez de transformer une structure tabulaire en bricolage de liste Python.

Les erreurs que je vois le plus souvent

La suppression des NaN semble facile, mais trois erreurs reviennent sans cesse. Je les liste parce qu’elles expliquent la plupart des comportements “bizarres” que l’on croit d’abord attribuer à Python, alors qu’ils viennent juste d’un mauvais test.

• Utiliser remove() sur un NaN: la recherche repose sur l’égalité, donc elle n’est pas fiable ici.
• Tester avec ==: un NaN n’est jamais égal à lui-même, donc la comparaison ne permet pas de le reconnaître proprement.
• Appliquer math.isnan() sans vérifier le type: sur une chaîne ou None, vous pouvez provoquer une exception inutile.
• Confondre NaN et infini: inf et -inf sont des valeurs différentes et doivent être filtrées séparément si elles posent problème.
• Modifier la mauvaise référence: si la liste est partagée, une réaffectation simple peut ne pas suffire là où un remplacement par tranche est préférable.

Le meilleur moyen de limiter ces bugs, c’est de décider dès le départ si vous nettoyez une liste pure de nombres, une séquence mixte, ou une structure d’analyse plus riche. Ce tri mental évite de surcharger le code avec des conditions inutiles, et il rend la suite plus prévisible.

Choisir le bon filtre selon la forme des données

Quand je dois trancher vite, je pars de la forme réelle des données, pas du réflexe de codage. C’est la manière la plus fiable d’éviter un filtre trop faible ou trop agressif.

• Liste de flottants uniquement: utilisez math.isnan() dans une compréhension de liste.
• Liste mixte mais où seul le NaN doit disparaître: protégez l’appel avec une fonction d’aide.
• Données déjà en NumPy: filtrez avec le masque booléen ~np.isnan(arr).
• Données d’analyse avec valeurs manquantes variées: passez par pandas.isna() ou par les méthodes pandas de filtrage.
• Besoin de conserver l’objet liste mais de nettoyer son contenu: utilisez l’affectation par tranche.

La règle pratique est simple: plus la donnée est “data science” ou “data engineering”, plus NumPy et pandas deviennent naturels. Plus elle ressemble à une petite liste métier, plus math.isnan() reste le meilleur choix. Je préfère cette logique parce qu’elle garde le code lisible et qu’elle respecte le format natif de la donnée au lieu de le forcer.

Si vous gardez seulement une idée en tête, retenez celle-ci: un NaN ne se supprime pas correctement avec les réflexes habituels de comparaison, il se filtre avec un vrai test. C’est ce petit changement de méthode qui rend le nettoyage fiable, que vous travailliez sur une liste simple, un tableau NumPy ou une série pandas.