float('nan')risulta in Nan (non un numero). Ma come posso verificarlo? Dovrebbe essere molto semplice, ma non riesco a trovarlo.

math.isnan (x)

Restituisce Truese x è un NaN (non un numero) e in caso Falsecontrario.

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

Il solito modo di testare una NaN è vedere se è uguale a se stesso:

def isNaN(num):
    return num != num

numpy.isnan(number)ti dice se lo è NaNo no.

Ecco tre modi in cui è possibile testare una variabile è "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)}")

Produzione

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

ecco una risposta che funziona con:

• Implementazioni NaN conformi allo standard IEEE 754
  • vale a dire: NaN di pitone: float('nan'), numpy.nan...
• qualsiasi altro oggetto: stringa o altro (non genera eccezioni se rilevato)

Un NaN implementato secondo lo standard è l'unico valore per il quale il confronto delle disuguaglianze con se stesso dovrebbe restituire True:

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

E alcuni esempi:

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

Produzione:

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

In realtà mi sono appena imbattuto in questo, ma per me stava controllando nan, -inf o inf. Ho appena usato

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

Questo vale per i numeri, falso per nan e entrambi inf, e solleverà un'eccezione per cose come stringhe o altri tipi (che è probabilmente una buona cosa). Inoltre, ciò non richiede l'importazione di librerie come matematica o numpy (numpy è così dannatamente grande che raddoppia le dimensioni di qualsiasi applicazione compilata).

math.isnan ()

o confronta il numero con se stesso. NaN è sempre! = NaN, altrimenti (ad es. Se è un numero) il confronto dovrebbe avere esito positivo.

Un altro metodo se sei bloccato su <2.6, non hai intorpidimento e non hai il supporto IEEE 754:

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

Bene, ho inserito questo post, perché ho avuto alcuni problemi con la funzione:

math.isnan()

Ci sono problemi quando si esegue questo codice:

a = "hello"
math.isnan(a)

Solleva un'eccezione. La mia soluzione è quella di fare un altro controllo:

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

Con Python <2.6 ho finito con

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

Questo funziona per me con Python 2.5.1 su una scatola di Solaris 5.9 e con Python 2.6.5 su Ubuntu 10

Sto ricevendo i dati da un servizio Web che invia NaNcome stringa 'Nan'. Ma potrebbero esserci anche altri tipi di stringhe nei miei dati, quindi un semplice float(value)potrebbe generare un'eccezione. Ho usato la seguente variante della risposta accettata:

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

Requisiti:

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

Tutti i metodi per dire se la variabile è NaN o None:

Nessuno 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

Come rimuovere gli elementi NaN (float) da un elenco di tipi di dati misti

Se hai tipi misti in un iterabile, ecco una soluzione che non 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 valutazione del cortocircuito significa che isnannon verrà chiamato su valori che non sono di tipo 'float', come False and (…)valuta rapidamente Falsesenza dover valutare il lato destro.

In Python 3.6 il controllo di un valore stringa x math.isnan (x) e np.isnan (x) genera un errore. Quindi non posso verificare se il valore dato è NaN o no se non so in anticipo che è un numero. Quanto segue sembra risolvere questo problema

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

Sembra che controllando se è uguale a se stesso

x!=x

è il più veloce.

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)

Per galleggiante di tipo nan

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

per stringhe in panda prendere pd.isnull:

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

la funzione come estrazione di funzionalità per 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