float('nan')résultats en Nan (pas un nombre). Mais comment puis-je le vérifier? Cela devrait être très facile, mais je ne le trouve pas.

math.isnan (x)

Retourne Truesi x est un NaN (pas un nombre), et Falsesinon.

>>> import math
>>> x = float('nan')
>>> math.isnan(x)
True

La façon habituelle de tester un NaN est de voir s'il est égal à lui-même:

def isNaN(num):
    return num != num

numpy.isnan(number)vous dit si c'est le cas NaNou non.

Voici trois façons de tester ou non une variable "NaN".

import pandas as pd
import numpy as np
import math

#For single variable all three libraries return single boolean
x1 = float("nan")

print(f"It's pd.isna  : {pd.isna(x1)}")
print(f"It's np.isnan  : {np.isnan(x1)}")
print(f"It's math.isnan : {math.isnan(x1)}")

Production

It's pd.isna  : True
It's np.isnan  : True
It's math.isnan  : True

voici une réponse avec:

• Implémentations NaN respectant la norme IEEE 754
  • à savoir: NaN python: float('nan'), numpy.nan...
• tout autre objet: chaîne ou autre (ne déclenche pas d'exceptions s'il est rencontré)

Un NaN implémenté suivant la norme, est la seule valeur pour laquelle la comparaison des inégalités avec lui-même doit retourner True:

def is_nan(x):
    return (x != x)

Et quelques exemples:

import numpy as np
values = [float('nan'), np.nan, 55, "string", lambda x : x]
for value in values:
    print(f"{repr(value):<8} : {is_nan(value)}")

Production:

nan      : True
nan      : True
55       : False
'string' : False
<function <lambda> at 0x000000000927BF28> : False

En fait, je suis juste tombé sur cela, mais pour moi, il vérifiait nan, -inf ou inf. Je viens d'utiliser

if float('-inf') < float(num) < float('inf'):

Cela est vrai pour les nombres, faux pour nan et les deux inf, et soulèvera une exception pour des choses comme les chaînes ou d'autres types (ce qui est probablement une bonne chose). De plus, cela ne nécessite pas d'importer de bibliothèques comme math ou numpy (numpy est tellement gros qu'il double la taille de toute application compilée).

math.isnan ()

ou comparer le nombre à lui-même. NaN est toujours! = NaN, sinon (par exemple s'il s'agit d' un nombre) la comparaison doit réussir.

Une autre méthode si vous êtes bloqué sur <2.6, vous n'avez pas numpy et vous n'avez pas de support IEEE 754:

def isNaN(x):
    return str(x) == str(1e400*0)

Eh bien, je suis entré dans ce message, car j'ai eu quelques problèmes avec la fonction:

math.isnan()

Il y a un problème lorsque vous exécutez ce code:

a = "hello"
math.isnan(a)

Cela soulève une exception. Ma solution est de faire une autre vérification:

def is_nan(x):
    return isinstance(x, float) and math.isnan(x)

Avec python <2.6, je me suis retrouvé avec

def isNaN(x):
    return str(float(x)).lower() == 'nan'

Cela fonctionne pour moi avec python 2.5.1 sur une boîte Solaris 5.9 et avec python 2.6.5 sur Ubuntu 10

Je reçois les données d'un service Web qui envoie NaNsous forme de chaîne 'Nan'. Mais il pourrait y avoir d'autres types de chaînes dans mes données, donc un simple float(value)pourrait lever une exception. J'ai utilisé la variante suivante de la réponse acceptée:

def isnan(value):
  try:
      import math
      return math.isnan(float(value))
  except:
      return False

Exigence:

isnan('hello') == False
isnan('NaN') == True
isnan(100) == False
isnan(float('nan')) = True

Toutes les méthodes pour savoir si la variable est NaN ou None:

Aucun type

In [1]: from numpy import math

In [2]: a = None
In [3]: not a
Out[3]: True

In [4]: len(a or ()) == 0
Out[4]: True

In [5]: a == None
Out[5]: True

In [6]: a is None
Out[6]: True

In [7]: a != a
Out[7]: False

In [9]: math.isnan(a)
Traceback (most recent call last):
  File "<ipython-input-9-6d4d8c26d370>", line 1, in <module>
    math.isnan(a)
TypeError: a float is required

In [10]: len(a) == 0
Traceback (most recent call last):
  File "<ipython-input-10-65b72372873e>", line 1, in <module>
    len(a) == 0
TypeError: object of type 'NoneType' has no len()

Type NaN

In [11]: b = float('nan')
In [12]: b
Out[12]: nan

In [13]: not b
Out[13]: False

In [14]: b != b
Out[14]: True

In [15]: math.isnan(b)
Out[15]: True

Comment supprimer des éléments NaN (float) d'une liste de types de données mixtes

Si vous avez des types mixtes dans un itérable, voici une solution qui n'utilise pas numpy:

from math import isnan

Z = ['a','b', float('NaN'), 'd', float('1.1024')]

[x for x in Z if not (
                      type(x) == float # let's drop all float values…
                      and isnan(x) # … but only if they are nan
                      )]

['a', 'b', 'd', 1.1024]

L'évaluation de court-circuit signifie que isnanles valeurs qui ne sont pas de type «flottant» ne seront pas appelées, car elles False and (…)sont évaluées rapidement Falsesans avoir à évaluer le côté droit.

En Python 3.6, la vérification d'une valeur de chaîne x math.isnan (x) et np.isnan (x) déclenche une erreur. Je ne peux donc pas vérifier si la valeur donnée est NaN ou non si je ne sais pas au préalable que c'est un nombre. Ce qui suit semble résoudre ce problème

if str(x)=='nan' and type(x)!='str':
    print ('NaN')
else:
    print ('non NaN')

Il semble que vérifier s'il est égal à lui-même

x!=x

est le plus rapide.

import pandas as pd 
import numpy as np 
import math 

x = float('nan')

%timeit x!=x                                                                                                                                                                                                                        
44.8 ns ± 0.152 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

%timeit math.isnan(x)                                                                                                                                                                                                               
94.2 ns ± 0.955 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

%timeit pd.isna(x) 
281 ns ± 5.48 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%timeit np.isnan(x)                                                                                                                                                                                                                 
1.38 µs ± 15.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Pour nan de type flotteur

>>> import pandas as pd
>>> value = float(nan)
>>> type(value)
>>> <class 'float'>
>>> pd.isnull(value)
True
>>>
>>> value = 'nan'
>>> type(value)
>>> <class 'str'>
>>> pd.isnull(value)
False

pour les chaînes en panda, prenez pd.isnull:

if not pd.isnull(atext):
  for word in nltk.word_tokenize(atext):

la fonction d'extraction de fonctionnalités pour NLTK

def act_features(atext):
features = {}
if not pd.isnull(atext):
  for word in nltk.word_tokenize(atext):
    if word not in default_stopwords:
      features['cont({})'.format(word.lower())]=True
return features