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