float('nan')ergibt Nan (keine Zahl). Aber wie überprüfe ich das? Sollte sehr einfach sein, aber ich kann es nicht finden.

math.isnan (x)

Geben Sie zurück, Truewenn x ein NaN (keine Zahl) ist, und Falseansonsten.

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

Der übliche Weg, um auf ein NaN zu testen, besteht darin, festzustellen, ob es sich selbst entspricht:

def isNaN(num):
    return num != num

numpy.isnan(number)sagt dir, ob es ist NaNoder nicht.

Hier sind drei Möglichkeiten, wie Sie testen können, ob eine Variable "NaN" ist oder nicht.

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

Ausgabe

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

Hier ist eine Antwort, mit der gearbeitet wird:

• NaN-Implementierungen gemäß IEEE 754-Standard
  • dh: Pythons NaN : float('nan'), numpy.nan...
• Alle anderen Objekte: Zeichenfolge oder was auch immer (löst keine Ausnahmen aus, wenn sie auftreten)

Ein nach dem Standard implementiertes NaN ist der einzige Wert, für den der Ungleichheitsvergleich mit sich selbst True zurückgeben sollte:

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

Und einige Beispiele:

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

Ausgabe:

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

Ich bin eigentlich nur darauf gestoßen, aber für mich war es die Suche nach nan, -inf oder inf. Ich habe es gerade benutzt

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

Dies gilt für Zahlen, falsch für nan und beide inf und löst eine Ausnahme für Dinge wie Strings oder andere Typen aus (was wahrscheinlich eine gute Sache ist). Außerdem müssen keine Bibliotheken wie math oder numpy importiert werden (numpy ist so verdammt groß, dass sich die Größe einer kompilierten Anwendung verdoppelt).

math.isnan ()

oder vergleichen Sie die Nummer mit sich selbst. NaN ist immer! = NaN, andernfalls (z. B. wenn es sich um eine Zahl handelt) sollte der Vergleich erfolgreich sein.

Eine andere Methode, wenn Sie auf <2.6 stecken, Sie haben keine Numpy und Sie haben keine IEEE 754-Unterstützung:

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

Nun, ich habe diesen Beitrag eingegeben, weil ich einige Probleme mit der Funktion hatte:

math.isnan()

Beim Ausführen dieses Codes tritt ein Problem auf:

a = "hello"
math.isnan(a)

Es wird eine Ausnahme ausgelöst. Meine Lösung dafür ist eine weitere Überprüfung:

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

Mit Python <2.6 endete ich mit

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

Dies funktioniert für mich mit Python 2.5.1 auf einer Solaris 5.9-Box und mit Python 2.6.5 unter Ubuntu 10

Ich empfange die Daten von einem Webdienst, der NaNals Zeichenfolge sendet 'Nan'. Aber es könnte auch andere Arten von Zeichenfolgen in meinen Daten geben, so dass eine einfache float(value)eine Ausnahme auslösen könnte. Ich habe die folgende Variante der akzeptierten Antwort verwendet:

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

Anforderung:

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

Alle Methoden, um festzustellen, ob die Variable NaN oder None ist:

Kein Typ

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

NaN-Typ

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

So entfernen Sie NaN (float) -Elemente aus einer Liste gemischter Datentypen

Wenn Sie gemischte Typen in einer Iterable haben, ist hier eine Lösung, die numpy nicht verwendet:

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]

Kurzschlussauswertung bedeutet, dass isnanWerte, die nicht vom Typ 'float' sind, nicht aufgerufen werden, da sie False and (…)schnell ausgewertet werden, Falseohne dass die rechte Seite ausgewertet werden muss.

In Python 3.6 löst das Überprüfen eines Zeichenfolgenwerts x math.isnan (x) und np.isnan (x) einen Fehler aus. Ich kann also nicht überprüfen, ob der angegebene Wert NaN ist oder nicht, wenn ich vorher nicht weiß, dass es sich um eine Zahl handelt. Das Folgende scheint dieses Problem zu lösen

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

Es scheint, dass zu überprüfen, ob es sich selbst gleich ist

x!=x

ist der schnellste.

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)

Für nan vom Typ 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

für Strings in Panda nimm pd.isnull:

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

die Funktion als Merkmalsextraktion für 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