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%
Retourneer
True
als x een NaN is (geen getal), en andersFalse
.
>>> 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 NaN
is 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
…
- ie: python’s 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%
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 NaN
verzendt 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 isnan
niet wordt aangeroepen voor waarden die niet van het type ‘float’ zijn, omdat False and (…)
snel worden geëvalueerd tot False
zonder 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.isnan
en np.isnan
en 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.isnan
en np.isnan
True
retourneren voor NaN
-waarden, kunt u niet controleren op verschillende typen objecten zoals None
of strings. Beide methoden zullen een fout retourneren, dus het controleren van een lijst met gemengde typen zal omslachtig zijn. Dit terwijl pd.isna
flexibel 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