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

Preciso arredondar um flutuador para ser exibido em uma interface do usuário. Por exemplo, para uma figura significativa:

1234 -> 1000

0,12 -> 0,1

0,012 -> 0,01

0,062 -> 0,06

6253 -> 6000

1999 -> 2000

Existe uma boa maneira de fazer isso usando a biblioteca Python, ou eu mesmo tenho que escrever?

Você pode usar números negativos para arredondar números inteiros:

>>> round(1234, -3)
1000.0

Portanto, se você precisar apenas do dígito mais 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

Você provavelmente terá que cuidar de transformar float em número inteiro se for maior que 1.

% g na formatação de string formatará um float arredondado para um número significativo de números. Às vezes, ele usa a notação científica 'e'; portanto, converta a string arredondada de volta em um float e, em seguida, através da formatação da string% 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 você quiser ter um número decimal diferente de 1 (caso contrário, o mesmo que o 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 solução é diferente de todas as outras porque:

1. -lo exatamente resolve a questão OP
2. ele não precisa de qualquer pacote adicional
3. ele não precisa de nenhuma função auxiliar definida pelo usuário ou operação matemática

Para um número arbitrário nde números significativos, você pode usar:

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 esta solução, não é possível adaptar dinamicamente o número de figuras significativas a partir da entrada, porque não existe uma maneira padrão de distinguir números com diferentes números de zeros à direita ( 3.14 == 3.1400). Se você precisar fazer isso, serão necessárias funções não padrão, como as fornecidas no pacote de precisão .

Eu criei o pacote com precisão que faz o que você deseja. Ele permite que você forneça números mais ou menos significativos.

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

Na resposta aceita, há a linha

>>> round_to_1(1234243)
1000000.0

Na verdade, isso especifica 8 sig figs. Para o número 1234243, minha biblioteca exibe apenas 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'

Ele também arredondará o último número significativo e poderá escolher automaticamente qual notação usar se uma notação não for especificada:

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

Para arredondar um número inteiro para 1 figura significativa, a idéia básica é convertê-lo em um ponto flutuante com 1 dígito antes do ponto e arredondá-lo e depois convertê-lo novamente em seu tamanho inteiro original.

Para fazer isso, precisamos conhecer a maior potência de 10 a menos que o número inteiro. Podemos usar o piso da função log 10 para isso.

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 diretamente à pergunta, aqui está minha versão usando a nomeação da função 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)

Meu principal motivo para postar esta resposta são os comentários reclamando que "0,075" arredonda para 0,07 em vez de 0,08. Isso se deve, como apontado por "Iniciante C", a uma combinação de aritmética de ponto flutuante com precisão finita e uma representação de base 2 . O número mais próximo a 0,075 que pode realmente ser representado é um pouco menor; portanto, o arredondamento sai de maneira diferente do que você pode esperar ingenuamente.

Observe também que isso se aplica a qualquer uso de aritmética de ponto flutuante não decimal, por exemplo, C e Java têm o mesmo problema.

Para mostrar com mais detalhes, pedimos ao Python que formate o número no formato "hexadecimal":

0.075.hex()

o que nos dá: 0x1.3333333333333p-4. A razão para fazer isso é que a representação decimal normal geralmente envolve arredondamentos e, portanto, não é como o computador "vê" o número. Se você não está acostumado a este formato, um par de referências úteis são os docs Python eo padrão C .

Para mostrar como esses números funcionam um pouco, podemos voltar ao nosso ponto de partida fazendo:

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

que deve ser impresso 0.075. 16**13é porque existem 13 dígitos hexadecimais após o ponto decimal e 2**-4porque os expoentes hexadecimais são base-2.

Agora, temos uma idéia de como os carros alegóricos são representados. Podemos usar o decimalmódulo para fornecer mais precisão, mostrando o que está acontecendo:

from decimal import Decimal

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

dando: 0.07499999999999999722444243844e esperançosamente explicando por que round(0.075, 2)avalia0.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

Espero ter o melhor de todas as respostas acima (menos poder colocá-lo como uma linha lambda;)). Ainda não explorou, sinta-se à vontade para editar esta resposta:

round_to_n(1e15 + 1, 11)  # 999999999999999.9

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

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)

Se você deseja arredondar sem envolver cordas, o link que encontrei enterrado nos comentários acima:

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

me parece melhor. Então, quando você imprime com qualquer descritor de formatação de sequência, obtém uma saída razoável e pode usar a representação numérica para outros fins de cálculo.

O código no link é de três linhas: def, doc e return. Ele tem um bug: você precisa verificar se há logaritmos explosivos. Isso é fácil. Compare a entrada com sys.float_info.min. A solução completa é:

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

Ele funciona para qualquer valor numérico escalar e n pode ser um floatse você precisar alterar a resposta por algum motivo. Você pode realmente empurrar o limite para:

sys.float_info.min*sys.float_info.epsilon

sem provocar um erro, se por algum motivo você estiver trabalhando com valores minúsculos.

Não consigo pensar em nada que possa resolver isso imediatamente. Mas é razoavelmente bem tratado para números de ponto flutuante.

>>> round(1.2322, 2)
1.23

Inteiros são mais complicados. Eles não são armazenados como base 10 na memória, portanto lugares significativos não são uma coisa natural a se fazer. É bastante trivial de implementar uma vez que eles são uma string.

Ou para números inteiros:

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

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

Se você deseja criar uma função que lida com qualquer número, minha preferência seria convertê-los em 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. Isso será muito menos flexível e provavelmente não funcionará bem com outros números, como Decimalobjetos:

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

A resposta postada foi a melhor disponível quando fornecida, mas possui várias limitações e não produz números significativos tecnicamente corretos.

numpy.format_float_positional suporta diretamente o comportamento desejado. O fragmento a seguir retorna o float xformatado para 4 números significativos, com a notação científica suprimida.

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

Encontrei isso também, mas precisava de controle sobre o tipo de arredondamento. Assim, escrevi uma função rápida (veja o código abaixo) que pode levar em consideração o valor, o tipo de arredondamento e os dígitos significativos desejados.

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 a formatação de novo estilo do python 2.6+ (como% -style está obsoleto):

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

No python 2.7+, você pode omitir os 0s principais .

Esta função executa uma rodada normal se o número for maior que 10 ** (- posições_ decimais); caso contrário, adiciona mais casas decimais até que o número de casas 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)

Espero que ajude.

https://stackoverflow.com/users/1391441/gabriel , o seguinte endereço aborda sua preocupação com rnd (0,075, 1)? Advertência: retorna valor como um float

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

Isso retorna uma string, para que resultados sem partes fracionárias e pequenos valores que, de outra forma, aparecessem na notação E sejam mostrados corretamente:

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

Dada uma pergunta tão bem respondida, por que não adicionar outra

Isso combina com minha estética um pouco melhor, embora muitos dos itens acima sejam comparáveis

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)

Isso funciona para números individuais e matrizes numpy e deve funcionar bem para números negativos.

Há uma etapa adicional que poderíamos adicionar - np.round () retorna um número decimal, mesmo que arredondado seja um número inteiro (por exemplo, para significantFigures = 2, podemos esperar voltar -460, mas obtemos -460,0). Podemos adicionar esta etapa para corrigir isso:

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

Infelizmente, esta etapa final não funcionará para uma série de números - deixarei isso para você, querido leitor, para descobrir se você precisa.

O pacote / biblioteca sigfig cobre isso. Após a instalação, você pode fazer o seguinte:

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