float('nan')da como resultado Nan (no es un número). Pero, ¿cómo lo compruebo? Debería ser muy fácil, pero no puedo encontrarlo.

matemáticas.isnan (x)

Devuelve Truesi x es un NaN (no un número), y de lo Falsecontrario.

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

La forma habitual de probar un NaN es ver si es igual a sí mismo:

def isNaN(num):
    return num != num

numpy.isnan(number)te dice si es NaNo no.

Aquí hay tres formas en las que puede probar que una variable sea "NaN" o no.

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)}")

Salida

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

Aquí hay una respuesta trabajando con:

• Implementaciones NaN respetando el estándar IEEE 754
  • es decir: NaN de pitón: float('nan'), numpy.nan...
• cualquier otro objeto: cadena o lo que sea (no genera excepciones si se encuentra)

Un NaN implementado siguiendo el estándar es el único valor para el cual la comparación de desigualdad consigo misma debería devolver True:

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

Y algunos ejemplos:

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)}")

Salida:

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

De hecho, me encontré con esto, pero para mí estaba buscando nan, -inf o inf. Acabo de usar

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

Esto es cierto para los números, falso para nan y ambos inf, y generará una excepción para cosas como cadenas u otros tipos (que probablemente sea algo bueno). Además, esto no requiere importar ninguna biblioteca como matemática o numpy (numpy es tan grande que duplica el tamaño de cualquier aplicación compilada).

math.isnan ()

o compara el número consigo mismo. NaN es siempre! = NaN, de lo contrario (por ejemplo, si es un número) la comparación debería tener éxito.

Otro método si está atascado en <2.6, no tiene numpy y no tiene soporte IEEE 754:

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

Bueno, entré en esta publicación, porque he tenido algunos problemas con la función:

math.isnan()

Hay un problema cuando ejecuta este código:

a = "hello"
math.isnan(a)

Se plantea una excepción. Mi solución para eso es hacer otra verificación:

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

Con python <2.6 terminé con

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

Esto funciona para mí con python 2.5.1 en un cuadro de Solaris 5.9 y con python 2.6.5 en Ubuntu 10

Estoy recibiendo los datos de un servicio web que se envía NaNcomo una cadena 'Nan'. Pero también podría haber otros tipos de cadenas en mis datos, por lo que un simple float(value)podría arrojar una excepción. Usé la siguiente variante de la respuesta aceptada:

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

Requisito:

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

Todos los métodos para saber si la variable es NaN o Ninguna:

Ninguno tipo

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()

Tipo 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

Cómo eliminar los elementos NaN (flotantes) de una lista de tipos de datos mixtos

Si tiene tipos mixtos en un iterable, aquí hay una solución que no usa 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]

La evaluación de cortocircuito significa que isnanno se invocará en valores que no sean del tipo 'flotante', como False and (…)se evalúa rápidamente Falsesin tener que evaluar el lado derecho.

En Python 3.6, verificar un valor de cadena x math.isnan (x) y np.isnan (x) genera un error. Por lo tanto, no puedo verificar si el valor dado es NaN o no si no sé de antemano que es un número. Lo siguiente parece resolver este problema

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

Parece que comprobar si es igual a sí mismo

x!=x

Es el más rápido.

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)

Para nan de tipo flotante

>>> 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

para cadenas en panda tome pd.isnull:

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

la función como extracción de características para 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