float('nan')resulta em Nan (não é um número). Mas como faço para verificar isso? Deve ser muito fácil, mas não consigo encontrá-lo.

math.isnan (x)

Retorne Truese x for um NaN (não um número) e Falsecaso contrário.

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

A maneira usual de testar um NaN é ver se é igual a si mesmo:

def isNaN(num):
    return num != num

numpy.isnan(number)diz se é NaNou não.

Aqui estão três maneiras pelas quais você pode testar uma variável: "NaN" ou não.

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

Resultado

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

aqui está uma resposta trabalhando com:

• Implementações de NaN respeitando o padrão IEEE 754
  • ou seja: de python NaN: float('nan'), numpy.nan...
• quaisquer outros objetos: string ou qualquer outra coisa (não gera exceções, se encontrado)

Um NaN implementado seguindo o padrão é o único valor para o qual a comparação de desigualdade com ele mesmo deve retornar True:

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

E alguns exemplos:

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

Resultado:

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

Na verdade, eu me deparei com isso, mas para mim estava checando nan, -inf ou inf. Eu apenas usei

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

Isso é verdadeiro para números, falso para nan e ambos inf, e gerará uma exceção para coisas como strings ou outros tipos (o que provavelmente é uma coisa boa). Além disso, isso não requer a importação de bibliotecas como matemática ou numpy (numpy é tão grande que dobra o tamanho de qualquer aplicativo compilado).

math.isnan ()

ou compare o número consigo mesmo. NaN é sempre! = NaN, caso contrário (por exemplo, se for um número), a comparação deve ser bem-sucedida.

Outro método, se você estiver preso em <2.6, não ficará entorpecido e não terá suporte ao IEEE 754:

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

Bem, eu entrei neste post, porque tive alguns problemas com a função:

math.isnan()

Há um problema ao executar este código:

a = "hello"
math.isnan(a)

Isso gera exceção. Minha solução para isso é fazer outra verificação:

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

Com python <2.6 acabei com

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

Isso funciona para mim com python 2.5.1 em uma caixa Solaris 5.9 e com python 2.6.5 no Ubuntu 10

Estou recebendo os dados de um serviço da web que envia NaNcomo uma string 'Nan'. Mas também poderia haver outros tipos de string nos meus dados, portanto, um simples float(value)poderia gerar uma exceção. Eu usei a seguinte variante da resposta aceita:

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

Requerimento:

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

Todos os métodos para saber se a variável é NaN ou None:

Nenhum 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

Como remover itens NaN (flutuantes) de uma lista de tipos de dados mistos

Se você misturou tipos em um iterável, aqui está uma solução que não 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]

A avaliação de curto-circuito significa que isnannão serão chamados valores que não são do tipo 'flutuante', como é False and (…)avaliado rapidamente, Falsesem a necessidade de avaliar o lado direito.

No Python 3.6, a verificação de um valor de string x math.isnan (x) e np.isnan (x) gera um erro. Portanto, não posso verificar se o valor fornecido é NaN ou não, se não souber de antemão que é um número. O seguinte parece resolver este problema

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

Parece que verificar se é igual a si mesmo

x!=x

é o mais 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 do tipo float

>>> 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 seqüências de caracteres no panda, pegue pd.isnull:

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

a função como extração de recurso 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