Python Language Math Module Infinity and NaN ("not a number")

Help us to keep this website almost Ad Free! It takes only 10 seconds of your time:
> Step 1: Go view our video on YouTube: EF Core Bulk Extensions
> Step 2: And Like the video. BONUS: You can also share it!

Example

In all versions of Python, we can represent infinity and NaN ("not a number") as follows:

pos_inf = float('inf')     # positive infinity
neg_inf = float('-inf')    # negative infinity
not_a_num = float('nan')   # NaN ("not a number")

In Python 3.5 and higher, we can also use the defined constants math.inf and math.nan:

Python 3.x3.5
pos_inf = math.inf
neg_inf = -math.inf
not_a_num = math.nan

The string representations display as inf and -inf and nan:

pos_inf, neg_inf, not_a_num
# Out: (inf, -inf, nan)

We can test for either positive or negative infinity with the isinf method:

math.isinf(pos_inf)
# Out: True

math.isinf(neg_inf)
# Out: True

We can test specifically for positive infinity or for negative infinity by direct comparison:

pos_inf == float('inf')    # or  == math.inf in Python 3.5+
# Out: True

neg_inf == float('-inf')   # or  == -math.inf in Python 3.5+
# Out: True

neg_inf == pos_inf
# Out: False

Python 3.2 and higher also allows checking for finiteness:

Python 3.x3.2
math.isfinite(pos_inf)
# Out: False

math.isfinite(0.0)
# Out: True

Comparison operators work as expected for positive and negative infinity:

import sys

sys.float_info.max
# Out: 1.7976931348623157e+308  (this is system-dependent)

pos_inf > sys.float_info.max
# Out: True

neg_inf < -sys.float_info.max
# Out: True

But if an arithmetic expression produces a value larger than the maximum that can be represented as a float, it will become infinity:

pos_inf == sys.float_info.max * 1.0000001
# Out: True

neg_inf == -sys.float_info.max * 1.0000001
# Out: True

However division by zero does not give a result of infinity (or negative infinity where appropriate), rather it raises a ZeroDivisionError exception.

try:
    x = 1.0 / 0.0
    print(x)
except ZeroDivisionError:
    print("Division by zero")

# Out: Division by zero

Arithmetic operations on infinity just give infinite results, or sometimes NaN:

-5.0 * pos_inf == neg_inf
# Out: True

-5.0 * neg_inf == pos_inf
# Out: True

pos_inf * neg_inf == neg_inf
# Out: True

0.0 * pos_inf
# Out: nan

0.0 * neg_inf
# Out: nan

pos_inf / pos_inf
# Out: nan

NaN is never equal to anything, not even itself. We can test for it is with the isnan method:

not_a_num == not_a_num
# Out: False

math.isnan(not_a_num)
Out: True

NaN always compares as "not equal", but never less than or greater than:

not_a_num != 5.0   # or any random value
# Out: True

not_a_num > 5.0   or   not_a_num < 5.0   or   not_a_num == 5.0
# Out: False

Arithmetic operations on NaN always give NaN. This includes multiplication by -1: there is no "negative NaN".

5.0 * not_a_num
# Out: nan

float('-nan')
# Out: nan
Python 3.x3.5
-math.nan
# Out: nan

There is one subtle difference between the old float versions of NaN and infinity and the Python 3.5+ math library constants:

Python 3.x3.5
math.inf is math.inf, math.nan is math.nan
# Out: (True, True)

float('inf') is float('inf'), float('nan') is float('nan')
# Out: (False, False)


Got any Python Language Question?