Quelle est la plage de valeurs qu'un float peut avoir en Python?
Quelles sont ses valeurs les plus petites et les plus grandes en python?
5 réponses
Parties pertinentes du poste:
In [2]: import kinds In [3]: kinds.default_float_kind.M kinds.default_float_kind.MAX kinds.default_float_kind.MIN kinds.default_float_kind.MAX_10_EXP kinds.default_float_kind.MIN_10_EXP kinds.default_float_kind.MAX_EXP kinds.default_float_kind.MIN_EXP In [3]: kinds.default_float_kind.MIN Out[3]: 2.2250738585072014e-308
>>> import sys
>>> sys.float_info
sys.floatinfo(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.2204460492503131e-16, radix=2, rounds=1)
Le plus petit est sys.float_info.min
(2.2250738585072014 e-308) et le plus grand est sys.float_info.max
(1.7976931348623157 e+308). Voir documentation pour d'autres propriétés.
Update : vous pouvez généralement obtenir un minimum dénormalisé comme sys.float_info.min*sys.float_info.epsilon
. Mais notez, que ces nombres sont représentés avec une perte de précision.
Comme une sorte de complément théorique aux réponses précédentes, je voudrais mentionner que la valeur" magique " ±308 vient directement de la représentation binaire des flottants. les flotteurs à double précision sont de la forme ±C * 2 * * q avec une" petite " valeur fractionnaire c (~1), et q un entier écrit avec 11 chiffres binaires (dont 1 bit pour son signe). Le fait que 2**(2**10-1) ait 308 chiffres (décimaux) explique l'apparition de 10 * * ±308 dans les valeurs flottantes extrêmes.
Calcul en Python:
>>> print len(repr(2**(2**10-1)).rstrip('L'))
308
Python utilise des flotteurs à double précision, qui peuvent contenir des valeurs d'environ 10 à la puissance -308 à 10 à la puissance 308.
Http://en.wikipedia.org/wiki/Double_precision_floating-point_format
Essayez cette expérience à partir de l'invite Python:
>>> 1e308
1e+308
>>> 1e309
inf
10 à la puissance 309 est un débordement, mais 10 à la 38 ne l'est pas. QED.
En fait, vous pouvez probablement obtenir des nombres inférieurs à 1e-308 via denormals, mais il y a un impact significatif sur les performances. Je trouvé que Python est capable de gérer 1e-324
mais sous-flux sur 1e-325
et renvoie {[3] } comme valeur.
Juste en train de jouer; voici une méthode algorithmique pour trouver le flottant positif minimum et maximum, espérons-le dans toute implémentation python où float("+inf")
est acceptable:
def find_float_limits():
"""Return a tuple of min, max positive numbers
representable by the platform's float"""
# first, make sure a float's a float
if 1.0/10*10 == 10.0:
raise RuntimeError("Your platform's floats aren't")
minimum= maximum= 1.0
infinity= float("+inf")
# first find minimum
last_minimum= 2*minimum
while last_minimum > minimum > 0:
last_minimum= minimum
minimum*= 0.5
# now find maximum
operands= []
while maximum < infinity:
operands.append(maximum)
try:
maximum*= 2
except OverflowError:
break
last_maximum= maximum= 0
while operands and maximum < infinity:
last_maximum= maximum
maximum+= operands.pop()
return last_minimum, last_maximum
if __name__ == "__main__":
print (find_float_limits()) # python 2 and 3 friendly
Dans mon cas,
$ python so1835787.py
(4.9406564584124654e-324, 1.7976931348623157e+308)
Donc les dénormaux sont utilisés.