Explication détaillée sur le jugement d'Inf et Nan en Python

Cet article présente principalement le problème du jugement d'Inf et Nan en Python. L'article le présente en détail et a une certaine valeur de référence pour que tous les amis dans le besoin puissent y jeter un œil ci-dessous.

Tout le monde sait qu'en Python on peut exprimer l'infini positif et négatif de la manière suivante :

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

Utilisez inf(infinite) pour multiplier par 0. Obtenez not-a-number(NaN). Si un nombre dépasse l'infini, c'est un nombre NaN（not a number）. Dans un nombre NaN, sa partie exposant est la valeur maximale exprimable, qui est FF (simple précision), 7FF (double précision) et 7FFF (double précision étendue). La différence entre les nombres NaN et les nombres infinis est que la partie significative du nombre infini est 0 (le bit63 de la double précision étendue est 1 tandis que la partie significative du nombre NaN n'est pas 0) ;

Regardons d'abord le code suivant :

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

Si vous n'avez pas essayé de juger en Python Qu'un nombre à virgule flottante soit NaN, vous serez certainement surpris par le résultat de sortie ci-dessus. Tout d'abord, si vous utilisez is pour opérer sur l'infini positif et négatif et NaN lui-même, le résultat est True. Il ne semble y avoir aucun problème ici mais si vous utilisez == pour opérer, le résultat est différent et NaN devient False ; . Si vous redéfinissez une variable avec float et que vous la comparez avec is et ==, le résultat est toujours inattendu. Les raisons de cette situation sont un peu compliquées, je n'entrerai donc pas dans les détails ici. Si vous êtes intéressé, vous pouvez vérifier les informations pertinentes.

Si vous souhaitez déterminer correctement les valeurs Inf et Nan, alors vous devez utiliser les fonctions math.isinf et math.isnan du module mathématique :

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

Ce sera exact. Pendant que j'y suis, voici un autre conseil : n'essayez pas d'utiliser is et == pour déterminer si un objet est infini ou NaN en Python. Utilisez simplement le module de mathématiques avec obéissance, sinon vous vous attirerez des ennuis.

Bien sûr, il existe d'autres façons de porter des jugements. NaN est utilisé comme exemple ci-dessous, mais il est toujours recommandé d'utiliser le module mathématique pour éviter de vous confondre.

Utilisez l'objet lui-même pour vous juger

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

Utilisez les fonctions de le module numpy

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

La fonction isnan de Numpy peut également juger la liste entière :

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

Le np.isnan renvoie ici un tableau de valeurs booléennes Si la position correspondante est NaN, elle renvoie True, sinon elle renvoie False.

Pour des explications plus détaillées sur le jugement d'Inf et Nan en Python, veuillez faire attention au site PHP chinois !