{"id":123450,"date":"2022-03-31T07:10:26","date_gmt":"2022-03-31T07:10:26","guid":{"rendered":"https:\/\/blog.finxter.com\/?p=273492"},"modified":"2022-03-31T07:10:26","modified_gmt":"2022-03-31T07:10:26","slug":"check-for-nan-values-in-python","status":"publish","type":"post","link":"https:\/\/sickgaming.net\/blog\/2022\/03\/31\/check-for-nan-values-in-python\/","title":{"rendered":"Check for NaN Values in Python"},"content":{"rendered":"

Overview<\/strong><\/h2>\n

Problem<\/strong>: How to check if a given value is NaN<\/code>?<\/p>\n

Here’s a quick look at the solutions to follow:<\/p>\n

import math\nimport numpy as np\nimport pandas as pd x = float('nan')\nprint(math.isnan(x))\nprint(x != x)\nprint(np.isnan(x))\nprint(pd.isna(x))\nprint(not(float('-inf') < x < float('inf')))<\/pre>\n
So, what is a NaN<\/code> value?<\/p>\n
NaN<\/code> is a constant value that indicates that the given value is Not a Number. It’s a floating-point value, hence cannot be converted to any other type other than float. We should know that NaN<\/code> and Null are two different things in Python. The Null values indicate something which does not exist, i.e. is empty. But that is not the case with NaN<\/code>.<\/p>\n
We have to deal with NaN<\/code> values frequently in Python especially when we deal with array objects or DataFrames. So, without further delay, let us dive into our mission critical question and have a look at the different methods to solve our problem.<\/p>\n
Method 1: Using math.isnan()<\/strong><\/h2>\n
The simplest solution to check for NaN values in Python is to use the mathematical function math.isnan()<\/code>.<\/p>\n
math.isnan()<\/code> is a function of the math module in Python that checks for NaN<\/code> constants in float objects and returns True for every NaN value encountered and returns False otherwise. <\/p>\n
Example: <\/strong><\/p>\n
# Importing the math module\nimport math # Function to check for NaN values\ndef isNaN(a): # Using math.isnan() if math.isnan(a): print(\"NaN value encountered!\") else: print(\"Type of Given Value: \", type(a)) # NaN value\nx = float('NaN')\nisNaN(x)\n# Floating value\ny = float(\"5.78\")\nisNaN(y)<\/pre>\n
Output:<\/strong><\/p>\n
NaN value encountered!\nType of Given Value: <class 'float'><\/code><\/pre>\n
In the above example, since x<\/code> represents a NaN value, hence, the isNaN<\/code> method returns True<\/code> but in case of y<\/code> , isNan<\/code> returns False<\/code> and prints the type of the variable y<\/code> as an output. <\/p>\n
Method 2: Hack NaN Using != Operator<\/strong><\/h2>\n
The most unique thing about NaN<\/code> values is that they are constantly shapeshifting. This means we cannot compare the NaN<\/code> value even against itself. Hence, we can use the !=<\/code> (not equal to) operator to check for the NaN<\/code> values. Thus, the idea is to check if the given variable is equal to itself. If we consider any object other than NaN<\/code>, the expression (x == x)<\/code> will always return True<\/code>. If it’s not equal, then it is a NaN<\/code> value. <\/p>\n
Example 1:<\/strong><\/p>\n
print(5 == 5)\n# True\nprint(['a', 'b'] == ['a', 'b'])\n# True\nprint([] == [])\n# True\nprint(float(\"nan\") == float(\"nan\"))\n# False\nprint(float(\"nan\") != float(\"nan\"))\n# True<\/pre>\n
Example 2:<\/strong><\/p>\n
# Function to check for NaN values\ndef not_a_number(x): # Using != operator if x != x: print(\"Not a Number!\") else: print(f'Type of {x} is {type(x)}') # Floating value\nx = float(\"7.8\")\nnot_a_number(x)\n# NaN value\ny = float(\"NaN\")\nnot_a_number(y)<\/pre>\n
Output:<\/strong><\/p>\n
Type of 7.8 is <class 'float'>\nNot a Number!<\/code><\/pre>\n
Method 3: Using numpy<\/a>.isnan()<\/strong><\/h2>\n
We can also use the NumPy<\/code> library to check whether the given value is NaN<\/code> or not. We just need to ensure that we import the library at the start of the program and then use its np.isnan(x)<\/code> method. <\/p>\n
The np.isnan(number)<\/code> function checks whether the element in a Numpy array is NaN<\/code> or not. It then returns the result as a boolean array.<\/p>\n
Example: <\/strong>In the following example we have a Numpy Array and then we will check the type of each value. We will also check if it is a NaN<\/code> value or not.<\/p>\n
import numpy as np arr = np.array([10, 20, np.nan, 40, np.nan])\nfor x in arr: if np.isnan(x): print(\"Not a Number!\") else: print(x, \":\", type(x))<\/pre>\n
Output:<\/strong><\/p>\n
10.0 : <class 'numpy.float64'>\n20.0 : <class 'numpy.float64'>\nNot a Number!\n40.0 : <class 'numpy.float64'>\nNot a Number!<\/code><\/pre>\n
\"\ud83d\udca1\"TRIVIA<\/strong><\/p>\n
Let us try to perform some basic functions on an numpy array that involves NaN<\/code> values and find out what happens to it.<\/p>\n
import numpy as np arr = np.array([10, 20, np.nan, 40, np.nan])\nprint(arr.sum())\nprint(arr.max())<\/pre>\n
Output:<\/strong><\/p>\n
nan\nnan<\/code><\/pre>\n
Now this can be a problem in many cases. So, do we have a way to eliminate the NaN values from our array object and then perform the mathematical operations upon the array elements? Yes! <\/strong>Numpy facilitates us with methods like np.nansum()<\/code> and np.nanmax()<\/code> that help us to calculate the sum and maximum values in the array by ignoring the presence of NaN<\/code> values in the array.<\/p>\n
Example:<\/strong><\/p>\n
import numpy as np arr = np.array([10, 20, np.nan, 40, np.nan])\nprint(np.nansum(arr))\nprint(np.nanmax(arr))<\/pre>\n
Output:<\/strong><\/p>\n
70.0\n40.0<\/code><\/pre>\n
Method 4: Using pandas<\/a>.isna()<\/strong><\/strong><\/h2>\n
Another way to solve our problem is to use the isna()<\/code> method of the Pandas module. pandas.isna()<\/code> is a function that detects missing values in an array-like object. It returns True if any NaN<\/code> value is encountered. <\/p>\n
Example 1:<\/strong><\/p>\n
import pandas as pd x = float(\"nan\")\ny = 25.75\nprint(pd.isna(x))\nprint(pd.isna(y))<\/pre>\n
Output:<\/strong><\/p>\n
True\nFalse<\/code><\/pre>\n
Example 2: <\/strong>In the following example we will have a look at a Pandas DataFrame and detect the presence of NaN values in the DataFrame.<\/p>\n
import pandas as pd df = pd.DataFrame([['Mercury', 'Venus', 'Earth'], ['1', float('nan'), '2']])\nprint(pd.isna(df))<\/pre>\n
Output:<\/strong><\/p>\n
 0 1 2\n0 False False False\n1 False True False<\/code><\/pre>\n
Method 5: By Checking The Range<\/strong><\/h2>\n
We can check for the NaN<\/code> values by using another NaN special property: limited range. The range of all the floating-point values falls within negative infinity to infinity. However, NaN<\/code> values do not fall within this range. <\/p>\n
Hence, the idea is to check whether a given value lies within the range of -inf<\/code> and inf<\/code>. If yes , then it is not a NaN <\/code>value else it is a NaN <\/code>value. <\/p>\n
Example:<\/strong><\/p>\n
li = [25.87, float('nan')]\nfor i in li: if float('-inf') < float(i) < float('inf'): print(i) else: print(\"Not a Number!\")<\/pre>\n
Output:<\/strong><\/p>\n
25.87\nNot a Number!<\/code><\/pre>\n
Recommended read: Python Infinity<\/a><\/strong><\/p>\n
Conclusion<\/strong><\/h2>\n
In this article, we learned how we can use the various methods and modules (pandas<\/code>, NumPy<\/code>, and math<\/code>) in Python to check for the NaN<\/code> values. I hope this article was able to answer your queries. Please stay tuned<\/a><\/strong> and subscribe<\/a><\/strong> for more such articles.\u00a0<\/p>\n
Authors: SHUBHAM SAYON and RASHI AGARWAL<\/strong><\/p>\n
\n
Do you want to become a NumPy master?<\/strong> Check out our interactive puzzle book Coffee Break NumPy<\/strong><\/a> and boost your data science skills! (Amazon link opens in new tab.)<\/em><\/p>\n
\n
\"Coffee<\/a><\/figure>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
Overview Problem: How to check if a given value is NaN? Here’s a quick look at the solutions to follow: import math import numpy as np import pandas as pd x = float(‘nan’) print(math.isnan(x)) print(x != x) print(np.isnan(x)) print(pd.isna(x)) print(not(float(‘-inf’) < x < float(‘inf’))) So, what is a NaN value? NaN is a constant value […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[857],"tags":[73,468,528],"class_list":["post-123450","post","type-post","status-publish","format-standard","hentry","category-python-tut","tag-programming","tag-python","tag-tutorial"],"_links":{"self":[{"href":"https:\/\/sickgaming.net\/blog\/wp-json\/wp\/v2\/posts\/123450","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/sickgaming.net\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/sickgaming.net\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/sickgaming.net\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/sickgaming.net\/blog\/wp-json\/wp\/v2\/comments?post=123450"}],"version-history":[{"count":0,"href":"https:\/\/sickgaming.net\/blog\/wp-json\/wp\/v2\/posts\/123450\/revisions"}],"wp:attachment":[{"href":"https:\/\/sickgaming.net\/blog\/wp-json\/wp\/v2\/media?parent=123450"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/sickgaming.net\/blog\/wp-json\/wp\/v2\/categories?post=123450"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/sickgaming.net\/blog\/wp-json\/wp\/v2\/tags?post=123450"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}