Quelle est la plage de valeurs qu'un flotteur peut avoir en Python?

Question

Quelles sont ses plus petites et plus grandes valeurs en python?

Answer 1

Voir ceci post.

parties pertinentes du message:

 
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 

Answer 2

Python utilise des flotteurs double précision, qui peut contenir des valeurs allant d'environ 10 à -308 à 10 308 à la puissance.

http://en.wikipedia.org/wiki/Double_precision_floating-point_format

Essayez cette expérience de l'invite Python:

>>> 1e308 
1e+308 
>>> 1e309 
inf 

10 à la puissance 309 est un trop-plein, mais 10 à 38 n'est pas. QED.

En fait, vous pouvez probablement obtenir un plus petit nombre de 1E-308 par l'intermédiaire denormals, mais il y a un coup de performance significatif à cet égard. J'ai trouvé que Python est capable de gérer 1e-324 mais déborde sur 1e-325 et retourne 0.0 comme valeur.

Answer 3

Comme une sorte de complément théorique aux réponses précédentes, je voudrais mentionner que la valeur "magique" ± 308 provient directement de la représentation binaire des flotteurs. Double precision floats sont de la forme ± c * 2 ** q avec une "petite" valeur fractionnaire c (~ 1), et q un entier écrit avec 11 chiffres binaires (y compris 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 

Answer 4

juste à jouer; voici une méthode algorithmique pour trouver le flottant positif minimum et maximum, je l'espère dans une implémentation de 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) 

si dénormalisés sont utilisés.

Answer 5

>>> 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.2250738585072014e-308) et le plus grand est sys.float_info.max (1.7976931348623157e + 308). Voir documentation pour d'autres propriétés.

Mise à jour: vous pouvez généralement obtenir une dénormalisation minimale de sys.float_info.min*sys.float_info.epsilon. Mais notez que ces chiffres sont représentés avec une perte de précision.