float('nan')wyniki w Nan (nie liczba). Ale jak to sprawdzić? Powinno to być bardzo łatwe, ale nie mogę tego znaleźć.

math.isnan (x)

Zwraca, Truejeśli x jest NaN (nie liczbą) i w Falseprzeciwnym razie.

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

Zwykłym sposobem na sprawdzenie NaN jest sprawdzenie, czy jest on równy:

def isNaN(num):
    return num != num

numpy.isnan(number)powie ci, czy to jest NaNczy nie.

Oto trzy sposoby testowania zmiennej na „NaN” lub nie.

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

Wynik

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

oto odpowiedź współpracująca z:

• Implementacje NaN zgodne ze standardem IEEE 754
  • tj .: NaN: python float('nan'), numpy.nan...
• wszelkie inne obiekty: ciąg znaków lub cokolwiek innego (nie stwarza wyjątków, jeśli zostaną napotkane)

NaN zaimplementowany zgodnie ze standardem jest jedyną wartością, dla której porównanie nierówności z samym sobą powinno zwrócić True:

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

I kilka przykładów:

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

Wynik:

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

Właściwie to po prostu na to wpadłem, ale dla mnie sprawdzało to nan, inf lub inf. Właśnie użyłem

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

Dotyczy to liczb, fałszu dla nan i obu inf, i spowoduje wyjątek dla takich rzeczy jak ciągi znaków lub inne typy (co jest prawdopodobnie dobrą rzeczą). Nie wymaga to również importowania bibliotek takich jak matematyka czy numpy (numpy jest tak cholernie duże, że podwaja rozmiar każdej skompilowanej aplikacji).

math.isnan ()

lub porównaj liczbę z samym sobą. NaN jest zawsze! = NaN, w przeciwnym razie (np. Jeśli jest to liczba) porównanie powinno się powieść.

Inna metoda, jeśli utkniesz na <2.6, nie masz numpy i nie masz obsługi IEEE 754:

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

Wpisałem ten post, ponieważ miałem pewne problemy z funkcją:

math.isnan()

Występuje problem po uruchomieniu tego kodu:

a = "hello"
math.isnan(a)

Rodzi wyjątek. Moim rozwiązaniem jest ponowne sprawdzenie:

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

Z pythonem <2.6 skończyłem z

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

Działa to dla mnie z Pythonem 2.5.1 na pudełku Solaris 5.9 iz Pythonem 2.6.5 na Ubuntu 10

Otrzymuję dane z usługi internetowej, która wysyła NaNjako ciąg znaków 'Nan'. Ale w moich danych mogą znajdować się również inne rodzaje ciągów, więc prosty float(value)może zgłosić wyjątek. Użyłem następującego wariantu zaakceptowanej odpowiedzi:

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

Wymaganie:

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

Wszystkie metody określania, czy zmienna ma wartość NaN czy None:

Brak typu

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

Typ 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

Jak usunąć elementy NaN (float) z listy mieszanych typów danych

Jeśli masz iterowalne typy mieszane, oto rozwiązanie, które nie używa 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]

Ocena zwarcia oznacza, że isnannie będą wywoływane wartości, które nie są typu „zmiennoprzecinkowego”, jak False and (…)szybko ocenia, Falsebez konieczności oceny prawej strony.

W Pythonie 3.6 sprawdzenie wartości ciągu x math.isnan (x) i np.isnan (x) powoduje błąd. Nie mogę więc sprawdzić, czy podana wartość to NaN, czy nie, jeśli wcześniej nie wiem, że jest to liczba. Poniższe wydają się rozwiązać ten problem

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

Wygląda na to, że sprawdzenie, czy jest równe sobie

x!=x

jest najszybszy.

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)

Dla pływaka typu 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

dla ciągów w pandzie weź pd.isnull:

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

funkcja jako ekstrakcja funkcji dla 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