Python Language Infinity et NaN ("pas un nombre")


Exemple

Dans toutes les versions de Python, nous pouvons représenter l'infini et NaN ("pas un nombre") comme suit:

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

En Python 3.5 et math.nan ultérieures, nous pouvons également utiliser les constantes définies math.inf et math.nan :

Python 3.x 3.5
pos_inf = math.inf
neg_inf = -math.inf
not_a_num = math.nan

Les représentations de chaîne s'affichent sous la forme inf et -inf et nan :

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

Nous pouvons tester l'infini positif ou négatif avec la méthode isinf :

math.isinf(pos_inf)
# Out: True

math.isinf(neg_inf)
# Out: True

Nous pouvons tester spécifiquement l'infini positif ou l'infini négatif par comparaison directe:

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 et les versions ultérieures permettent également de vérifier la finitude:

Python 3.x 3.2
math.isfinite(pos_inf)
# Out: False

math.isfinite(0.0)
# Out: True

Les opérateurs de comparaison travaillent comme prévu pour l'infini positif et négatif:

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

Mais si une expression arithmétique produit une valeur supérieure au maximum pouvant être représenté par un float , elle deviendra infinie:

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

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

Cependant, la division par zéro ne donne pas un résultat d'infini (ou d'infini négatif le cas échéant), mais plutôt une exception ZeroDivisionError .

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

# Out: Division by zero

Les opérations arithmétiques sur l'infini donnent simplement des résultats infinis, ou parfois 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 n'est jamais égal à rien, pas même à lui-même. Nous pouvons tester car c'est avec la méthode isnan :

not_a_num == not_a_num
# Out: False

math.isnan(not_a_num)
Out: True

NaN se compare toujours comme "non égal", mais jamais inférieur ou supérieur à:

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

Les opérations arithmétiques sur NaN donnent toujours NaN. Ceci inclut la multiplication par -1: il n'y a pas de "NaN négatif".

5.0 * not_a_num
# Out: nan

float('-nan')
# Out: nan
Python 3.x 3.5
-math.nan
# Out: nan

Il existe une différence subtile entre les anciennes versions float de NaN et infinity et les constantes de la bibliothèque math Python 3.5+:

Python 3.x 3.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)