¿Cuál es el rango de valores que un float puede tener en Python?

Question

¿Cuáles son sus valores más pequeños y más grandes en python?

Answer 1

Ver esto post.

partes pertinentes del mensaje:

 
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 usa flotadores de doble precisión, que pueden contener valores de aproximadamente 10 a la -308 a 10 a la potencia 308.

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

probar este experimento desde el indicador de Python:

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

10 a la potencia 309 es un desbordamiento, pero 10 a la 38 no lo es. QED.

En realidad, probablemente pueda obtener números menores que 1e-308 a través de denormals, pero esto tiene un impacto significativo en el rendimiento. Descubrí que Python puede manejar 1e-324 pero se desborda en 1e-325 y devuelve 0.0 como valor.

Answer 3

Como una especie de complemento teórico de las respuestas anteriores, me gustaría mencionar que el valor "mágico" ± 308 proviene directamente de la representación binaria de flotadores. Double precision floats son de la forma ± c * 2 ** q con un "pequeño" valor fraccionario c (~ 1), yq un entero escrito con 11 dígitos binarios (incluyendo 1 bit para su signo). El hecho de que 2 ** (2 ** 10-1) tenga 308 (decimales) dígitos explica la aparición de 10 ** ± 308 en los valores float extremos.

Cálculo en Python:

>>> print len(repr(2**(2**10-1)).rstrip('L')) 
308 

Answer 4

simplemente jugando; He aquí un método algorítmico para encontrar el mínimo y el máximo de flotación positiva, es de esperar en cualquier aplicación donde pitón float("+inf") es aceptable:

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 

En mi caso,

$ python so1835787.py 
(4.9406564584124654e-324, 1.7976931348623157e+308) 

lo que se utilizan denormals.

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) 

El más pequeño es sys.float_info.min (2.2250738585072014e-308) y el más grande es sys.float_info.max (1.7976931348623157e + 308). Ver documentation para otras propiedades.

Actualización: generalmente puede obtener un mínimo de desnormalización como sys.float_info.min*sys.float_info.epsilon. Pero tenga en cuenta que tales números se representan con una pérdida de precisión.