Réponses:
Retourne
True
si x est un NaN (pas un nombre), etFalse
sinon.
>>> import math
>>> x = float('nan')
>>> math.isnan(x)
True
math.isnan
préféré à np.isnan()
?
import numpy
prend environ 15 Mo de RAM, alors qu'il en import math
faut environ 0,2 Mo
numpy.isnan
c'est un choix supérieur, car il gère les tableaux NumPy. Si vous n'utilisez pas NumPy, il n'y a aucun avantage à prendre une dépendance NumPy et à passer du temps à charger NumPy juste pour une vérification NaN (mais si vous écrivez le type de code qui fait des vérifications NaN, il est probable que vous devriez utiliser NumPy).
La façon habituelle de tester un NaN est de voir s'il est égal à lui-même:
def isNaN(num):
return num != num
numpy.isnan(number)
vous dit si c'est le cas NaN
ou non.
numpy.all(numpy.isnan(data_list))
est également utile si vous devez déterminer si tous les éléments de la liste sont nan
all(map(math.isnan, [float("nan")]*5))
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)}")
Production
It's pd.isna : True
It's np.isnan : True
It's math.isnan : True
ps.isna()
résout mes problèmes. Merci!
voici une réponse avec:
float('nan')
, numpy.nan
...Un NaN implémenté suivant la norme, est la seule valeur pour laquelle la comparaison des inégalités avec lui-même doit retourner True:
def is_nan(x):
return (x != x)
Et quelques exemples:
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)}")
Production:
nan : True
nan : True
55 : False
'string' : False
<function <lambda> at 0x000000000927BF28> : False
numpy.nan
est un float
objet Python standard , tout comme le type retourné par float('nan')
. La plupart des NaN que vous rencontrez dans NumPy ne seront pas l' numpy.nan
objet.
numpy.nan
définit sa valeur NaN sur sa propre dans la bibliothèque sous - jacente en C . Il n'emballe pas le NaN de python. Mais maintenant, ils sont tous deux conformes à la norme IEEE 754 car ils s'appuient sur l'API C99.
float('nan') is float('nan')
(non unique) et np.nan is np.nan
(unique)
np.nan
est un objet spécifique, tandis que chaque float('nan')
appel produit un nouvel objet. Si vous le faisiez nan = float('nan')
, vous en auriez nan is nan
aussi. Si vous construisiez un véritable NumPy NaN avec quelque chose comme ça np.float64('nan')
, vous en auriez np.float64('nan') is not np.float64('nan')
aussi .
En fait, je suis juste tombé sur cela, mais pour moi, il vérifiait nan, -inf ou inf. Je viens d'utiliser
if float('-inf') < float(num) < float('inf'):
Cela est vrai pour les nombres, faux pour nan et les deux inf, et soulèvera une exception pour des choses comme les chaînes ou d'autres types (ce qui est probablement une bonne chose). De plus, cela ne nécessite pas d'importer de bibliothèques comme math ou numpy (numpy est tellement gros qu'il double la taille de toute application compilée).
math.isfinite
n'a pas été introduit avant Python 3.2, donc étant donné la réponse de @DaveTheScientist publiée en 2012, ce n'était pas exactement "réinventer [la roue]" - la solution représente toujours ceux qui travaillent avec Python 2.
ou comparer le nombre à lui-même. NaN est toujours! = NaN, sinon (par exemple s'il s'agit d' un nombre) la comparaison doit réussir.
Eh bien, je suis entré dans ce message, car j'ai eu quelques problèmes avec la fonction:
math.isnan()
Il y a un problème lorsque vous exécutez ce code:
a = "hello"
math.isnan(a)
Cela soulève une exception. Ma solution est de faire une autre vérification:
def is_nan(x):
return isinstance(x, float) and math.isnan(x)
def is_nan(x): try: return math.isnan(x) except: return False
Avec python <2.6, je me suis retrouvé avec
def isNaN(x):
return str(float(x)).lower() == 'nan'
Cela fonctionne pour moi avec python 2.5.1 sur une boîte Solaris 5.9 et avec python 2.6.5 sur Ubuntu 10
-1.#IND
Je reçois les données d'un service Web qui envoie NaN
sous forme de chaîne 'Nan'
. Mais il pourrait y avoir d'autres types de chaînes dans mes données, donc un simple float(value)
pourrait lever une exception. J'ai utilisé la variante suivante de la réponse acceptée:
def isnan(value):
try:
import math
return math.isnan(float(value))
except:
return False
Exigence:
isnan('hello') == False
isnan('NaN') == True
isnan(100) == False
isnan(float('nan')) = True
try: int(value)
value
être NaN
ou non?
NaN
(comme en python ce que vous pourriez obtenir float('inf') * 0
), et donc bien que la chaîne 'Hello' ne soit pas un nombre, mais ce n'est pas non plus NaN
parce que NaN
c'est toujours une valeur numérique!
int(value)
Pour toutes les exceptions, False
sera écrit.
Toutes les méthodes pour savoir si la variable est NaN ou None:
Aucun 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()
Type 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
Si vous avez des types mixtes dans un itérable, voici une solution qui n'utilise pas 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]
L'évaluation de court-circuit signifie que isnan
les valeurs qui ne sont pas de type «flottant» ne seront pas appelées, car elles False and (…)
sont évaluées rapidement False
sans avoir à évaluer le côté droit.
En Python 3.6, la vérification d'une valeur de chaîne x math.isnan (x) et np.isnan (x) déclenche une erreur. Je ne peux donc pas vérifier si la valeur donnée est NaN ou non si je ne sais pas au préalable que c'est un nombre. Ce qui suit semble résoudre ce problème
if str(x)=='nan' and type(x)!='str':
print ('NaN')
else:
print ('non NaN')
Il semble que vérifier s'il est égal à lui-même
x!=x
est le plus rapide.
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)
pour les chaînes en panda, prenez pd.isnull:
if not pd.isnull(atext):
for word in nltk.word_tokenize(atext):
la fonction d'extraction de fonctionnalités pour 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