Detailed explanation on the judgment of Inf and Nan in Python

This article mainly introduces the problem of judging Inf and Nan in Python. The introduction is very detailed and has certain reference value for everyone. Friends in need can take a look below.

Everyone knows that in Python you can use the following method to express positive and negative infinity:

float("inf") # 正无穷
float("-inf") # 负无穷

Use inf(infinite) Multiplying by 0 gives not-a-number(NaN). If a number exceeds infinite, it is a NaN (not a number) number. In a NaN number, its exponent part is the maximum expressible value, which are FF (single precision), 7FF (double precision), and 7FFF (extended double precision). The difference between NaN numbers and infinite numbers is that the significand part of the infinite number is 0 (bit63 of extended double precision is 1); while the significand part of the NaN number is not 0.

Let’s take a look at the following code first:

>>> inf = float("inf")
>>> ninf = float("-inf")
>>> nan = float("nan")
>>> inf is inf
True
>>> ninf is ninf
True
>>> nan is nan
True
>>> inf == inf
True
>>> ninf == ninf
True
>>> nan == nan
False
>>> inf is float("inf")
False
>>> ninf is float("-inf")
False
>>> nan is float("nan")
False
>>> inf == float("inf")
True
>>> ninf == float("-inf")
True
>>> nan == float("nan")
False

If you have not tried to judge a float in Python Whether the point is NaN, you will definitely be surprised by the above output result. First of all, if you use is to operate on positive and negative infinity and NaN itself, the result is True. There seems to be no problem here; but if you use == to operate, the result is different, and NaN becomes False. If you redefine a variable with float and compare them with is and ==, the result is still unexpected. The reasons for this situation are a little complicated, so I won’t go into details here. If you are interested, you can check the relevant information.

If you want to correctly determine Inf and Nan values, then you should use the math module's math.isinf and math.isnan functions:

>>> import math
>>> math.isinf(inf)
True
>>> math.isinf(ninf)
True
>>> math.isnan(nan)
True
>>> math.isinf(float("inf"))
True
>>> math.isinf(float("-inf"))
True
>>> math.isnan(float("nan"))
True

This is accurate. While I'm on the subject, here's another word of advice: don't try to use is and == to determine whether an object is infinity or NaN in Python. Just use the math module obediently, otherwise you will get yourself into trouble.

Of course there are other ways to make judgments. NaN is used as an example below, but it is still recommended to use the math module to avoid confusing yourself.

Use the object itself to judge yourself

>>> def isnan(num):
...  return num != num
... 
>>> isnan(float("nan"))
True

Use the functions of the numpy module

>>> import numpy as np
>>> 
>>> np.isnan(np.nan)
True
>>> np.isnan(float("nan"))
True
>>> np.isnan(float("inf"))
False

Numpy’s isnan function can also judge the entire list:

>>> lst = [1, float("nan"), 2, 3, np.nan, float("-inf"), 4, np.nan]
>>> lst
[1, nan, 2, 3, nan, -inf, 4, nan]
>>> np.isnan(lst)
array([False, True, False, False, True, False, False, True], dtype=bool)

Herenp.isnan Returns an array of Boolean values. If the corresponding position is NaN, return True, otherwise return False.

For more detailed explanations on the judgment of Inf and Nan in Python, please pay attention to the PHP Chinese website!