วิธีการปัดเศษตัวเลขเป็นตัวเลขสำคัญใน Python

ฉันต้องปัดเศษทศนิยมเพื่อให้แสดงใน UI เช่นกับบุคคลสำคัญ:

1234 -> 1,000

0.12 -> 0.1

0.012 -> 0.01

0.062 -> 0.06

6253 -> 6000

1999 -> 2000

มีวิธีที่ดีในการทำเช่นนี้โดยใช้ห้องสมุด Python หรือฉันต้องเขียนเอง?

คุณสามารถใช้ตัวเลขติดลบเพื่อปัดเศษจำนวนเต็ม:

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

หากคุณต้องการให้มีทศนิยมมากกว่า 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

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

วิธีนี้แตกต่างจากโซลูชันอื่นทั้งหมดเนื่องจาก:

1. มันตรงแก้คำถามสหกรณ์
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']

หมายเหตุ : ด้วยวิธีนี้มันเป็นไปไม่ได้ที่จะปรับจำนวนตัวเลขที่สำคัญแบบไดนามิกจากอินพุตเนื่องจากไม่มีวิธีมาตรฐานในการแยกแยะตัวเลขด้วยตัวเลขที่แตกต่างกันของศูนย์ต่อท้าย ( 3.14 == 3.1400) หากคุณต้องการทำเช่นนั้นจำเป็นต้องใช้ฟังก์ชั่นที่ไม่ได้มาตรฐานเช่นเดียวกับที่อยู่ในแพ็คเกจเพื่อความแม่นยำ

ฉันได้สร้างแพ็คเกจเพื่อความแม่นยำที่ทำในสิ่งที่คุณต้องการ จะช่วยให้คุณให้ตัวเลขที่สำคัญมากขึ้นหรือน้อยลง

นอกจากนี้ยังแสดงสัญลักษณ์มาตรฐานวิทยาศาสตร์และวิศวกรรมด้วยตัวเลขที่ระบุจำนวนมาก

ในคำตอบที่ยอมรับมีบรรทัด

>>> round_to_1(1234243)
1000000.0

ที่ระบุจริงมะเดื่อ 8 sig สำหรับหมายเลข 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'

ในการปัดเศษจำนวนเต็มเป็น 1 ตัวเลขสำคัญแนวคิดพื้นฐานคือการแปลงให้เป็นทศนิยมด้วยตัวเลข 1 หลักก่อนจุดและปัดเศษจากนั้นแปลงกลับเป็นขนาดจำนวนเต็มดั้งเดิม

ในการทำเช่นนี้เราจำเป็นต้องรู้พลังที่ใหญ่ที่สุดของ 10 น้อยกว่าจำนวนเต็ม เราสามารถใช้ฟังก์ชัน floor ของ 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)

หากต้องการตอบคำถามโดยตรงนี่คือรุ่นของฉันที่ใช้การตั้งชื่อจากฟังก์ชัน 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.07 มากกว่า 0.08 นี่คือเนื่องจากตามที่ชี้ให้เห็นโดย "สามเณร C" เพื่อการรวมกันของเลขคณิตจุดลอยที่มีทั้งความแม่นยำแน่นอนและการเป็นตัวแทนฐาน -2ความแม่นยำแน่นอนและเป็นตัวแทนฐาน-2ตัวเลขที่ใกล้ที่สุดถึง 0.075 ที่สามารถแสดงได้จริงนั้นมีขนาดเล็กกว่าเล็กน้อยดังนั้นการปัดเศษจึงแตกต่างจากที่คุณคาดไม่ถึง

นอกจากนี้โปรดทราบว่าสิ่งนี้ใช้กับการใช้เลขทศนิยมใด ๆ ที่ไม่ใช่ทศนิยมเช่น C และ Java ทั้งคู่มีปัญหาเดียวกัน

เพื่อแสดงรายละเอียดเพิ่มเติมเราขอให้ Python จัดรูปแบบตัวเลขในรูปแบบ "hex":

0.075.hex()

0x1.3333333333333p-4ซึ่งจะช่วยให้เรา: เหตุผลในการทำเช่นนี้คือการแทนทศนิยมปกติมักเกี่ยวข้องกับการปัดเศษและไม่ใช่วิธีที่คอมพิวเตอร์ "เห็น" จำนวนจริง หากคุณไม่คุ้นเคยกับรูปแบบนี้การอ้างอิงที่เป็นประโยชน์สองสามประการคือPython docsและมาตรฐาน Cประการ

เพื่อแสดงให้เห็นว่าตัวเลขเหล่านี้ทำงานได้ดีเพียงใดเราสามารถกลับไปที่จุดเริ่มต้นของเราได้โดยทำดังนี้

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

0.075ซึ่งควรควรจะพิมพ์ออกมา 16**13เป็นเพราะมีเลขฐานสิบหก 13 หลักหลังจุดทศนิยมและ2**-4เป็นเพราะเลขชี้กำลังเลขฐานสิบหกเป็นฐาน -2

ตอนนี้เรามีความคิดว่าการเป็นตัวแทนของลอยนั้นสามารถใช้decimalโมดูลเพื่อให้ความแม่นยำมากขึ้นแสดงให้เราเห็นสิ่งที่เกิดขึ้น:

from decimal import Decimal

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

ให้: 0.07499999999999999722444243844และหวังว่าจะอธิบายว่าทำไมround(0.075, 2)ประเมินถึง0.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

หวังว่าจะใช้คำตอบที่ดีที่สุดทั้งหมดข้างต้น (ลบด้วยความสามารถที่จะใส่มันเป็นแลมบ์ดาบรรทัดเดียว)) ยังไม่ได้สำรวจอย่าลังเลที่จะแก้ไขคำตอบนี้:

round_to_n(1e15 + 1, 11)  # 999999999999999.9

ฉันแก้ไขวิธีแก้ปัญหาของ indgar เพื่อจัดการกับจำนวนลบและตัวเลขเล็ก ๆ (รวมศูนย์)

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

มันใช้งานได้กับค่าตัวเลขเซนต์คิตส์และเนวิสอาจเป็นfloatถ้าคุณต้องการที่จะตอบสนองด้วยเหตุผลบางอย่าง คุณสามารถผลักดันขีด จำกัด ไปที่:

sys.float_info.min*sys.float_info.epsilon

โดยไม่มีการยั่วยุข้อผิดพลาดถ้าด้วยเหตุผลบางอย่างคุณกำลังทำงานกับค่า miniscule

ฉันไม่สามารถคิดอะไรที่สามารถจัดการกับเรื่องนี้ได้ แต่ก็มีการจัดการที่ค่อนข้างดีสำหรับตัวเลขจุดลอย

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

หากคุณต้องการสร้างฟังก์ชั่นที่จัดการหมายเลขใด ๆ การตั้งค่าของฉันคือการแปลงทั้งสองเป็นสตริงและค้นหาตำแหน่งทศนิยมเพื่อตัดสินใจว่าจะทำอย่างไร:

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

คำตอบที่โพสต์นั้นดีที่สุดเมื่อได้รับ แต่มีข้อ จำกัด มากมายและไม่ได้สร้างตัวเลขที่มีความหมายทางเทคนิคที่ถูกต้อง

numpy.format_float_positionalสนับสนุนพฤติกรรมที่ต้องการโดยตรง แฟรกเมนต์ต่อไปนี้ส่งคืนโฟลว์ที่xจัดรูปแบบเป็นตัวเลขที่มีนัยสำคัญ 4 ตัวพร้อมกับระงับสัญลักษณ์ทางวิทยาศาสตร์

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

ฉันวิ่งเข้าไปในนี้เช่นกัน แต่ฉันต้องการการควบคุมประเภทการปัดเศษ ดังนั้นฉันจึงเขียนฟังก์ชั่นด่วน (ดูรหัสด้านล่าง) ที่สามารถนำค่าประเภทการปัดเศษและตัวเลขที่สำคัญที่ต้องการเข้าบัญชี

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

การใช้การจัดรูปแบบรูปแบบใหม่ของไพ ธ อน 2.6+ (เนื่องจาก% -style เลิกใช้แล้ว):

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

ใน python 2.7+ คุณสามารถละทิ้ง0s

ฟังก์ชั่นนี้ทำรอบปกติถ้าจำนวนมากกว่า 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) หรือไม่ Caveat: ส่งคืนค่าเป็นแบบลอย

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)

วิธีนี้ใช้ได้กับตัวเลขแต่ละตัวและอาร์เรย์ numpy และควรทำงานได้ดีสำหรับจำนวนลบ

มีอีกหนึ่งขั้นตอนที่เราอาจเพิ่ม - np.round () ส่งกลับเลขทศนิยมแม้ว่าการปัดเศษเป็นจำนวนเต็ม (เช่นสำหรับตัวเลขสำคัญ = 2 เราอาจคาดหวังว่าจะได้รับกลับ -460 แต่แทนที่จะได้รับ -460.0) เราสามารถเพิ่มขั้นตอนนี้เพื่อแก้ไข:

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

น่าเสียดายที่ขั้นตอนสุดท้ายนี้ใช้ไม่ได้กับอาร์เรย์ของตัวเลข - ฉันจะปล่อยให้คุณเป็นที่รักของผู้อ่านเพื่อคิดออกหากคุณต้องการ

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

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