# How can I check for NaN values?

## Question:

`float('nan')` represents NaN (not a number). But how do I check for it?

The usual way to test for a NaN is to see if it’s equal to itself:

``````def isNaN(num):
return num != num
``````
``````>>> import math
>>> x = float('nan')
>>> math.isnan(x)
True
``````

math.isnan()

or compare the number to itself. NaN is always != NaN, otherwise (e.g. if it is a number) the comparison should succeed.

`numpy.isnan(number)` tells you if it’s `NaN` or not.

Another method if you’re stuck on <2.6, you don’t have numpy, and you don’t have IEEE 754 support:

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

With python < 2.6 I ended up with

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

This works for me with python 2.5.1 on a Solaris 5.9 box and with python 2.6.5 on Ubuntu 10

Well I entered this post, because i’ve had some issues with the function:

``````math.isnan()
``````

There are problem when you run this code:

``````a = "hello"
math.isnan(a)
``````

It raises exception.
My solution for that is to make another check:

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

I actually just ran into this, but for me it was checking for nan, -inf, or inf. I just used

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

This is true for numbers, false for nan and both inf, and will raise an exception for things like strings or other types (which is probably a good thing). Also this does not require importing any libraries like math or numpy (numpy is so damn big it doubles the size of any compiled application).

I am receiving the data from a web-service that sends `NaN` as a string `'Nan'`. But there could be other sorts of string in my data as well, so a simple `float(value)` could throw an exception. I used the following variant of the accepted answer:

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

Requirement:

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

All the methods to tell if the variable is NaN or None:

None type

``````In : from numpy import math

In : a = None
In : not a
Out: True

In : len(a or ()) == 0
Out: True

In : a == None
Out: True

In : a is None
Out: True

In : a != a
Out: False

In : 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 : 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 : b = float('nan')
In : b
Out: nan

In : not b
Out: False

In : b != b
Out: True

In : math.isnan(b)
Out: True
``````

here is an answer working with:

• NaN implementations respecting IEEE 754 standard
• ie: python’s NaN: `float('nan')`, `numpy.nan`
• any other objects: string or whatever (does not raise exceptions if encountered)

A NaN implemented following the standard, is the only value for which the inequality comparison with itself should return True:

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

And some examples:

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

Output:

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

For nan of 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
``````

for strings in panda take pd.isnull:

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

the function as feature extraction for 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
``````

How to remove NaN (float) item(s) from a list of mixed data types

If you have mixed types in an iterable, here is a solution that does not use 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]`

Short-circuit evaluation means that `isnan` will not be called on values that are not of type ‘float’, as `False and (…)` quickly evaluates to `False` without having to evaluate the right-hand side.

Here are three ways where you can test a variable is "NaN" or not.

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

Output

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

In Python 3.6 checking on a string value x math.isnan(x) and np.isnan(x) raises an error.
So I can’t check if the given value is NaN or not if I don’t know beforehand it’s a number.
The following seems to solve this issue

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

It seems that checking if it’s equal to itself (`x != x`) is the fastest.

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

Comparison `pd.isna`, `math.isnan` and `np.isnan` and their flexibility dealing with different type of objects.

The table below shows if the type of object can be checked with the given method:

``````
+------------+-----+---------+------+--------+------+
|   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`

The most flexible method to check for different types of missing values.

None of the answers cover the flexibility of `pd.isna`. While `math.isnan` and `np.isnan` will return `True` for `NaN` values, you cannot check for different type of objects like `None` or strings. Both methods will return an error, so checking a list with mixed types will be cumbersom. This while `pd.isna` is flexible and will return the correct boolean for different kind of types:

``````In : import pandas as pd

In : import numpy as np

In : missing_values = [3, None, np.NaN, pd.NA, pd.NaT, '10']

In : pd.isna(missing_values)
Out: array([False,  True,  True,  True,  True, False])
``````
Categories: questions Tags: ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.