Cómo redondear un número a cifras significativas en Python

Necesito redondear un flotador para que se muestre en una interfaz de usuario. Por ejemplo, a una cifra significativa:

1234 -> 1000

0.12 -> 0.1

0.012 -> 0.01

0,062 -> 0,06

6253 -> 6000

1999 -> 2000

¿Hay una buena manera de hacer esto usando la biblioteca Python, o tengo que escribirlo yo mismo?

Puede usar números negativos para redondear enteros:

>>> round(1234, -3)
1000.0

Por lo tanto, si solo necesita el dígito más significativo:

>>> from math import log10, floor
>>> def round_to_1(x):
...   return round(x, -int(floor(log10(abs(x)))))
... 
>>> round_to_1(0.0232)
0.02
>>> round_to_1(1234243)
1000000.0
>>> round_to_1(13)
10.0
>>> round_to_1(4)
4.0
>>> round_to_1(19)
20.0

Probablemente tenga que encargarse de convertir el flotador en entero si es mayor que 1.

% g en el formato de cadena formateará un flotante redondeado a un número de cifras significativas. A veces usará la notación científica 'e', ​​por lo tanto, vuelva a convertir la cadena redondeada en flotante mediante el formato de cadena% s.

>>> '%s' % float('%.1g' % 1234)
'1000'
>>> '%s' % float('%.1g' % 0.12)
'0.1'
>>> '%s' % float('%.1g' % 0.012)
'0.01'
>>> '%s' % float('%.1g' % 0.062)
'0.06'
>>> '%s' % float('%.1g' % 6253)
'6000.0'
>>> '%s' % float('%.1g' % 1999)
'2000.0'

Si desea tener otro decimal distinto de 1 (de lo contrario, lo mismo que Evgeny):

>>> from math import log10, floor
>>> def round_sig(x, sig=2):
...   return round(x, sig-int(floor(log10(abs(x))))-1)
... 
>>> round_sig(0.0232)
0.023
>>> round_sig(0.0232, 1)
0.02
>>> round_sig(1234243, 3)
1230000.0

f'{float(f"{i:.1g}"):g}'
# Or with Python <3.6,
'{:g}'.format(float('{:.1g}'.format(i)))

Esta solución es diferente de todas las demás porque:

1. es exactamente resuelve la cuestión OP
2. sí no necesita ningún paquete adicional
3. sí no necesita ningún definida por el usuario función auxiliar o operación matemática

Para un número arbitrario nde cifras significativas, puede usar:

print('{:g}'.format(float('{:.{p}g}'.format(i, p=n))))

Prueba:

a = [1234, 0.12, 0.012, 0.062, 6253, 1999, -3.14, 0., -48.01, 0.75]
b = ['{:g}'.format(float('{:.1g}'.format(i))) for i in a]
# b == ['1000', '0.1', '0.01', '0.06', '6000', '2000', '-3', '0', '-50', '0.8']

Nota : con esta solución, no es posible adaptar el número de cifras significativas dinámicamente desde la entrada porque no hay una forma estándar de distinguir números con diferentes números de ceros finales ( 3.14 == 3.1400). Si necesita hacerlo, entonces se necesitan funciones no estándar como las proporcionadas en el paquete de precisión .

He creado el paquete con precisión que hace lo que quieres. Le permite dar a sus números cifras más o menos significativas.

También genera notación estándar, científica y de ingeniería con un número específico de cifras significativas.

En la respuesta aceptada está la línea.

>>> round_to_1(1234243)
1000000.0

Eso realmente especifica 8 higos sig. Para el número 1234243, mi biblioteca solo muestra una cifra significativa:

>>> from to_precision import to_precision
>>> to_precision(1234243, 1, 'std')
'1000000'
>>> to_precision(1234243, 1, 'sci')
'1e6'
>>> to_precision(1234243, 1, 'eng')
'1e6'

También redondeará la última cifra significativa y puede elegir automáticamente qué notación usar si no se especifica una notación:

>>> to_precision(599, 2)
'600'
>>> to_precision(1164, 2)
'1.2e3'

Para redondear un número entero a 1 cifra significativa, la idea básica es convertirlo a un punto flotante con 1 dígito antes del punto y redondearlo, luego convertirlo nuevamente a su tamaño entero original.

Para hacer esto, necesitamos saber la potencia más grande de 10 menos que el número entero. Podemos usar el piso de la función log 10 para esto.

from math import log10, floor
def round_int(i,places):
    if i == 0:
        return 0
    isign = i/abs(i)
    i = abs(i)
    if i < 1:
        return 0
    max10exp = floor(log10(i))
    if max10exp+1 < places:
        return i
    sig10pow = 10**(max10exp-places+1)
    floated = i*1.0/sig10pow
    defloated = round(floated)*sig10pow
    return int(defloated*isign)

Para responder directamente a la pregunta, aquí está mi versión usando nombres de la función R :

import math

def signif(x, digits=6):
    if x == 0 or not math.isfinite(x):
        return x
    digits -= math.ceil(math.log10(abs(x)))
    return round(x, digits)

Mi razón principal para publicar esta respuesta son los comentarios quejándose de que "0.075" se redondea a 0.07 en lugar de 0.08. Esto se debe, como lo señaló "Novato C", a una combinación de aritmética de coma flotante que tiene precisión finita y una representación de base 2 . El número más cercano a 0.075 que puede representarse realmente es un poco más pequeño, por lo tanto, el redondeo sale de manera diferente de lo que cabría esperar ingenuamente.

También tenga en cuenta que esto se aplica a cualquier uso de aritmética de coma flotante no decimal, por ejemplo, C y Java tienen el mismo problema.

Para mostrar con más detalle, le pedimos a Python que formatee el número en formato "hexadecimal":

0.075.hex()

lo que nos da: 0x1.3333333333333p-4. La razón para hacer esto es que la representación decimal normal a menudo implica redondeo y, por lo tanto, no es cómo la computadora realmente "ve" el número. Si no está acostumbrado a este formato, un par de referencias útiles son las documentación de Python y el C estándar .

Para mostrar cómo funcionan un poco estos números, podemos volver a nuestro punto de partida haciendo lo siguiente:

0x13333333333333 / 16**13 * 2**-4

que debería imprimirse 0.075. 16**13es porque hay 13 dígitos hexadecimales después del punto decimal, y 2**-4es porque los exponentes hexadecimales son base-2.

Ahora tenemos una idea de cómo se representan los flotadores, podemos usar el decimalmódulo para darnos más precisión, mostrándonos lo que está sucediendo:

from decimal import Decimal

Decimal(0x13333333333333) / 16**13 / 2**4

dando: 0.07499999999999999722444243844y con suerte explicando por qué round(0.075, 2)evalúa a0.07

def round_to_n(x, n):
    if not x: return 0
    power = -int(math.floor(math.log10(abs(x)))) + (n - 1)
    factor = (10 ** power)
    return round(x * factor) / factor

round_to_n(0.075, 1)      # 0.08
round_to_n(0, 1)          # 0
round_to_n(-1e15 - 1, 16) # 1000000000000001.0

Con suerte, tomando la mejor de todas las respuestas anteriores (menos poder ponerlo como una lambda de una línea;)). Todavía no lo he explorado, siéntase libre de editar esta respuesta:

round_to_n(1e15 + 1, 11)  # 999999999999999.9

Modifiqué la solución de indgar para manejar números negativos y números pequeños (incluido cero).

from math import log10, floor
def round_sig(x, sig=6, small_value=1.0e-9):
    return round(x, sig - int(floor(log10(max(abs(x), abs(small_value))))) - 1)

Si desea redondear sin involucrar cadenas, el enlace que encontré enterrado en los comentarios anteriores:

http://code.activestate.com/lists/python-tutor/70739/

me parece lo mejor. Luego, cuando imprime con cualquier descriptor de formato de cadena, obtiene un resultado razonable y puede usar la representación numérica para otros fines de cálculo.

El código en el enlace tiene tres líneas: def, doc y return. Tiene un error: debe verificar la existencia de logaritmos explosivos. Eso es fácil. Compare la entrada a sys.float_info.min. La solución completa es:

import sys,math

def tidy(x, n):
"""Return 'x' rounded to 'n' significant digits."""
y=abs(x)
if y <= sys.float_info.min: return 0.0
return round( x, int( n-math.ceil(math.log10(y)) ) )

Funciona para cualquier valor numérico escalar, y n puede ser un floatsi necesita cambiar la respuesta por alguna razón. En realidad, puede empujar el límite para:

sys.float_info.min*sys.float_info.epsilon

sin provocar un error, si por alguna razón está trabajando con valores minúsculos.

No puedo pensar en nada que pueda manejar esto fuera de la caja. Pero está bastante bien manejado para números de coma flotante.

>>> round(1.2322, 2)
1.23

Los enteros son más complicados. No se almacenan como base 10 en la memoria, por lo que los lugares importantes no son algo natural. Sin embargo, es bastante trivial implementar una vez que son una cadena.

O para enteros:

>>> def intround(n, sigfigs):
...   n = str(n)
...   return n[:sigfigs] + ('0' * (len(n)-(sigfigs)))

>>> intround(1234, 1)
'1000'
>>> intround(1234, 2)

Si desea crear una función que maneje cualquier número, mi preferencia sería convertirlos en cadenas y buscar un lugar decimal para decidir qué hacer:

>>> def roundall1(n, sigfigs):
...   n = str(n)
...   try:
...     sigfigs = n.index('.')
...   except ValueError:
...     pass
...   return intround(n, sigfigs)

Otra opción es verificar el tipo. Esto será mucho menos flexible y probablemente no jugará bien con otros números como los Decimalobjetos:

>>> def roundall2(n, sigfigs):
...   if type(n) is int: return intround(n, sigfigs)
...   else: return round(n, sigfigs)

La respuesta publicada fue la mejor disponible cuando se dio, pero tiene una serie de limitaciones y no produce cifras significativas técnicamente correctas.

numpy.format_float_positional admite el comportamiento deseado directamente. El siguiente fragmento devuelve el flotador xformateado a 4 cifras significativas, con la notación científica suprimida.

import numpy as np
x=12345.6
np.format_float_positional(x, precision=4, unique=False, fractional=False, trim='k')
> 12340.

Me encontré con esto también, pero necesitaba control sobre el tipo de redondeo. Por lo tanto, escribí una función rápida (vea el código a continuación) que puede tener en cuenta el valor, el tipo de redondeo y los dígitos significativos deseados.

import decimal
from math import log10, floor

def myrounding(value , roundstyle='ROUND_HALF_UP',sig = 3):
    roundstyles = [ 'ROUND_05UP','ROUND_DOWN','ROUND_HALF_DOWN','ROUND_HALF_UP','ROUND_CEILING','ROUND_FLOOR','ROUND_HALF_EVEN','ROUND_UP']

    power =  -1 * floor(log10(abs(value)))
    value = '{0:f}'.format(value) #format value to string to prevent float conversion issues
    divided = Decimal(value) * (Decimal('10.0')**power) 
    roundto = Decimal('10.0')**(-sig+1)
    if roundstyle not in roundstyles:
        print('roundstyle must be in list:', roundstyles) ## Could thrown an exception here if you want.
    return_val = decimal.Decimal(divided).quantize(roundto,rounding=roundstyle)*(decimal.Decimal(10.0)**-power)
    nozero = ('{0:f}'.format(return_val)).rstrip('0').rstrip('.') # strips out trailing 0 and .
    return decimal.Decimal(nozero)


for x in list(map(float, '-1.234 1.2345 0.03 -90.25 90.34543 9123.3 111'.split())):
    print (x, 'rounded UP: ',myrounding(x,'ROUND_UP',3))
    print (x, 'rounded normal: ',myrounding(x,sig=3))

Usando el formato de estilo nuevo de Python 2.6+ (ya que el estilo% está en desuso):

>>> "{0}".format(float("{0:.1g}".format(1216)))
'1000.0'
>>> "{0}".format(float("{0:.1g}".format(0.00356)))
'0.004'

En python 2.7+ puedes omitir los 0s principales .

Esta función realiza una ronda normal si el número es mayor que 10 ** (- decimales_posiciones), de lo contrario agrega más decimales hasta que se alcanza el número de posiciones decimales significativas:

def smart_round(x, decimal_positions):
    dp = - int(math.log10(abs(x))) if x != 0.0 else int(0)
    return round(float(x), decimal_positions + dp if dp > 0 else decimal_positions)

Espero eso ayude.

https://stackoverflow.com/users/1391441/gabriel , ¿aborda lo siguiente su preocupación sobre rnd (.075, 1)? Advertencia: devuelve el valor como flotante

def round_to_n(x, n):
    fmt = '{:1.' + str(n) + 'e}'    # gives 1.n figures
    p = fmt.format(x).split('e')    # get mantissa and exponent
                                    # round "extra" figure off mantissa
    p[0] = str(round(float(p[0]) * 10**(n-1)) / 10**(n-1))
    return float(p[0] + 'e' + p[1]) # convert str to float

>>> round_to_n(750, 2)
750.0
>>> round_to_n(750, 1)
800.0
>>> round_to_n(.0750, 2)
0.075
>>> round_to_n(.0750, 1)
0.08
>>> math.pi
3.141592653589793
>>> round_to_n(math.pi, 7)
3.141593

Esto devuelve una cadena, de modo que los resultados sin partes fraccionarias, y los valores pequeños que de otro modo aparecerían en la notación E se muestran correctamente:

def sigfig(x, num_sigfig):
    num_decplace = num_sigfig - int(math.floor(math.log10(abs(x)))) - 1
    return '%.*f' % (num_decplace, round(x, num_decplace))

Ante una pregunta tan bien respondida, ¿por qué no agregar otra?

Esto se adapta un poco mejor a mi estética, aunque muchos de los anteriores son comparables

import numpy as np

number=-456.789
significantFigures=4

roundingFactor=significantFigures - int(np.floor(np.log10(np.abs(number)))) - 1
rounded=np.round(number, roundingFactor)

string=rounded.astype(str)

print(string)

Esto funciona para números individuales y matrices numpy, y debería funcionar bien para números negativos.

Hay un paso adicional que podríamos agregar: np.round () devuelve un número decimal incluso si redondeado es un entero (es decir, para cifras significativas = 2 podríamos esperar obtener -460, pero en su lugar obtenemos -460.0). Podemos agregar este paso para corregir eso:

if roundingFactor<=0:
    rounded=rounded.astype(int)

Desafortunadamente, este paso final no funcionará para una variedad de números; se lo dejaré a usted, querido lector, para que lo descubra si lo necesita.

El paquete / biblioteca sigfig cubre esto. Después de la instalación , puede hacer lo siguiente:

>>> from sigfig import round
>>> round(1234, 1)
1000
>>> round(0.12, 1)
0.1
>>> round(0.012, 1)
0.01
>>> round(0.062, 1)
0.06
>>> round(6253, 1)
6000
>>> round(1999, 1)
2000

import math

  def sig_dig(x, n_sig_dig):
      num_of_digits = len(str(x).replace(".", ""))
      if n_sig_dig >= num_of_digits:
          return x
      n = math.floor(math.log10(x) + 1 - n_sig_dig)
      result = round(10 ** -n * x) * 10 ** n
      return float(str(result)[: n_sig_dig + 1])


    >>> sig_dig(1234243, 3)
    >>> sig_dig(243.3576, 5)

        1230.0
        243.36