Kuzungusha desimali na nambari kamili katika Python na “raundi” na “Decimal.quantize

Biashara

Ifuatayo inaelezea jinsi ya kuzungusha nambari kwenye Python kwa kuzungusha au kuzungusha hadi nambari sawa. Nambari zinadhaniwa kuwa za sehemu inayoelea au aina kamili ya int.

  • kitendakazi kilichojumuishwa (k.m. katika lugha ya programu):round()
    • Desimali pande zote hadi nambari yoyote ya tarakimu.
    • Nambari kamili kwa nambari yoyote ya nambari.
    • round() duru hadi nambari sawa, sio kwa mduara wa kawaida
  • maktaba ya kawaidadecimalquantize()
    • DecimalKuunda kitu
    • Kuzungusha desimali hadi nambari yoyote ya tarakimu na kuzungushwa hadi nambari sawa
    • Kuzungusha nambari kamili kwa nambari yoyote ya tarakimu na kuzungushwa hadi nambari sawia
  • Bainisha kipengele kipya cha kukokotoa
    • Sawazisha desimali hadi nambari yoyote ya tarakimu.
    • Nambari kamili kwa nambari yoyote ya nambari
    • Kumbuka: Kwa maadili hasi

Kumbuka kuwa, kama ilivyotajwa hapo juu, duru ya kazi iliyojumuishwa sio mduara wa jumla, lakini mduara kwa nambari sawa. Tazama hapa chini kwa maelezo.

kitendakazi kilichojumuishwa (k.m. katika lugha ya programu):round()

Round() imetolewa kama kitendakazi kilichojengewa ndani. Inaweza kutumika bila kuagiza moduli yoyote.

Hoja ya kwanza ni nambari asilia, na hoja ya pili ni nambari ya tarakimu (kuzungusha tarakimu ngapi).

Desimali pande zote hadi nambari yoyote ya tarakimu.

Ufuatao ni mfano wa usindikaji wa aina ya kuelea-pointi.

Hoja ya pili ikiachwa, inazungushwa hadi nambari kamili. Aina pia inakuwa aina kamili ya int.

f = 123.456

print(round(f))
# 123

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

Ikiwa hoja ya pili imebainishwa, inarejesha aina ya kuelea ya sehemu inayoelea.

Ikiwa nambari chanya imeainishwa, mahali pa decimal hubainishwa; ikiwa nambari hasi imebainishwa, sehemu kamili imebainishwa. Mizunguko 1 hadi kumi iliyo karibu zaidi, -2 mizunguko hadi mia iliyo karibu zaidi, na mizunguko 0 hadi nambari kamili (nafasi ya kwanza), lakini inarudisha aina ya kuelea, tofauti na inapoachwa.

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

Nambari kamili kwa nambari yoyote ya nambari.

Ufuatao ni mfano wa usindikaji wa aina kamili ya int.

Ikiwa hoja ya pili itaachwa, au ikiwa 0 au nambari kamili imebainishwa, thamani halisi inarejeshwa kama ilivyo. Ikiwa nambari hasi imebainishwa, inazungushwa hadi tarakimu kamili inayolingana. Katika visa vyote viwili, aina kamili ya int inarudishwa.

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() duru hadi nambari sawa, sio kwa mduara wa kawaida

Kumbuka kuwa kuzungusha na kujengwa ndani round() kazi katika Python 3 raundi hadi nambari sawa, sio kwa mzunguko wa jumla.

Kama ilivyoandikwa katika hati rasmi, 0.5 imezungushwa hadi 0, 5 imezungushwa hadi 0, na kadhalika.

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

Ufafanuzi wa kuzungusha kwa nambari sawa ni kama ifuatavyo.

Ikiwa sehemu ni chini ya 0.5, duru chini; ikiwa sehemu ni kubwa kuliko 0.5, izungushe; ikiwa sehemu ni 0.5 haswa, izungushe hadi nambari sawa kati ya kuzungusha chini na kuzungusha.
Rounding – Wikipedia

0.5 haijapunguzwa kila wakati.

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

Katika hali nyingine, ufafanuzi wa kuzungusha kwa nambari hata hautumiki kwa usindikaji baada ya sehemu mbili za decimal.

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

Hii ni kwa sababu ya ukweli kwamba desimali haziwezi kuwakilishwa sawasawa na nambari za sehemu zinazoelea, kama ilivyoonyeshwa kwenye hati rasmi.

Tabia ya round() kwa nambari za sehemu zinazoelea inaweza kukushangaza:Kwa mfano, round(2.675, 2) itakupa 2.67 badala ya 2.68 kama inavyotarajiwa. Huyu si mdudu.:Hii ni matokeo ya ukweli kwamba desimali nyingi haziwezi kuwakilishwa haswa na nambari za nukta zinazoelea.
round() — Built-in Functions — Python 3.10.2 Documentation

Iwapo ungependa kufikia mduara wa jumla au uwekaji sahihi wa desimali hadi nambari hata, unaweza kutumia kipimo cha desimali ya kawaida ya maktaba (iliyofafanuliwa hapa chini) au kufafanua chaguo mpya la kukokotoa.

Pia kumbuka kuwa round() kwenye Python 2 haizungushi kwa nambari hata, lakini inazungusha.

quantize() ya desimali ya kawaida ya maktaba

Moduli ya desimali ya maktaba ya kawaida inaweza kutumika kushughulikia nambari za uhakika za desimali zinazoelea.

Kutumia njia ya quantize () ya moduli ya decimal, inawezekana kuzunguka nambari kwa kutaja hali ya kuzunguka.

Thamani zilizowekwa za kuzungusha kwa hoja kwa njia ya quantize() zina maana zifuatazo, mtawaliwa.

  • ROUND_HALF_UP:Mzunguko wa jumla
  • ROUND_HALF_EVEN:Inazunguka kwa nambari sawa

Moduli ya decimal ni maktaba ya kawaida, kwa hivyo hakuna usakinishaji wa ziada unaohitajika, lakini kuagiza ni muhimu.

from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

Kuunda kitu cha Desimali

Desimali() inaweza kutumika kuunda vitu vya aina ya Desimali.

Ukibainisha aina ya kuelea kama hoja, unaweza kuona thamani inachukuliwa kama nini.

print(Decimal(0.05))
# 0.05000000000000000277555756156289135105907917022705078125

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

Kama inavyoonyeshwa kwenye mfano, 0.05 haijatibiwa kama 0.05 haswa. Hii ndio sababu fomula ya kukokotoa iliyojengewa ndani round() iliyofafanuliwa hapo juu kuzungushwa hadi thamani tofauti na inavyotarajiwa kwa thamani za desimali ikijumuisha 0.05 kwenye mfano.

Kwa kuwa 0.5 ni nusu (-1 nguvu ya 2), inaweza kuonyeshwa haswa katika nukuu ya binary.

print(Decimal(0.5))
# 0.5

Ukibainisha aina ya mfuatano badala ya aina ya kuelea, itachukuliwa kama aina ya Desimali ya thamani kamili.

print(Decimal('0.05'))
# 0.05

Kuzungusha desimali hadi nambari yoyote ya tarakimu na kuzungushwa hadi nambari sawa

Piga quantize() kutoka kwa kitu cha aina ya Desimali ili kumaliza thamani.

Hoja ya kwanza ya quantize() ni mfuatano wenye nambari sawa ya tarakimu na nambari ya tarakimu unayotaka kupata, kama vile ‘0.1’ au ‘0.01’.

Kwa kuongeza, hoja ya ROUNDING inabainisha hali ya kuzungusha; ikiwa ROUND_HALF_UP imebainishwa, mzunguko wa jumla unatumika.

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

Tofauti na kazi iliyojengewa ndani round(), 0.5 imezungushwa hadi 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

Ikiwa mduara wa hoja umewekwa kuwa ROUND_HALF_EVEN, kuzungusha kunafanywa kwa nambari sawa kama katika duru ya chaguo la kukokotoa iliyojumuishwa().

Kama ilivyoelezwa hapo juu, ikiwa aina ya kuelea ya sehemu ya kuelea imeainishwa kama hoja ya Decimal(), inachukuliwa kama kitu cha Desimali na thamani sawa na thamani halisi ya aina ya kuelea, kwa hivyo matokeo ya kutumia quantize() njia itakuwa tofauti na inavyotarajiwa, kama kazi iliyojengwa ndani 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

Ikiwa hoja ya Desimali() imebainishwa kama mfuatano wa aina str, inachukuliwa kama kitu cha Desimali cha thamani hiyo haswa, kwa hivyo matokeo ni kama inavyotarajiwa.

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

Kwa kuwa 0.5 inaweza kushughulikiwa ipasavyo na aina ya kuelea, hakuna tatizo katika kubainisha aina ya kuelea kama hoja ya Decimal() wakati wa kuzungusha hadi nambari kamili, lakini ni salama zaidi kubainisha aina ya mfuatano wakati wa kuzungusha hadi mahali pa desimali.

Kwa mfano, 2.675 ni kweli 2.67499 …. katika aina ya kuelea. Kwa hivyo, ikiwa unataka kuzungusha hadi sehemu mbili za desimali, lazima ubainishe kamba kwa Desimali(), vinginevyo matokeo yatakuwa tofauti na matokeo yanayotarajiwa ikiwa utazungusha hadi nambari nzima iliyo karibu (ROUND_HALF_UP) au nambari sawa (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

Kumbuka kuwa njia ya quantize() inarudisha nambari ya aina ya Desimali, kwa hivyo ikiwa unataka kufanya kazi kwenye nambari ya aina ya kuelea, unahitaji kuibadilisha kuwa aina ya kuelea kwa kutumia float(), vinginevyo hitilafu itatokea.

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

Kuzungusha nambari kamili kwa nambari yoyote ya tarakimu na kuzungushwa hadi nambari sawia

Ikiwa unataka kuzungusha hadi nambari kamili, kubainisha kitu kama ’10’ kama hoja ya kwanza haitakupa matokeo unayotaka.

i = 99518

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

Hii ni kwa sababu quantize() hufanya kuzungusha kulingana na kipeo cha kitu cha Desimali, lakini kipeo cha Decimal(’10’) ni 0, sio 1.

Unaweza kubainisha kipeo kikuu kiholela kwa kutumia E kama mfuatano wa kipeo (k.m., ‘1E1’). Kipeo kikuu kinaweza kuangaliwa kwa njia ya 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)

Kama ilivyo, matokeo yatakuwa katika nukuu ya ufafanuzi kwa kutumia E. Ikiwa unataka kutumia nukuu ya kawaida, au ikiwa unataka kufanya kazi na aina kamili ya int baada ya kuzungusha, tumia int() kubadilisha matokeo.

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

Ikiwa mzunguko wa hoja utawekwa kuwa ROUND_HALF_UP, mduara wa jumla utafanyika, k.m., 5 itazungushwa hadi 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

Kwa kweli, hakuna shida ikiwa utaibainisha kama kamba.

Bainisha kipengele kipya cha kukokotoa

Njia ya kutumia moduli ya decimal ni sahihi na salama, lakini ikiwa huna urahisi na ubadilishaji wa aina, unaweza kufafanua kazi mpya ili kufikia mzunguko wa jumla.

Kuna njia nyingi zinazowezekana za kufanya hivyo, kwa mfano, kazi ifuatayo.

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

Ikiwa huna haja ya kutaja idadi ya tarakimu na kila mara kuzunguka hadi sehemu ya kwanza ya desimali, unaweza kutumia fomu rahisi zaidi.

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

Ikiwa unahitaji kuwa sahihi, ni salama kutumia desimali.

Ifuatayo ni kwa kumbukumbu tu.

Sawazisha desimali hadi nambari yoyote ya tarakimu.

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

Tofauti na pande zote, 0.5 inakuwa 1 kulingana na mzunguko wa jumla.

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

Nambari kamili kwa nambari yoyote ya nambari

i = 99518

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

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

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

Tofauti na pande zote, 5 inakuwa 10 kulingana na mzunguko wa kawaida.

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

Kumbuka: Kwa maadili hasi

Katika mfano wa kazi hapo juu, -0.5 imezungushwa hadi 0.

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

Kuna njia anuwai za kufikiria juu ya kuzungusha kwa maadili hasi, lakini ikiwa unataka kufanya -0.5 kuwa -1, unaweza kuirekebisha kama ifuatavyo, kwa mfano.

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