En Python, le type de nombre à virgule flottante float est une représentation 64 bits d’un nombre à virgule flottante double précision, équivalent à double dans d’autres langages de programmation tels que C.
Cet article explique comment obtenir et vérifier la plage (valeurs maximales et minimales) que float peut représenter en Python.
Dans de nombreux environnements, la plage est la suivante.
-1.7976931348623157e+308 <= f <= 1.7976931348623157e+308
Cet article décrit le contenu suivant.
- float est un nombre à virgule flottante double précision en Python
- Informations sur le flotteur :
sys.float_info - La valeur maximale que float peut représenter :
sys.float_info.max - La valeur minimale que float peut représenter
- La valeur négative minimale
- La valeur normalisée positive minimale :
sys.float_info.min - La valeur dénormalisée positive minimale
Notez qu’il n’y a pas de limite pour le type entier int en Python3.
Le type flottant a également une valeur spéciale, inf, qui représente l’infini.
float est un nombre à virgule flottante double précision en Python
En Python, les nombres à virgule flottante sont généralement implémentés à l’aide du langage C double, comme décrit dans la documentation officielle.
Les nombres à virgule flottante sont généralement implémentés en utilisant double en C ;
Types intégrés — documentation Python 3.9.7
À moins que vous n’utilisiez une implémentation spéciale qui n’est pas CPython, vous pouvez supposer que double est utilisé. Vous pouvez vérifier la précision réelle en utilisant sys.float_info décrit ci-dessous.
Le nombre à virgule flottante double précision double est une représentation de nombre à virgule flottante 64 bits.
Dans de nombreux autres langages de programmation, tels que C, les nombres à virgule flottante simple précision sont utilisés comme flottants et les nombres à virgule flottante double précision comme double, mais en Python, la double précision est appelée float et il n’y a pas de type simple précision. .
Notez que dans NumPy, vous pouvez spécifier explicitement le type avec le nombre de bits, comme float32, float64.
Informations sur le flotteur :sys.float_info
Utilisez sys.float_info pour obtenir des informations sur float.
Le module sys est inclus dans la bibliothèque standard, aucune installation supplémentaire n’est donc requise.
import sys
print(sys.float_info)
# sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)
print(type(sys.float_info))
# <class 'sys.float_info'>
Vous pouvez obtenir la valeur de chaque élément sous forme d’attribut, comme sys.float_info..
print(sys.float_info.max)
# 1.7976931348623157e+308
Voir la documentation officielle pour une liste des éléments et leurs explications. Chaque élément correspond à une constante à virgule flottante définie dans le fichier d’en-tête standard float.h du langage C.
| attribut | macro float.h | explication |
|---|---|---|
| epsilon | DBL_EPSILON | différence entre 1,0 et la plus petite valeur supérieure à 1,0 représentable sous forme de nombre flottant |
| tu | DBL_DIG | nombre maximal de chiffres décimaux pouvant être fidèlement représentés dans un flottant |
| mant_vous | DBL_MANT_DIG | précision du flottant : le nombre de chiffres de base dans le signifiant d’un flottant |
| maximum | DBL_MAX | flotteur fini positif maximum représentable |
| exp_max | DBL_MAX_EXP | entier maximum e tel que radix**(e-1) soit un flottant fini représentable |
| max_10_exp | DBL_MAX_10_EXP | entier maximum e tel que 10**e soit dans la gamme des flottants finis représentables |
| min | DBL_MIN | flotteur normalisé positif minimum représentable |
| exp_min | DBL_MIN_EXP | entier minimum e tel que radix**(e-1) soit un flottant normalisé |
| min_10_exp | DBL_MIN_10_EXP | entier minimum e tel que 10**e soit un flottant normalisé |
| base | FLT_RADIX | base de la représentation des exposants |
| Les manches | FLT_ROUNDS | constante entière représentant le mode d’arrondi utilisé pour les opérations arithmétiques. Cela reflète la valeur de la macro système FLT_ROUNDS au démarrage de l’interpréteur |
La valeur maximale que float peut représenter :sys.float_info.max
Vous pouvez obtenir la valeur maximale que float peut représenter avec sys.float_info.max. e+XXX signifie 10 à la puissance XXX. + est facultatif.
print(sys.float_info.max)
# 1.7976931348623157e+308
Les valeurs supérieures sont traitées comme inf, ce qui signifie l’infini. Voir l’article suivant pour plus de détails sur inf.
print(1.8e+308)
# inf
print(type(1.8e+308))
# <class 'float'>
En hexadécimal, c’est comme suit.
print(sys.float_info.max.hex())
# 0x1.fffffffffffffp+1023
La valeur minimale que float peut représenter
La valeur négative minimale
La valeur négative minimale que float peut représenter est sys.float_info.max avec -. Les valeurs plus petites que cela sont traitées comme l’infini négatif.
print(-sys.float_info.max)
# -1.7976931348623157e+308
print(-1.8e+308)
# -inf
print(type(-1.8e+308))
# <class 'float'>
La valeur normalisée positive minimale :sys.float_info.min
Vous pouvez obtenir la valeur normalisée positive minimale avec sys.float_info.min.
print(sys.float_info.min)
# 2.2250738585072014e-308
Un nombre normalisé est une valeur dont la partie exposant n’est pas 0. sys.float_info.min est comme suit en hexadécimal.
print(sys.float_info.min.hex())
# 0x1.0000000000000p-1022
La valeur dénormalisée positive minimale
sys.float_info.min est la valeur normalisée positive minimale.
Les valeurs dont la partie exposant est 0 et dont la partie mantisse n’est pas 0 sont appelées nombres dénormalisés.
La valeur dénormalisée positive minimale peut être convertie à partir d’une chaîne hexadécimale comme suit :
print(float.fromhex('0x0.0000000000001p-1022'))
# 5e-324
print(format(float.fromhex('0x0.0000000000001p-1022'), '.17'))
# 4.9406564584124654e-324
Une valeur inférieure à celle-ci est considérée comme 0,0.
print(1e-323)
# 1e-323
print(1e-324)
# 0.0
Dans Python 3.9 ou version ultérieure, vous pouvez obtenir la valeur dénormalisée positive minimale en transmettant 0,0 à la fonction nouvellement ajoutée math.ulp().
import math
print(math.ulp(0.0))
# 5e-324
print(format(math.ulp(0.0), '.17'))
# 4.9406564584124654e-324