在 Python 中使用“round”和“Decimal.quantize”舍入小數和整數

商業

下面解釋如何在 Python 中通過舍入或舍入到偶數來對數字進行舍入。這些數字被假定為浮點浮點或整數 int 類型。

  • 內置函數(例如在編程語言中):round()
    • 將小數四捨五入到任意位數。
    • 將整數四捨五入為任意位數。
    • round() 舍入到偶數,而不是普通舍入
  • 標準庫decimalquantize()
    • Decimal創建對象
    • 將小數四捨五入為任意位數並四捨五入為偶數
    • 將整數四捨五入為任意位數並四捨五入為偶數
  • 定義一個新函數
    • 將小數四捨五入到任意位數。
    • 將整數四捨五入為任意位數
    • 注意:對於負值

注意,如上所述,內置函數 round 不是一般的捨入,而是捨入到偶數。詳情見下文。

內置函數(例如在編程語言中):round()

Round() 作為內置函數提供。它可以在不導入任何模塊的情況下使用。

第一個參數是原始數字,第二個參數是位數(要四捨五入的位數)。

將小數四捨五入到任意位數。

以下是浮點浮點類型的處理示例。

如果省略第二個參數,則將其四捨五入為整數。該類型也變為整數 int 類型。

f = 123.456

print(round(f))
# 123

print(type(round(f)))
# <class 'int'>

如果指定了第二個參數,則返回浮點浮點類型。

如果指定正整數,則指定小數位;如果指定了負整數,則指定整數位。 -1 舍入到最接近的十分之一,-2 舍入到最接近的百分之一,0 舍入到整數(第一位),但返回浮點類型,與省略時不同。

print(round(f, 1))
# 123.5

print(round(f, 2))
# 123.46

print(round(f, -1))
# 120.0

print(round(f, -2))
# 100.0

print(round(f, 0))
# 123.0

print(type(round(f, 0)))
# <class 'float'>

將整數四捨五入為任意位數。

以下是整型 int 類型的處理示例。

如果省略第二個參數,或者指定 0 或正整數,則按原樣返回原始值。如果指定了負整數,則將其四捨五入到相應的整數位。在這兩種情況下,都會返回整數 int 類型。

i = 99518

print(round(i))
# 99518

print(round(i, 2))
# 99518

print(round(i, -1))
# 99520

print(round(i, -2))
# 99500

print(round(i, -3))
# 100000

round() 舍入到偶數,而不是普通舍入

請注意,使用 Python 3 中的內置 round() 函數舍入到偶數,而不是一般舍入。

官方文檔中寫的,0.5四捨五入為0,5四捨五入為0,以此類推。

print('0.4 =>', round(0.4))
print('0.5 =>', round(0.5))
print('0.6 =>', round(0.6))
# 0.4 => 0
# 0.5 => 0
# 0.6 => 1

print('4 =>', round(4, -1))
print('5 =>', round(5, -1))
print('6 =>', round(6, -1))
# 4 => 0
# 5 => 0
# 6 => 10

四捨五入到偶數的定義如下。

如果分數小於 0.5,則向下取整;如果分數大於 0.5,則向上取整;如果分數恰好為 0.5,則將其向上舍入到向下舍入和向上舍入之間的偶數。
Rounding – Wikipedia

0.5 並不總是被截斷。

print('0.5 =>', round(0.5))
print('1.5 =>', round(1.5))
print('2.5 =>', round(2.5))
print('3.5 =>', round(3.5))
print('4.5 =>', round(4.5))
# 0.5 => 0
# 1.5 => 2
# 2.5 => 2
# 3.5 => 4
# 4.5 => 4

在某些情況下,舍入到偶數的定義甚至不適用於小數點後兩位的處理。

print('0.05 =>', round(0.05, 1))
print('0.15 =>', round(0.15, 1))
print('0.25 =>', round(0.25, 1))
print('0.35 =>', round(0.35, 1))
print('0.45 =>', round(0.45, 1))
# 0.05 => 0.1
# 0.15 => 0.1
# 0.25 => 0.2
# 0.35 => 0.3
# 0.45 => 0.5

這是因為小數不能完全表示為浮點數,如官方文檔中所述。

浮點數的 round() 行為可能會讓您感到驚訝:例如,round(2.675, 2) 會給你 2.67 而不是預期的 2.68。這不是錯誤。:這是因為大多數小數不能用浮點數精確表示。
round() — Built-in Functions — Python 3.10.2 Documentation

如果要實現小數的一般舍入或精確舍入為偶數,可以使用標準庫十進制量化(如下所述)或定義一個新函數。

另請注意,Python 2 中的 round() 不是四捨五入到偶數,而是四捨五入。

標準庫十進制的 quantize()

標準庫的十進制模塊可用於處理精確的十進制浮點數。

使用 decimal 模塊的 quantize() 方法,可以通過指定舍入模式對數字進行舍入。

quantize() 方法的參數舍入的設置值分別具有以下含義。

  • ROUND_HALF_UP:一般舍入
  • ROUND_HALF_EVEN:四捨五入為偶數

十進制模塊是一個標準庫,所以不需要額外安裝,但需要導入。

from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

創建十進制對象

Decimal() 可用於創建 Decimal 類型的對象。

如果將浮點類型指定為參數,則可以看到該值實際被視為什麼。

print(Decimal(0.05))
# 0.05000000000000000277555756156289135105907917022705078125

print(type(Decimal(0.05)))
# <class 'decimal.Decimal'>

如示例中所示,0.05 不完全被視為 0.05。這就是為什麼上述內置函數 round() 舍入到與示例中的十進制值(包括 0.05)不同的值的原因。

由於 0.5 是二分之一(2 的 -1 次方),因此可以精確地用二進製表示法表示。

print(Decimal(0.5))
# 0.5

如果指定字符串類型 str 而不是 float 類型,它將被視為精確值的 Decimal 類型。

print(Decimal('0.05'))
# 0.05

將小數四捨五入為任意位數並四捨五入為偶數

從 Decimal 類型的對象調用 quantize() 以四捨五入該值。

quantize() 的第一個參數是一個字符串,其位數與您要查找的位數相同,例如“0.1”或“0.01”。

此外,參數 ROUNDING 指定舍入模式;如果指定了 ROUND_HALF_UP,則使用一般舍入。

f = 123.456

print(Decimal(str(f)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
# 123

print(Decimal(str(f)).quantize(Decimal('0.1'), rounding=ROUND_HALF_UP))
# 123.5

print(Decimal(str(f)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
# 123.46

與內置函數 round() 不同,0.5 舍入為 1。

print('0.4 =>', Decimal(str(0.4)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
print('0.5 =>', Decimal(str(0.5)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
print('0.6 =>', Decimal(str(0.6)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
# 0.4 => 0
# 0.5 => 1
# 0.6 => 1

如果參數舍入設置為 ROUND_HALF_EVEN,則舍入到偶數,如內置函數 round()。

如前所述,如果指定浮點浮點類型作為 Decimal() 的參數,則將其視為 Decimal 對象,其值等於浮點類型的實際值,因此使用 quantize() 的結果方法將與預期不同,就像內置函數 round() 一樣。

print('0.05 =>', round(0.05, 1))
print('0.15 =>', round(0.15, 1))
print('0.25 =>', round(0.25, 1))
print('0.35 =>', round(0.35, 1))
print('0.45 =>', round(0.45, 1))
# 0.05 => 0.1
# 0.15 => 0.1
# 0.25 => 0.2
# 0.35 => 0.3
# 0.45 => 0.5

print('0.05 =>', Decimal(0.05).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.15 =>', Decimal(0.15).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.25 =>', Decimal(0.25).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.35 =>', Decimal(0.35).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.45 =>', Decimal(0.45).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
# 0.05 => 0.1
# 0.15 => 0.1
# 0.25 => 0.2
# 0.35 => 0.3
# 0.45 => 0.5

如果 Decimal() 的參數指定為 str 類型的字符串,則將其視為恰好具有該值的 Decimal 對象,因此結果符合預期。

print('0.05 =>', Decimal(str(0.05)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.15 =>', Decimal(str(0.15)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.25 =>', Decimal(str(0.25)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.35 =>', Decimal(str(0.35)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.45 =>', Decimal(str(0.45)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
# 0.05 => 0.0
# 0.15 => 0.2
# 0.25 => 0.2
# 0.35 => 0.4
# 0.45 => 0.4

由於 0.5 可以通過 float 類型正確處理,因​​此在舍入為整數時指定 float 類型作為 Decimal() 的參數是沒有問題的,但在舍入到小數位時指定字符串 str 類型更安全。

例如,2.675 實際上是 2.67499…. 浮點型。因此,如果要四捨五入到兩位小數,必須在 Decimal() 中指定一個字符串,否則無論是四捨五入到最接近的整數 (ROUND_HALF_UP) 還是偶數 (ROUND_HALF_EVEN),結果都會與預期結果不同)。

print(Decimal(2.675))
# 2.67499999999999982236431605997495353221893310546875

print(Decimal(2.675).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
# 2.67

print(Decimal(str(2.675)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
# 2.68

print(Decimal(2.675).quantize(Decimal('0.01'), rounding=ROUND_HALF_EVEN))
# 2.67

print(Decimal(str(2.675)).quantize(Decimal('0.01'), rounding=ROUND_HALF_EVEN))
# 2.68

注意quantize()方法返回的是Decimal類型的數字,所以如果要對float類型的數字進行操作,需要使用float()將其轉換為float類型,否則會報錯。

d = Decimal('123.456').quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)

print(d)
# 123.46

print(type(d))
# <class 'decimal.Decimal'>

# print(1.2 + d)
# TypeError: unsupported operand type(s) for +: 'float' and 'decimal.Decimal'

print(1.2 + float(d))
# 124.66

將整數四捨五入為任意位數並四捨五入為偶數

如果你想四捨五入到一個整數,指定像“10”這樣的第一個參數不會給你想要的結果。

i = 99518

print(Decimal(i).quantize(Decimal('10'), rounding=ROUND_HALF_UP))
# 99518

這是因為 quantize() 根據 Decimal 對象的指數進行舍入,但 Decimal(’10’) 的指數是 0,而不是 1。

您可以通過使用 E 作為指數字符串來指定任意指數(例如,’1E1’)。可以在 as_tuple 方法中檢查指數指數。

print(Decimal('10').as_tuple())
# DecimalTuple(sign=0, digits=(1, 0), exponent=0)

print(Decimal('1E1').as_tuple())
# DecimalTuple(sign=0, digits=(1,), exponent=1)

實際上,結果將使用 E 以指數表示法。如果您想使用普通表示法,或者如果您想在舍入後使用整數 int 類型進行操作,請使用 int() 轉換結果。

print(Decimal(i).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP))
# 9.952E+4

print(int(Decimal(i).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
# 99520

print(int(Decimal(i).quantize(Decimal('1E2'), rounding=ROUND_HALF_UP)))
# 99500

print(int(Decimal(i).quantize(Decimal('1E3'), rounding=ROUND_HALF_UP)))
# 100000

如果參數舍入設置為 ROUND_HALF_UP,將進行一般舍入,例如,5 將舍入為 10。

print('4 =>', int(Decimal(4).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
print('5 =>', int(Decimal(5).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
print('6 =>', int(Decimal(6).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
# 4 => 0
# 5 => 10
# 6 => 10

當然,如果指定為字符串也沒有問題。

定義一個新函數

使用decimal模塊的方法準確且安全,但如果您不習慣類型轉換,您可以定義一個新函數來實現一般舍入。

有很多可能的方法可以做到這一點,例如,下面的函數。

def my_round(val, digit=0):
    p = 10 ** digit
    return (val * p * 2 + 1) // 2 / p

如果您不需要指定位數並始終四捨五入到小數點後一位,則可以使用更簡單的形式。

my_round_int = lambda x: int((x * 2 + 1) // 2)

如果您需要精確,使用小數會更安全。

以下內容僅供參考。

將小數四捨五入到任意位數。

print(int(my_round(f)))
# 123

print(my_round_int(f))
# 123

print(my_round(f, 1))
# 123.5

print(my_round(f, 2))
# 123.46

與舍入不同,0.5 按照一般舍入變為 1。

print(int(my_round(0.4)))
print(int(my_round(0.5)))
print(int(my_round(0.6)))
# 0
# 1
# 1

將整數四捨五入為任意位數

i = 99518

print(int(my_round(i, -1)))
# 99520

print(int(my_round(i, -2)))
# 99500

print(int(my_round(i, -3)))
# 100000

與舍入不同,根據普通舍入,5 變為 10。

print(int(my_round(4, -1)))
print(int(my_round(5, -1)))
print(int(my_round(6, -1)))
# 0
# 10
# 10

注意:對於負值

在上面的示例函數中,-0.5 舍入為 0。

print(int(my_round(-0.4)))
print(int(my_round(-0.5)))
print(int(my_round(-0.6)))
# 0
# 0
# -1

對負值進行四捨五入的想法有很多種,但是如果要將-0.5變成-1,可以修改如下,例如

import math

def my_round2(val, digit=0):
    p = 10 ** digit
    s = math.copysign(1, val)
    return (s * val * p * 2 + 1) // 2 / p * s

print(int(my_round2(-0.4)))
print(int(my_round2(-0.5)))
print(int(my_round2(-0.6)))
# 0
# -1
# -1
Copied title and URL