Pag-round ng mga decimal at integer sa Python na may “round” at “Decimal.quantize

Negosyo

Ang sumusunod ay nagpapaliwanag kung paano i-round ang mga numero sa Python sa pamamagitan ng pag-round o pag-round sa isang even na numero. Ang mga numero ay ipinapalagay na floating point float o integer int type.

  • built-in na function (hal. sa programming language):round()
    • Bilugan ang mga decimal sa anumang bilang ng mga digit.
    • Bilugan ang mga integer sa anumang bilang ng mga digit.
    • round() rounds sa isang even na numero, hindi sa isang karaniwang rounding
  • karaniwang aklatandecimalquantize()
    • DecimalPaglikha ng isang bagay
    • Pag-round ng mga decimal sa anumang bilang ng mga digit at pag-round sa even na mga numero
    • Pag-round ng integer sa anumang bilang ng mga digit at pag-round sa even na mga numero
  • Tukuyin ang isang bagong function
    • I-round off ang mga decimal sa anumang bilang ng mga digit.
    • Bilugan ang mga integer sa anumang bilang ng mga digit
    • Tandaan: Para sa mga negatibong halaga

Tandaan na, tulad ng nabanggit sa itaas, ang built-in na function na round ay hindi isang pangkalahatang rounding, ngunit isang rounding sa isang even na numero. Tingnan sa ibaba para sa mga detalye.

built-in na function (hal. sa programming language):round()

Round() ay ibinigay bilang isang built-in na function. Maaari itong magamit nang walang pag-import ng anumang mga module.

Ang unang argumento ay ang orihinal na numero, at ang pangalawang argumento ay ang bilang ng mga digit (kung gaano karaming mga digit ang ipapaikot).

Bilugan ang mga decimal sa anumang bilang ng mga digit.

Ang sumusunod ay isang halimbawa ng pagproseso para sa floating-point float type.

Kung ang pangalawang argumento ay tinanggal, ito ay bilugan sa isang integer. Ang uri ay nagiging isang integer int na uri.

f = 123.456

print(round(f))
# 123

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

Kung tinukoy ang pangalawang argumento, nagbabalik ito ng floating-point float type.

Kung ang isang positibong integer ay tinukoy, ang decimal na lugar ay tinukoy; kung ang isang negatibong integer ay tinukoy, ang integer na lugar ay tinukoy. -1 rounds sa pinakamalapit na ikasampu, -2 rounds sa pinakamalapit na hundredth, at 0 rounds sa isang integer (ang unang lugar), ngunit nagbabalik ng float type, hindi tulad ng kapag tinanggal.

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

Bilugan ang mga integer sa anumang bilang ng mga digit.

Ang sumusunod ay isang halimbawa ng pagproseso para sa integer int type.

Kung ang pangalawang argumento ay tinanggal, o kung 0 o isang positibong integer ang tinukoy, ang orihinal na halaga ay ibabalik kung ano ang dati. Kung ang isang negatibong integer ay tinukoy, ito ay bilugan sa katumbas na integer digit. Sa parehong mga kaso, isang integer int na uri ay ibinalik.

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() rounds sa isang even na numero, hindi sa isang karaniwang rounding

Tandaan na ang rounding gamit ang built-in na round() function sa Python 3 rounds sa isang even na numero, hindi sa isang pangkalahatang rounding.

Gaya ng nakasulat sa opisyal na dokumentasyon, ang 0.5 ay ni-round sa 0, ang 5 ay ni-round sa 0, at iba pa.

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

Ang kahulugan ng pag-round sa isang even na numero ay ang mga sumusunod.

Kung ang fraction ay mas mababa sa 0.5, bilugan ito pababa; kung ang fraction ay mas malaki sa 0.5, bilugan ito; kung ang fraction ay eksaktong 0.5, i-round up ito sa even number sa pagitan ng rounding down at rounding up.
Rounding – Wikipedia

0.5 ay hindi palaging pinutol.

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

Sa ilang mga kaso, ang kahulugan ng pag-round sa isang even na numero ay hindi nalalapat sa pagproseso pagkatapos ng dalawang decimal na lugar.

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

Ito ay dahil sa ang katunayan na ang mga decimal ay hindi maaaring katawanin nang eksakto bilang mga floating point na numero, tulad ng nakasaad sa opisyal na dokumentasyon.

Ang pag-uugali ng round() para sa mga numero ng floating point ay maaaring mabigla sa iyo:Halimbawa, ang round(2.675, 2) ay magbibigay sa iyo ng 2.67 sa halip na 2.68 gaya ng inaasahan. Hindi ito insekto.:Ito ay resulta ng katotohanan na ang karamihan sa mga decimal ay hindi maaaring katawanin nang eksakto ng mga numero ng floating point.
round() — Built-in Functions — Python 3.10.2 Documentation

Kung gusto mong makamit ang pangkalahatang pag-ikot o tumpak na pag-ikot ng mga decimal sa kahit na mga numero, maaari mong gamitin ang karaniwang library decimal quantize (inilalarawan sa ibaba) o tumukoy ng bagong function.

Tandaan din na ang round() sa Python 2 ay hindi rounding sa even number, ngunit rounding.

quantize() ng karaniwang library decimal

Ang decimal module ng karaniwang library ay maaaring gamitin upang pangasiwaan ang eksaktong decimal floating point na mga numero.

Gamit ang quantize() method ng decimal module, posibleng i-round ang mga numero sa pamamagitan ng pagtukoy sa rounding mode.

Ang mga set value para sa argument rounding ng quantize() method ay may mga sumusunod na kahulugan, ayon sa pagkakabanggit.

  • ROUND_HALF_UP:Pangkalahatang pag-ikot
  • ROUND_HALF_EVEN:Pag-round sa even na mga numero

Ang decimal module ay isang karaniwang library, kaya walang karagdagang pag-install ang kinakailangan, ngunit ang pag-import ay kinakailangan.

from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

Paglikha ng isang Decimal object

Ang Decimal() ay maaaring gamitin upang lumikha ng mga bagay na may uri ng Decimal.

Kung tutukuyin mo ang isang uri ng float bilang isang argumento, makikita mo kung ano talaga ang itinuturing na halaga.

print(Decimal(0.05))
# 0.05000000000000000277555756156289135105907917022705078125

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

Tulad ng ipinapakita sa halimbawa, ang 0.05 ay hindi itinuturing na eksaktong 0.05. Ito ang dahilan kung bakit ang built-in na function na round() na inilarawan sa itaas ay binilog sa ibang halaga kaysa sa inaasahan para sa mga decimal na halaga kasama ang 0.05 sa halimbawa.

Dahil ang 0.5 ay isang kalahati (-1 kapangyarihan ng 2), maaari itong ipahayag nang eksakto sa binary notation.

print(Decimal(0.5))
# 0.5

Kung tinukoy mo ang uri ng string na str sa halip na ang uri ng float, ituturing itong Decimal na uri ng eksaktong halaga.

print(Decimal('0.05'))
# 0.05

Pag-round ng mga decimal sa anumang bilang ng mga digit at pag-round sa even na mga numero

Tumawag sa quantize() mula sa isang object ng uri ng Decimal upang i-round off ang value.

Ang unang argumento ng quantize() ay isang string na may parehong bilang ng mga digit sa bilang ng mga digit na gusto mong hanapin, gaya ng ‘0.1’ o ‘0.01’.

Sa karagdagan, ang argumento ROUNDING ay tumutukoy sa rounding mode; kung ang ROUND_HALF_UP ay tinukoy, ang pangkalahatang rounding ay ginagamit.

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

Hindi tulad ng built-in na function round(), ang 0.5 ay bilugan sa 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

Kung ang argument rounding ay nakatakda sa ROUND_HALF_EVEN, ang rounding ay isinasagawa sa even na mga numero tulad ng sa built-in na function round().

Tulad ng nabanggit sa itaas, kung ang isang floating-point float type ay tinukoy bilang ang argument ng Decimal(), ito ay itinuturing bilang isang Decimal object na may value na katumbas ng aktwal na value ng float type, kaya ang resulta ng paggamit ng quantize() paraan ay iba mula sa kung ano ang inaasahan, tulad ng built-in na function 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

Kung ang argument ng Decimal() ay tinukoy bilang isang string ng uri ng str, ito ay ituturing bilang isang Decimal object ng eksaktong halagang iyon, kaya ang resulta ay tulad ng inaasahan.

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

Dahil ang 0.5 ay maaaring mahawakan nang tama ng uri ng float, walang problema sa pagtukoy sa uri ng float bilang argument ng Decimal() kapag ini-round sa isang integer, ngunit mas ligtas na tukuyin ang uri ng string str kapag ni-round sa isang decimal na lugar.

Halimbawa, ang 2.675 ay talagang 2.67499…. sa uri ng float. Samakatuwid, kung gusto mong i-round sa dalawang decimal na lugar, kailangan mong tukuyin ang isang string sa Decimal(), kung hindi, ang resulta ay magiging iba sa inaasahang resulta kung ikaw ay i-round sa pinakamalapit na buong numero (ROUND_HALF_UP) o sa isang even na numero (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

Tandaan na ang quantize() method ay nagbabalik ng Decimal type number, kaya kung gusto mong gumana sa float type number, kailangan mong i-convert ito sa float type gamit ang float(), kung hindi, magkakaroon ng error.

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

Pag-round ng integer sa anumang bilang ng mga digit at pag-round sa even na mga numero

Kung gusto mong i-round sa isang integer digit, ang pagtukoy ng isang bagay tulad ng ’10’ bilang unang argumento ay hindi magbibigay sa iyo ng nais na resulta.

i = 99518

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

Ito ay dahil ang quantize() ay nagsasagawa ng rounding ayon sa exponent ng Decimal object, ngunit ang exponent ng Decimal(’10’) ay 0, hindi 1.

Maaari mong tukuyin ang isang di-makatwirang exponent sa pamamagitan ng paggamit ng E bilang isang exponent string (hal., ‘1E1’). Maaaring suriin ang exponent exponent sa as_tuple method.

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)

Dahil dito, ang resulta ay nasa exponential notation gamit ang E. Kung gusto mong gumamit ng normal na notation, o kung gusto mong gumana nang may integer int type pagkatapos ng rounding, gamitin ang int() para i-convert ang resulta.

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

Kung ang argument rounding ay nakatakda sa ROUND_HALF_UP, ang pangkalahatang rounding ay magaganap, hal., 5 ay ipapa-round sa 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

Siyempre, walang problema kung tinukoy mo ito bilang isang string.

Tukuyin ang isang bagong function

Ang paraan ng paggamit ng decimal module ay tumpak at secure, ngunit kung hindi ka kumportable sa uri ng conversion, maaari mong tukuyin ang isang bagong function upang makamit ang pangkalahatang rounding.

Maraming posibleng paraan para gawin ito, halimbawa, ang sumusunod na function.

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

Kung hindi mo kailangang tukuyin ang bilang ng mga digit at palaging iikot sa unang decimal place, maaari kang gumamit ng mas simpleng form.

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

Kung kailangan mong maging tumpak, mas ligtas na gumamit ng decimal.

Ang sumusunod ay para sa sanggunian lamang.

I-round off ang mga decimal sa anumang bilang ng mga digit.

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

Hindi tulad ng pag-ikot, ang 0.5 ay nagiging 1 ayon sa pangkalahatang pag-ikot.

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

Bilugan ang mga integer sa anumang bilang ng mga digit

i = 99518

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

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

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

Hindi tulad ng pag-ikot, ang 5 ay nagiging 10 ayon sa karaniwang pag-ikot.

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

Tandaan: Para sa mga negatibong halaga

Sa halimbawang function sa itaas, -0.5 ay bilugan sa 0.

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

Mayroong iba’t ibang paraan ng pag-iisip tungkol sa pag-round para sa mga negatibong halaga, ngunit kung gusto mong gawing -1 ang -0.5, maaari mo itong baguhin bilang mga sumusunod, halimbawa.

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