Hoe kan ik controleren op NaN-waarden?

float('nan')resulteert in Nan (geen getal). Maar hoe controleer ik dit? Zou heel gemakkelijk moeten zijn, maar ik kan het niet vinden.


Antwoord 1, autoriteit 100%

math.isnan(x)

Retourneer Trueals x een NaN is (geen getal), en anders False.

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

Antwoord 2, autoriteit 28%

De gebruikelijke manier om te testen op een NaN is om te zien of het gelijk is aan zichzelf:

def isNaN(num):
    return num != num

Antwoord 3, autoriteit 13%

numpy.isnan(number)vertelt je of het NaNis of niet.


Antwoord 4, autoriteit 8%

Hier zijn drie manieren waarop u kunt testen of een variabele “NaN” is of niet.

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

Uitvoer

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

Antwoord 5, autoriteit 3%

hier is een antwoord dat werkt met:

  • NaN-implementaties die voldoen aan de IEEE 754-standaard
    • ie: python’s NaN: float('nan'), numpy.nan
  • elke andere objecten: string of wat dan ook (veroorzaakt geen uitzonderingen als ze worden aangetroffen)

Een NaN geïmplementeerd volgens de standaard, is de enige waarde waarvoor de ongelijkheidsvergelijking met zichzelf True moet retourneren:

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

En enkele voorbeelden:

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

Uitvoer:

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

Antwoord 6, autoriteit 2%

Ik kwam dit eigenlijk net tegen, maar voor mij was het controleren op nan, -inf of inf. Ik heb net

. gebruikt

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

Dit geldt voor getallen, onwaar voor nan en beide inf, en zal een uitzondering opleveren voor zaken als strings of andere typen (wat waarschijnlijk een goede zaak is). Je hoeft hiervoor ook geen bibliotheken zoals wiskunde of numpy te importeren (numpy is zo verdomd groot dat het de grootte van een gecompileerde applicatie verdubbelt).


Antwoord 7, autoriteit 2%

Het lijkt erop dat controleren of het gelijk is aan zichzelf

x!=x

is de snelste.

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)

Antwoord 8, autoriteit 2%

math.isnan()

of vergelijk het nummer met zichzelf. NaN is altijd != NaN, anders (bijvoorbeeld als het iseen getal) zou de vergelijking moeten lukken.


Antwoord 9

Nou, ik heb dit bericht ingevoerd, omdat ik wat problemen had met de functie:

math.isnan()

Er is een probleem wanneer u deze code uitvoert:

a = "hello"
math.isnan(a)

Het roept uitzondering op.
Mijn oplossing daarvoor is om nog een keer te controleren:

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

Antwoord 10

Een andere methode als je vastzit op <2.6, je hebt geen numpy en je hebt geen IEEE 754-ondersteuning:

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

Antwoord 11

Met python < 2.6 Ik eindigde met

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

Dit werkt voor mij met python 2.5.1 op een Solaris 5.9-doos en met python 2.6.5 op Ubuntu 10


Antwoord 12

Ik ontvang de gegevens van een webservice die NaNverzendt als een string 'Nan'. Maar er kunnen ook andere soorten strings in mijn gegevens zitten, dus een simpele float(value)kan een uitzondering veroorzaken. Ik heb de volgende variant van het geaccepteerde antwoord gebruikt:

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

Vereiste:

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

Antwoord 13

Alle methoden om te bepalen of de variabele NaN of Geen is:

Geen type

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

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

Antwoord 14

NaN (float) item(s) verwijderen uit een lijst met gemengde gegevenstypen

Als je gemengde typen in een iterable hebt, is hier een oplossing die geen numpy gebruikt:

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]

Kortsluitingsevaluatie betekent dat isnanniet wordt aangeroepen voor waarden die niet van het type ‘float’ zijn, omdat False and (…)snel worden geëvalueerd tot Falsezonder de rechterkant te hoeven evalueren.


Antwoord 15

In Python 3.6 levert het controleren van een stringwaarde x math.isnan(x) en np.isnan(x) een fout op.
Ik kan dus niet controleren of de gegeven waarde NaN is of niet als ik niet van tevoren weet dat het een getal is.
Het volgende lijkt dit probleem op te lossen

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

Antwoord 16

Vergelijking pd.isna, math.isnanen np.isnanen hun flexibiliteit bij het omgaan met verschillende soorten objecten.

De onderstaande tabel laat zien of het type object kan worden gecontroleerd met de gegeven methode:


+------------+-----+---------+------+--------+------+
|   Method   | NaN | numeric | None | string | list |
+------------+-----+---------+------+--------+------+
| pd.isna    | yes | yes     | yes  | yes    | yes  |
| math.isnan | yes | yes     | no   | no     | no   |
| np.isnan   | yes | yes     | no   | no     | yes  | <-- # will error on mixed type list
+------------+-----+---------+------+--------+------+

pd.isna

De meest flexibele methode om te controleren op verschillende soorten ontbrekende waarden.


Geen van de antwoorden dekt de flexibiliteit van pd.isna. Terwijl math.isnanen np.isnanTrueretourneren voor NaN-waarden, kunt u niet controleren op verschillende typen objecten zoals Noneof strings. Beide methoden zullen een fout retourneren, dus het controleren van een lijst met gemengde typen zal omslachtig zijn. Dit terwijl pd.isnaflexibel is en de juiste boolean retourneert voor verschillende soorten typen:

In [1]: import pandas as pd
In [2]: import numpy as np
In [3]: missing_values = [3, None, np.NaN, pd.NA, pd.NaT, '10']
In [4]: pd.isna(missing_values)
Out[4]: array([False,  True,  True,  True,  True, False])

Antwoord 17

Voor nan van het type 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

Antwoord 18

voor strings in panda neem pd.isnull:

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

de functie als feature extractie voor 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

Other episodes