파이썬에서 숫자를 유의한 숫자로 반올림하는 방법

파이썬에서 숫자를 유의한 숫자로 반올림하는 방법

UI에 표시할 플로트를 반올림해야 합니다. 예를 들어 다음과 같은 중요한 숫자가 표시됩니다.

1234 -> 1000

0.12 -> 0.1

0.012 -> 0.01

0.062 -> 0.06

6253 -> 6000

1999 -> 2000

파이썬 라이브러리를 사용하여 이를 수행하는 좋은 방법이 있습니까, 아니면 제가 직접 작성해야 합니까?

음수를 사용하여 정수를 반올림할 수 있습니다.

>>> round(1234, -3)
1000.0

따라서 가장 유의한 숫자만 필요한 경우:

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

1보다 크면 플로트를 정수로 전환하는 것을 처리해야 할 것입니다.

문자열 형식 지정의 %g은 일부 숫자로 반올림된 플로트 형식을 지정합니다.때때로 'e' 과학적 표기법을 사용하므로 반올림한 문자열을 다시 플로트로 변환한 다음 %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'

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

이 솔루션은 다음과 같은 이유로 다른 모든 솔루션과 다릅니다.

1. 그것은 정확히 OP 질문을 해결합니다.
2. 추가 패키지가 필요하지 않습니다.
3. 사용자 정의 보조 함수 또는 수학적 연산이 필요하지 않습니다.

의 숫자에 n중요한 숫자의 경우 다음을 사용할 수 있습니다.

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

테스트:

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

참고: 이 솔루션을 사용하면 뒤에 오는 0의 수가 다른 숫자를 구별하는 표준 방법이 없기 때문에 중요한 숫자의 수를 입력에서 동적으로 조정할 수 없습니다(3.14 == 3.1400) 그렇게 해야 할 경우 정밀도가 높은 패키지에 제공되는 것과 같은 비표준 기능이 필요합니다.

유의한 소수점이 1개가 아닌 경우(그렇지 않으면 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

질문에 직접 대답하자면, 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)

제가 이 답변을 올린 주된 이유는 "0.075"가 0.08이 아닌 0.07로 반올림된다는 불만 댓글입니다.이것은 "Novice C"가 지적한 바와 같이 유한 정밀도와 기저-2 표현을 모두 갖는 부동소수점 산술의 조합에 기인합니다.실제로 나타낼 수 있는 0.075에 가장 가까운 숫자는 약간 더 작기 때문에 반올림은 순수하게 예상하는 것과 다르게 나타납니다.

또한 이는 소수가 아닌 부동 소수점 산술의 모든 사용에 적용됩니다. 예를 들어 C와 Java는 모두 동일한 문제를 가지고 있습니다.

자세한 내용을 보여주기 위해 Python에서 숫자를 "hex" 형식으로 포맷하도록 요청합니다.

0.075.hex()

다음과 같은 이점이 있습니다.0x1.3333333333333p-4이렇게 하는 이유는 일반적인 십진수 표현은 종종 반올림을 포함하기 때문에 컴퓨터가 실제로 숫자를 "보는" 방식이 아니기 때문입니다.이 형식에 익숙하지 않은 경우 몇 가지 유용한 참고 자료가 Python 문서와 C 표준입니다.

이러한 수치가 어떻게 작동하는지 보여주기 위해 다음을 수행하여 시작점으로 돌아갈 수 있습니다.

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

을 해주시면 됩니다.0.075.16**13, 소점개 13의진 16수가있 16다니때가 있기 입니다.2**-416이기 입니다.

이제 우리는 플로트가 어떻게 표현되는지에 대해 약간의 아이디어를 가지고 있습니다. 우리는 다음을 사용할 수 있습니다.decimal모듈을 사용하여 자세한 내용을 확인할 수 있습니다.

from decimal import Decimal

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

제공:0.07499999999999999722444243844그리고 바라건대 그 이유를 설명하기를 바랍니다.round(0.075, 2)으로 됩니다.0.07

저는 당신이 원하는 대로 정확하게 패키지를 만들었습니다.그것은 당신이 당신의 숫자들을 어느 정도 중요한 숫자들을 제공할 수 있게 해줍니다.

또한 지정된 수의 유의한 숫자로 표준, 과학 및 엔지니어링 표기법을 출력합니다.

승인된 답변에는 다음과 같은 라인이 있습니다.

>>> round_to_1(1234243)
1000000.0

그것은 실제로 8개의 시그마를 지정합니다.숫자 1234243의 경우 라이브러리에 중요한 숫자가 하나만 표시됩니다.

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

또한 마지막 유의 숫자를 반올림하고 표기법이 지정되지 않은 경우 사용할 표기법을 자동으로 선택할 수 있습니다.

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

게시된 답변은 주어진 경우 가장 잘 이용할 수 있는 답변이었지만, 여러 가지 제한 사항이 있으며 기술적으로 정확한 유의한 수치를 산출하지 못합니다.

numpy.format_module_positional은 원하는 동작을 직접 지원합니다.다음 조각은 플로트를 반환합니다.x4개의 유의한 숫자로 포맷되었으며, 과학적 표기는 억제되었습니다.

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

정수를 1개의 유의한 숫자로 반올림하는 기본 아이디어는 점 앞에 1자리 숫자가 있는 부동 소수점으로 변환하고 반올림한 다음 원래 정수 크기로 다시 변환하는 것입니다.

이를 위해서는 정수보다 10 작은 최대 거듭제곱을 알아야 합니다.우리는 이것을 위해 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)

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

저는 마이너스 숫자와 작은 숫자(0 포함)를 처리하기 위해 인더의 솔루션을 수정했습니다.

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)

문자열을 포함하지 않고 반올림하려면 위의 설명에 숨겨진 링크를 찾습니다.

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

가장 인상적입니다.그런 다음 문자열 형식 설명자를 사용하여 인쇄하면 적절한 출력을 얻을 수 있으며 다른 계산 목적으로 숫자 표현을 사용할 수 있습니다.

링크의 코드는 def, doc, return의 세 가지 라이너입니다.버그가 있습니다. 폭발하는 로그를 확인해야 합니다.그것은 쉽습니다. 내용을 입을비니다합교와 해 보세요.sys.float_info.min전체 솔루션은 다음과 같습니다.

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

값에 하며, 은 임의스숫값칼자대작동며, n은 같수있습다니은을과하다음해의가 될 수 .float어떤 이유로 응답을 변경해야 하는 경우.실제로 다음과 같은 제한을 적용할 수 있습니다.

sys.float_info.min*sys.float_info.epsilon

어떤 이유로 작은 값으로 작업하는 경우 오류를 유발하지 않습니다.

sigfig 패키지/라이브러리에서 이 문제를 다룹니다.설치 후 다음 작업을 수행할 수 있습니다.

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

저는 이 일을 즉시 처리할 수 있는 어떤 것도 생각할 수 없습니다.하지만 부동 소수점 번호에 대해서는 상당히 잘 처리됩니다.

>>> round(1.2322, 2)
1.23

정수가 더 까다롭습니다.메모리에 기본 10으로 저장되지 않기 때문에 중요한 장소는 자연스러운 작업이 아닙니다.그러나 일단 문자열이 되면 구현하는 것은 상당히 사소한 일입니다.

또는 정수의 경우:

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

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

숫자를 처리하는 함수를 만들고 싶다면 두 숫자를 모두 문자열로 변환하고 소수점을 찾아 수행할 작업을 결정하는 것이 좋습니다.

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

다른 옵션은 유형을 확인하는 것입니다.이것은 훨씬 덜 유연할 것이고, 아마도 다음과 같은 다른 숫자들과 잘 어울리지 않을 것입니다.Decimal객체:

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

python 2.6+ 새로운 스타일 포맷 사용(%-style은 더 이상 사용되지 않음):

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

2 python 2.7+를 할 수 .0s의

저는 답 중 하나를 수정했습니다.마음에 들어요.

def sigfiground(number:float, ndigits=3)->float:
    return float(f"{number:.{ndigits}g}")

아직 플로트가 필요할 때 사용합니다(다른 곳에서 포맷을 합니다).

저도 이것에 부딪혔지만 라운딩 타입을 제어해야 했습니다.따라서 값, 반올림 유형, 원하는 유의 자릿수를 고려할 수 있는 빠른 함수(아래 코드 참조)를 작성했습니다.

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

이 함수는 숫자가 10**(-decimal_positions)보다 크면 정규 반올림을 수행하고, 그렇지 않으면 의미 있는 소수점 위치 수에 도달할 때까지 소수점을 더 추가합니다.

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)

도움이 되길 바랍니다.

https://stackoverflow.com/users/1391441/gabriel, 에서 rnd(.075, 1)에 대한 우려를 해결할 수 있습니까?주의: 값을 플로트로 반환합니다.

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

이렇게 하면 부분 부분이 없는 결과와 E 표기법에 표시되는 작은 값이 올바르게 표시되도록 문자열이 반환됩니다.

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

질문에 대한 답변이 너무 철저한데 왜 다른 질문을 추가하지 않습니까?

위의 것들 중 많은 것들이 비슷하지만, 이것은 내 미적 감각에 조금 더 잘 맞습니다.

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)

이것은 개별 숫자와 숫자 배열에 적용되며 음수에 대해서는 정상적으로 작동합니다.

추가할 수 있는 한 가지 추가 단계가 있습니다. -np.round()는 반올림된 정수라도 소수를 반환합니다(즉, 중요한 그림=2의 경우 -460을 반환할 것으로 예상되지만 대신 -460.0을 반환합니다).이 단계를 추가하여 수정할 수 있습니다.

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

불행하게도, 이 마지막 단계는 일련의 숫자에 대해서는 효과가 없을 것입니다. 독자 여러분이 필요한지 알아보실 수 있도록 그것을 맡기겠습니다.

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

대부분의 응답에는 산술, 십진수 및/또는 numpy 가져오기 또는 출력 값이 문자열로 포함됩니다.다음은 큰 숫자와 작은 숫자를 모두 처리하고 플로트를 출력하는 기본 파이썬의 간단한 솔루션입니다.

def sig_fig_round(number, digits=3):
    power = "{:e}".format(number).split('e')[1]
    return round(number, -(int(power) - digits))

표준 10진수 라이브러리를 사용한 단순 변형

from decimal import Decimal

def to_significant_figures(v: float, n_figures: int) -> str:
    d = Decimal(v)
    d = d.quantize(Decimal((0, (), d.adjusted() - n_figures + 1)))
    return str(d.quantize(Decimal(1)) if d == d.to_integral() else d.normalize())

테스트 중

>>> to_significant_figures(1.234567, 3)
'1.23'
>>> to_significant_figures(1234567, 3)
'1230000'
>>> to_significant_figures(1.23, 7)
'1.23'
>>> to_significant_figures(123, 7)
'123'

이 함수는 양수와 음수를 모두 사용하며 적절한 유효 자릿수 반올림을 수행합니다.

from math import floor

def significant_arithmetic_rounding(n, d):
    '''
    This function takes a floating point number and the no. of significant digit d, perform significant digits
    arithmetic rounding and returns the floating point number after rounding
    '''
    if n == 0:
        return 0
    else:
        # Checking whether the no. is negative or positive. If it is negative we will take the absolute value of it and proceed
        neg_flag = 0
        if n < 0:
            neg_flag = 1
            n = abs(n)
        
        n1 = n   
        # Counting the no. of digits to the left of the decimal point in the no.
        ld = 0
        while(n1 >= 1):
            n1 /= 10
            ld += 1
        
        n1 = n
        # Counting the no. of zeros to the right of the decimal point and before the first significant digit in the no.
        z = 0
        if ld == 0:
            while(n1 <= 0.1):
                n1 *= 10
                z += 1
        
        n1 = n
        # No. of digits to be considered after decimal for rounding
        rd = (d - ld) + z
        n1 *= 10**rd
    
        # Increase by 0.5 and take the floor value for rounding
        n1 = floor(n1+0.5)
        # Placing the decimal point at proper position
        n1 /= 10 ** rd
        # If the original number is negative then make it negative
        if neg_flag == 1:
            n1 = 0 - n1

        return n1

테스트:

>>> significant_arithmetic_rounding(1234, 3)
1230.0
>>> significant_arithmetic_rounding(123.4, 3)
123.0
>>> significant_arithmetic_rounding(0.0012345, 3)
0.00123
>>> significant_arithmetic_rounding(-0.12345, 3)
-0.123
>>> significant_arithmetic_rounding(-30.15345, 3)
-30.2

예제가 포함되어 있을 때 답변을 쉽게 알 수 있습니다.다음은 이전 솔루션을 기반으로 하지만 1, 2, 3, 4 또는 임의의 유효 숫자로 반올림할 수 있는 보다 일반적인 기능을 제공합니다.

import math

# Given x as float or decimal, returns as string a number rounded to "sig" significant digts
# Return as string in order to control significant digits, could be a float or decimal 
def round_sig(x, sig=2):
  r = round(x, sig-int(math.floor(math.log10(abs(x))))-1)
  floatsig = "%." + str(sig) + "g"
  return "%d"%r if abs(r) >= 10**(sig-1) else '%s'%float(floatsig % r) 

>>> a = [1234, 123.4, 12.34, 1.234, 0.1234, 0.01234, 0.25, 1999, -3.14, -48.01, 0.75]
>>> [print(i, "->", round_sig(i,1), round_sig(i), round_sig(i,3), round_sig(i,4)) for i in a]

1234 -> 1000 1200 1230 1234
123.4 -> 100 120 123 123.4
12.34 -> 10 12 12.3 12.34
1.234 -> 1 1.2 1.23 1.234
0.1234 -> 0.1 0.12 0.123 0.1234
0.01234 -> 0.01 0.012 0.0123 0.01234
0.25 -> 0.2 0.25 0.25 0.25
1999 -> 2000 2000 2000 1999
-3.14 -> -3 -3.1 -3.14 -3.14
-48.01 -> -50 -48 -48.0 -48.01
0.75 -> 0.8 0.75 0.75 0.75

대부분의 경우 유의 개수는 평가된 공정(예: 오차)에 따라 달라집니다.나는 오류(또는 원하는 숫자)에 따라 숫자를 반환하는 일부 코드와 문자열 형태(오른쪽에 유의한 0이 제거되지 않음)를 작성했습니다.

import numpy as np

def Sig_Digit(x, *N,):
    if abs(x) < 1.0e-15:
        return(1)
    N = 1 if N ==() else N[0]
    k = int(round(abs(N)-1))-int(np.floor(np.log10(abs(x))))
    return(k);

def Sig_Format(x, *Error,):
    if abs(x) < 1.0e-15:
        return('{}')
    Error = 1 if Error ==() else abs(Error[0])
    k = int(np.floor(np.log10(abs(x))))
    z = x/10**k
    k = -Sig_Digit(Error, 1)
    m = 10**k
    y = round(x*m)/m
    if k < 0:
        k = abs(k)
        if z >= 9.5:
            FMT = '{:'+'{}'.format(1+k)+'.'+'{}'.format(k-1)+'f}'
        else:
            FMT = '{:'+'{}'.format(2+k)+'.'+'{}'.format(k)+'f}'
    elif k == 0:
        if z >= 9.5:
            FMT = '{:'+'{}'.format(1+k)+'.0e}'
        else:
            FMT = '{:'+'{}'.format(2+k)+'.0f}'
    else:
        FMT = '{:'+'{}'.format(2+k)+'.'+'{}'.format(k)+'e}'
    return(FMT)

def Sci_Format(x, *N):
    if abs(x) < 1.0e-15:
        return('{}')
    N = 1 if N ==() else N[0]
    N = int(round(abs(N)-1))
    y = abs(x)
    k = int(np.floor(np.log10(y)))
    z = x/10**k
    k = k-N
    m = 10**k
    y = round(x/m)*m
    if k < 0:
        k = abs(k)
        if z >= 9.5:
            FMT = '{:'+'{}'.format(1+k)+'.'+'{}'.format(k-1)+'f}'
        else:
            FMT = '{:'+'{}'.format(2+k)+'.'+'{}'.format(k)+'f}'
    elif k == 0:
        if z >= 9.5:
            FMT = '{:'+'{}'.format(1+k)+'.0e}'
        else:
            FMT = '{:'+'{}'.format(2+k)+'.0f}'
    else:
        FMT = '{:'+'{}'.format(2+N)+'.'+'{}'.format(N)+'e}'
    return(FMT)

def Significant(x, *Error):
    N = 0 if Error ==() else Sig_Digit(abs(Error[0]), 1)
    m = 10**N
    y = round(x*m)/m
    return(y)

def Scientific(x, *N):
    m = 10**Sig_Digit(x, *N)
    y = round(x*m)/m
    return(y)

def Scientific_Str(x, *N,): 
    FMT = Sci_Format(x, *N)
    return(FMT.format(x))

def Significant_Str(x, *Error,):    
    FMT = Sig_Format(x, *Error)
    return(FMT.format(x))

테스트 코드:

X = [19.03345607, 12.075, 360.108321344, 4325.007605343]
Error = [1.245, 0.1245, 0.0563, 0.01245, 0.001563, 0.0004603]
for x in X:
    for error in Error:
        print(x,'+/-',error, end='   \t==> ')
        print(' (',Significant_Str(x, error), '+/-', Scientific_Str(error),')')

  

출력:

19.03345607 +/- 1.245       ==>  ( 19 +/-  1 )

19.03345607 +/- 0.1245      ==>  ( 19.0 +/- 0.1 )

19.03345607 +/- 0.0563      ==>  ( 19.03 +/- 0.06 )

19.03345607 +/- 0.01245     ==>  ( 19.03 +/- 0.01 )

19.03345607 +/- 0.001563    ==>  ( 19.033 +/- 0.002 )

19.03345607 +/- 0.0004603       ==>  ( 19.0335 +/- 0.0005 )

12.075 +/- 1.245    ==>  ( 12 +/-  1 )

12.075 +/- 0.1245       ==>  ( 12.1 +/- 0.1 )

12.075 +/- 0.0563       ==>  ( 12.07 +/- 0.06 )

12.075 +/- 0.01245      ==>  ( 12.07 +/- 0.01 )

12.075 +/- 0.001563     ==>  ( 12.075 +/- 0.002 )

12.075 +/- 0.0004603    ==>  ( 12.0750 +/- 0.0005 )

360.108321344 +/- 1.245     ==>  ( 360 +/-  1 )

360.108321344 +/- 0.1245    ==>  ( 360.1 +/- 0.1 )

360.108321344 +/- 0.0563    ==>  ( 360.11 +/- 0.06 )

360.108321344 +/- 0.01245       ==>  ( 360.11 +/- 0.01 )

360.108321344 +/- 0.001563      ==>  ( 360.108 +/- 0.002 )

360.108321344 +/- 0.0004603     ==>  ( 360.1083 +/- 0.0005 )

4325.007605343 +/- 1.245    ==>  ( 4325 +/-  1 )

4325.007605343 +/- 0.1245       ==>  ( 4325.0 +/- 0.1 )

4325.007605343 +/- 0.0563       ==>  ( 4325.01 +/- 0.06 )

4325.007605343 +/- 0.01245      ==>  ( 4325.01 +/- 0.01 )

4325.007605343 +/- 0.001563     ==>  ( 4325.008 +/- 0.002 )

4325.007605343 +/- 0.0004603    ==>  ( 4325.0076 +/- 0.0005 )

언급URL : https://stackoverflow.com/questions/3410976/how-to-round-a-number-to-significant-figures-in-python