¿Cómo puedo verificar los valores de NaN?

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

math.isnan ()

Comprueba si el float x es un NaN (no un número). Los NaN son parte de los estándares IEEE 754. La operación como, pero sin limitarse a, inf * 0, inf / inf o cualquier operación que involucre un NaN, por ejemplo nan * 1, devuelve un NaN.

Nuevo en la versión 2.6.

 >>> 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 NaN o no en Python 2.5.

De hecho, me acabo de encontrar 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 (lo que probablemente sea bueno). Además, esto no requiere importar bibliotecas como math o numpy (el número es tan grande que duplica el tamaño de cualquier aplicación comstackda).

Aquí hay una respuesta trabajando con:

  • Python no único NaN: float('nan')
  • Número único NaN (singleton): np.nan
  • cualquier otro objeto: cadena o lo que sea (no genera excepciones si se encuentran)

Aquí está:

 import numpy as np def is_nan(x): return (x is np.nan or x != x) 

Y algunos ejemplos:

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

Salida:

 nan : True nan : True 55 : False 'string' : False  at 0x000000000927BF28> : False 

math.isnan ()

o comparar el número a sí mismo. NaN siempre es! = 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 números y no tiene soporte de IEEE 754:

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

Bueno, ingresé a esta publicación porque tuve algunos problemas con la función:

 math.isnan() 

Hay un problema cuando ejecutas este código:

 a = "hello" math.isnan(a) 

Se plantea la excepción. Mi solución para eso es hacer otro cheque:

 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 me funciona con python 2.5.1 en una caja de Solaris 5.9 y con python 2.6.5 en Ubuntu 10

Aquí hay tres formas en que puede probar una variable es “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 

Estoy recibiendo los datos de un servicio web que envía NaN como 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 generar 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 Ninguno:

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 "", line 1, in  math.isnan(a) TypeError: a float is required In [10]: len(a) == 0 Traceback (most recent call last): File "", line 1, in  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 elementos de NaN (flotación) 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 no se isnan a isnan en valores que no sean del tipo ‘flotante’ como ( False and … se evalúa rápidamente como False sin tener que evaluar el lado derecho.

Para nan de tipo float

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

para cuerdas en panda tomar pd.isnull:

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

La función como función de extracción 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