Jak zaokrąglić liczbę do cyfr znaczących w Pythonie

Muszę zaokrąglić liczbę zmiennoprzecinkową, aby była wyświetlana w interfejsie użytkownika. Np. Do jednej znaczącej liczby:

1234 -> 1000

0,12 -> 0,1

0,012 -> 0,01

0,062 -> 0,06

6253 -> 6000

1999 -> 2000

Czy istnieje dobry sposób na zrobienie tego za pomocą biblioteki Python, czy też muszę sam to napisać?

Możesz użyć liczb ujemnych do zaokrąglenia liczb całkowitych:

>>> round(1234, -3)
1000.0

Zatem jeśli potrzebujesz tylko najbardziej znaczącej cyfry:

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

Prawdopodobnie będziesz musiał zadbać o zmianę liczby zmiennoprzecinkowej na liczbę całkowitą, jeśli jest większa niż 1.

% g w formatowaniu łańcucha sformatuje liczbę zmiennoprzecinkową zaokrągloną do pewnej liczby cyfr znaczących. Czasami używa notacji naukowej 'e', ​​więc przekonwertuj zaokrąglony ciąg z powrotem na zmiennoprzecinkowy, a następnie przez formatowanie ciągu% 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'

Jeśli chcesz mieć inne niż 1 znaczące miejsce po przecinku (w przeciwnym razie to samo co 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)))

To rozwiązanie różni się od wszystkich innych, ponieważ:

1. to dokładnie rozwiązuje kwestię OP
2. to jednak nie potrzeba żadnego dodatkowego pakietu
3. to jednak nie potrzeba żadnego zdefiniowanego przez użytkownika funkcję pomocniczą lub operacji matematycznych

W przypadku dowolnej liczby ncyfr znaczących możesz użyć:

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

Test:

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

Uwaga : w przypadku tego rozwiązania nie jest możliwe dynamiczne dostosowywanie liczby cyfr znaczących na podstawie danych wejściowych, ponieważ nie ma standardowego sposobu rozróżniania liczb z różnymi liczbami końcowych zer ( 3.14 == 3.1400). Jeśli zajdzie taka potrzeba, potrzebne są niestandardowe funkcje, takie jak te zawarte w pakiecie do precyzji .

Stworzyłem precyzyjny pakiet, który robi to, co chcesz. Pozwala na podanie liczb mniej lub bardziej znaczących.

Wyprowadza również notację standardową, naukową i inżynierską z określoną liczbą cyfr znaczących.

W zaakceptowanej odpowiedzi jest linia

>>> round_to_1(1234243)
1000000.0

To faktycznie określa 8 sig fig. Dla numeru 1234243 moja biblioteka wyświetla tylko jedną znaczącą cyfrę:

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

Zaokrągli również ostatnią znaczącą cyfrę i może automatycznie wybrać, jakiego zapisu użyć, jeśli notacja nie jest określona:

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

Aby zaokrąglić liczbę całkowitą do 1 cyfry znaczącej, podstawową ideą jest przekonwertowanie jej na liczbę zmiennoprzecinkową z 1 cyfrą przed kropką i zaokrąglić ją, a następnie przekonwertować ją z powrotem do pierwotnej wielkości całkowitej.

Aby to zrobić, musimy znać największą potęgę 10 mniejszą od liczby całkowitej. Możemy do tego użyć floor funkcji log 10.

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)

Aby bezpośrednio odpowiedzieć na pytanie, oto moja wersja używająca nazewnictwa z funkcji 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)

Moim głównym powodem opublikowania tej odpowiedzi są komentarze narzekające, że „0,075” zaokrągla do 0,07 zamiast 0,08. Wynika to, jak wskazał „Nowicjusz C”, z połączenia arytmetyki zmiennoprzecinkowej mającej zarówno skończoną precyzję, jak i reprezentację o podstawie 2 . Liczba najbliższa 0,075, którą można w rzeczywistości przedstawić, jest nieco mniejsza, dlatego zaokrąglanie wygląda inaczej, niż można by się naiwnie spodziewać.

Należy również zauważyć, że dotyczy to wszelkich zastosowań arytmetyki zmiennoprzecinkowej innej niż dziesiętna, np. C i Java mają ten sam problem.

Aby pokazać bardziej szczegółowo, prosimy Pythona o sformatowanie liczby w formacie „szesnastkowym”:

0.075.hex()

co daje nam: 0x1.3333333333333p-4. Powodem takiego postępowania jest to, że normalna reprezentacja dziesiętna często obejmuje zaokrąglanie, a zatem nie jest to sposób, w jaki komputer faktycznie „widzi” liczbę. Jeśli nie jesteś przyzwyczajony do tego formatu, kilka przydatnych odnośników są docs Python i standard C .

Aby pokazać, jak działają te liczby, możemy wrócić do punktu wyjścia, wykonując:

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

który powinien zostać wydrukowany 0.075. 16**13Dzieje się tak, ponieważ po przecinku znajduje się 13 cyfr szesnastkowych, a 2**-4wykładniki szesnastkowe mają podstawę 2.

Teraz mamy już pewne wyobrażenie o tym, jak reprezentowane są zmiennoprzecinkowe, możemy użyć decimalmodułu, aby zwiększyć precyzję, pokazując nam, co się dzieje:

from decimal import Decimal

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

dawanie: 0.07499999999999999722444243844i miejmy nadzieję, że wyjaśnia, dlaczego round(0.075, 2)ocenia0.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

Miejmy nadzieję, że biorąc pod uwagę wszystkie powyższe odpowiedzi (bez możliwości ujęcia tego jako jednowierszowej lambda;)). Jeszcze nie eksplorowałem, możesz edytować tę odpowiedź:

round_to_n(1e15 + 1, 11)  # 999999999999999.9

Zmodyfikowałem rozwiązanie indgar, aby obsługiwać liczby ujemne i małe liczby (w tym 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)

Jeśli chcesz zaokrąglić bez angażowania ciągów, link, który znalazłem ukryty w komentarzach powyżej:

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

wydaje mi się najlepsze. Następnie, gdy drukujesz z dowolnymi deskryptorami formatowania łańcuchów, uzyskujesz rozsądny wynik i możesz użyć reprezentacji numerycznej do innych celów obliczeniowych.

Kod pod linkiem składa się z trzech linijek: def, doc i return. Ma błąd: musisz sprawdzić eksplodujące logarytmy. Tołatwe. Porównaj dane wejściowe z sys.float_info.min. Kompletne rozwiązanie to:

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

Działa dla dowolnej skalarnej wartości liczbowej, a n może być a, floatjeśli z jakiegoś powodu musisz zmienić odpowiedź. W rzeczywistości możesz przesunąć limit, aby:

sys.float_info.min*sys.float_info.epsilon

bez wywoływania błędu, jeśli z jakiegoś powodu pracujesz z małymi wartościami.

Nie przychodzi mi do głowy nic, co byłoby w stanie sobie z tym poradzić po wyjęciu z pudełka. Ale jest dość dobrze obsługiwany w przypadku liczb zmiennoprzecinkowych.

>>> round(1.2322, 2)
1.23

Liczby całkowite są trudniejsze. Nie są przechowywane jako podstawa 10 w pamięci, więc ważne miejsca nie są rzeczą naturalną. Jednak implementacja, gdy są one ciągiem, jest dość trywialna.

Lub dla liczb całkowitych:

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

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

Jeśli chcesz utworzyć funkcję obsługującą dowolną liczbę, wolałbym przekonwertować je na ciągi znaków i poszukać miejsca dziesiętnego, aby zdecydować, co zrobić:

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

Inną opcją jest sprawdzenie typu. Będzie to znacznie mniej elastyczne i prawdopodobnie nie będzie dobrze współgrać z innymi liczbami, takimi jak Decimalobiekty:

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

Opublikowana odpowiedź była najlepszą dostępną odpowiedzią, gdy została udzielona, ​​ale ma szereg ograniczeń i nie daje technicznie poprawnych liczb znaczących.

numpy.format_float_positional bezpośrednio obsługuje żądane zachowanie. Poniższy fragment zwraca xliczbę zmiennoprzecinkową sformatowaną do 4 cyfr znaczących z pominięciem notacji naukowej.

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

Wpadłem na to również, ale potrzebowałem kontroli nad typem zaokrąglania. Dlatego napisałem szybką funkcję (patrz kod poniżej), która może brać pod uwagę wartość, typ zaokrąglenia i pożądane cyfry znaczące.

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

Korzystanie z formatowania w nowym stylu pythona 2.6+ (ponieważ styl% jest przestarzały):

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

W Pythonie 2.7+ możesz pominąć wiodące 0s.

Ta funkcja wykonuje normalną rundę, jeśli liczba jest większa niż 10 ** (- decimal_positions), w przeciwnym razie dodaje więcej miejsc dziesiętnych, aż zostanie osiągnięta liczba znaczących miejsc dziesiętnych:

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)

Mam nadzieję, że to pomoże.

https://stackoverflow.com/users/1391441/gabriel , czy poniższe informacje dotyczą Twojego problemu dotyczącego rnd (.075, 1)? Caveat: zwraca wartość w postaci liczby zmiennoprzecinkowej

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

Zwraca ciąg, dzięki czemu wyniki bez części ułamkowych, a małe wartości, które w przeciwnym razie pojawiłyby się w notacji E, są wyświetlane poprawnie:

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

Biorąc pod uwagę tak wyczerpującą odpowiedź, dlaczego nie dodać kolejnego

To trochę lepiej pasuje do mojej estetyki, chociaż wiele z powyższych jest porównywalnych

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)

Działa to dla pojedynczych liczb i tablic numpy i powinno działać dobrze dla liczb ujemnych.

Jest jeszcze jeden krok, który możemy dodać - np.round () zwraca liczbę dziesiętną, nawet jeśli zaokrąglona jest liczbą całkowitą (tj. Dla importantFigures = 2 możemy spodziewać się powrotu -460, ale zamiast tego otrzymamy -460.0). Możemy dodać ten krok, aby to poprawić:

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

Niestety, ten ostatni krok nie zadziała dla szeregu liczb - zostawię to tobie drogi czytelniku, aby dowiedzieć się, czy potrzebujesz.

Sigfig pakiet / Osłony biblioteczne to. Po zainstalowaniu możesz wykonać następujące czynności:

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