Python math.isnan(): Detect NaN Values

Syntax & Parameters 🔝

The math.isnan() function is provided by the standard math module:

import math

is_nan = math.isnan(x)

Return Value: Returns a boolean True if x represents NaN; otherwise returns False.

The IEEE 754 Paradox: Why == and 'is' Fail for NaN 🔝

A classic pitfall in computer science is attempting to test for NaN using the equality operator (==) or identity operator (is):

val = float("nan")

print(val == val)           # False! (NaN is never equal to itself)
print(val == float("nan"))  # False!
print(val is float("nan"))  # False! (Different memory references)

# The correct and authoritative approach:
import math
print(math.isnan(val))      # True

False
False
False
True

Fun Fact: Because NaN is defined as unequal to itself, an old trick to check if a variable x is NaN without importing math is testing x != x, which evaluates to True exclusively for NaN. However, using math.isnan(x) is vastly preferred for readability and code clarity.

Generating NaN Values in Python 🔝

In Python, NaN values arise in two primary ways:

1. Explicit Creation

Passing the string "nan" (case-insensitive) to float():

nan1 = float("nan")
nan2 = float("NaN")
nan3 = float("NAN")

2. Indeterminate Mathematical Operations

Operations involving infinity that have no defined mathematical solution result in NaN:

inf = float("inf")

print(math.isnan(inf / inf))  # True (Infinity divided by Infinity)
print(math.isnan(inf - inf))  # True (Infinity minus Infinity)
print(math.isnan(0 * inf))    # True (Zero multiplied by Infinity)

The Float Inspection Trio: isnan vs. isinf vs. isfinite 🔝

The Python standard library provides three complementary functions to classify any floating-point number:

Filtering NaN Values in Lists 🔝

When working with numerical lists, NaN values propagate through calculations (e.g. sum([1.0, 2.0, float('nan')]) returns nan). Use a list comprehension to filter out missing or invalid values:

import math

raw_measurements = [10.2, float("nan"), 12.5, 9.8, float("nan"), 11.1]

# Filter out NaN items
clean_data = [x for x in raw_measurements if not math.isnan(x)]

print("Cleaned data: ", clean_data)
print("Average value:", sum(clean_data) / len(clean_data))

Cleaned data:  [10.2, 12.5, 9.8, 11.1]
Average value: 10.9

NaN in Data Science: Python vs. NumPy & Pandas 🔝

In data analytics, missing numerical entries in Pandas DataFrames are encoded as NaN. While math.isnan() works on single numbers, Pandas and NumPy offer vectorized methods:

• Use math.isnan(val) for individual scalar numbers in pure Python scripts.
• Use pd.isna(series) or series.isnull() when checking entire columns in Pandas.
• To drop missing values in tables, use df.dropna(), or replace them with defaults using df.fillna().

TypeError & Non-Numeric Handling 🔝

Passing non-numeric types (such as strings or lists) directly to math.isnan() raises a TypeError:

import math

try:
    math.isnan("nan")  # Passing string rather than float
except TypeError as err:
    print("Caught expected type error:", err)
# Output: Caught expected type error: must be real number, not str

Hands-on Exercise: Telemetry Sensor Data Cleaner with Assertions 🔝

Let's construct an automated data cleaning utility that ingests noisy IoT sensor streams, converts values, drops NaNs and infinities, and computes calibrated averages with unit assertions:

import math

def sanitize_telemetry(readings):
    clean = []
    for item in readings:
        try:
            val = float(item)
            # Keep only real numbers that are not NaN and not Infinite
            if not math.isnan(val) and math.isfinite(val):
                clean.append(val)
        except (ValueError, TypeError):
            continue  # Ignore corrupted text strings
    return clean

sensor_stream = [22.4, float("nan"), 23.1, "DEVICE_OFFLINE", float("inf"), 22.9, float("nan")]
sanitized = sanitize_telemetry(sensor_stream)

# Unit Assertions
assert sanitized == [22.4, 23.1, 22.9]
assert len(sanitized) == 3
assert round(sum(sanitized) / len(sanitized), 2) == 22.8

print("Sanitized readings:", sanitized)
print("All sensor telemetry unit assertions passed successfully!")

Practice in Google Colab & GitHub 🔝

Open in Google Colab View on GitHub

Run all math.isnan() examples interactively, test the NaN equality paradox, and verify the telemetry sanitizer with unit assertions directly in Google Colab.

More Details & Related Guides 🔝

• Python Math Module Overview — Master arithmetic, trigonometry, and numeric constants in Python.
• math.isinf() Function — Check if numbers are positive or negative infinity.
• math.isfinite() Function — Confirm that a number is neither NaN nor Infinite.
• float() Constructor — Convert strings and integers into floating-point numbers.
• Pandas isnull() & isna() — Detect missing values across tabular Series and DataFrames.
• Exception Handling in Python — Manage TypeError, ValueError, and ZeroDivisionError gracefully.

Subhendu Mohapatra

Author & Instructor at plus2net

I write and maintain practical tutorials on Python, PHP, SQL, JavaScript, HTML, jQuery, and web development at plus2net. The tutorials focus on clear explanations, working examples, and code that readers can test and adapt while learning.

About the author   Watch on YouTube

Connect: