Como arredondar um número para números significativos em Python

%g na formatação de texto irá formatar um flutuador arredondado para um número de figuras significativas. Ele às vezes vai usar notação científica 'e', então converter a cadeia arredondada de volta para um float, em seguida, através de formatação de cadeia de %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'

Se quiser ter outra casa decimal significativa (caso contrário, a mesma 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

Para arredondar um inteiro para 1 figura significativa a ideia básica é convertê-lo para um ponto flutuante com 1 dígito antes do ponto e arredondá-lo, em seguida, convertê-lo de volta para o seu tamanho inteiro original.

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)

Modifiquei a solução do indgar para lidar com números negativos e números pequenos (incluindo zero).

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)

print('{:g}'.format(float('{:.1g}'.format(12.345))))

Esta solução é diferente de todas as outras porque:

1. Issoexactamente resolve a questão OP
2. não é necessário nenhum pacote extra
3. não necessita de nenhuma função auxiliar definida pelo utilizador ou operação matemática

Para um número arbitrário n de números significativos, pode utilizar:

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

Teste:

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 com isto solução, não é possível adaptar dinamicamente o número de figuras significativas da entrada porque não existe uma maneira padrão de distinguir números com diferentes números de zeros finais (3.14 == 3.1400). Se você precisar fazer isso, então funções não-padrão como as fornecidas no Pacote to-precision são necessárias.

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

round_to_n(1e15 + 1, 11)  # 999999999999999.9

Eu criei o pacote to-precision que faz o que você quer. Ele permite que você dê seus números mais ou menos significativos.

Também produz notação padrão, científica e de engenharia com um número especificado de números significativos.

Na resposta aceite há a linha

>>> round_to_1(1234243)
1000000.0

Que especifica de facto 8 figos sig. Para o número 1234243, A Minha Biblioteca apenas apresenta uma figura 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'

Também rodeará o última figura significativa e pode escolher automaticamente que Notação usar se uma notação não for especificada:

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

>>> round(1.2322, 2)
1.23

Ou para inteiros:

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

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

Se você gostaria de criar uma função que lida com qualquer número, minha preferência seria convertê - los ambos para strings e procurar uma casa decimal para decidir o que fazer:

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

Outra opção é verificar o tipo. Isto será muito menos flexível, e provavelmente não jogará bem com outros números como Decimal objectos:

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

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))

Se queres andar por aí sem envolver cordas, o link que encontrei enterrado nos comentários acima:

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

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 qualquer valor numérico escalar, e n pode ser um float Se precisar de mudar a resposta por alguma razão. Você pode realmente empurrar o limite para:

sys.float_info.min*sys.float_info.epsilon

Sem provocar um erro, se por alguma razão estiver a trabalhar com valores minúsculos.

Esta função faz uma ronda normal se o número for maior que 10 * * (- decimal_posições), caso contrário adiciona mais casas decimais até que o número de posições decimais significativas seja atingido:

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)