Rrumbullakimi i numrave dhjetorë dhe numrave të plotë në Python me “round” dhe “Decimal.quantize

biznes

Më poshtë shpjegon se si të rrumbullakosni numrat në Python duke rrumbullakosur ose rrumbullakosur në një numër çift. Numrat supozohen të jenë të tipit float me pikë lundruese ose int të plotë.

  • funksion i integruar (p.sh. në gjuhën e programimit):round()
    • Rrumbullakosni numrat dhjetorë në çdo numër shifrash.
    • Rrumbullakosni numrat e plotë në çdo numër shifrash.
    • round() rrumbullakos në një numër çift, jo në një rrumbullakim të zakonshëm
  • bibliotekë standardedecimalquantize()
    • DecimalKrijimi i një objekti
    • Rrumbullakimi i numrave dhjetorë në çdo numër shifrash dhe rrumbullakimi në numra çift
    • Rrumbullakimi i numrave të plotë në çdo numër shifrash dhe rrumbullakimi në numra çift
  • Përcaktoni një funksion të ri
    • Rrumbullakosni numrat dhjetorë në çdo numër shifrash.
    • Rrumbullakosni numrat e plotë në çdo numër shifrash
    • Shënim: Për vlerat negative

Vini re se, siç u përmend më lart, raundi i funksionit të integruar nuk është një rrumbullakim i përgjithshëm, por një rrumbullakim në një numër çift. Shihni më poshtë për detaje.

funksion i integruar (p.sh. në gjuhën e programimit):round()

Round() ofrohet si një funksion i integruar. Mund të përdoret pa importuar asnjë modul.

Argumenti i parë është numri origjinal, dhe argumenti i dytë është numri i shifrave (në sa shifra duhet rrumbullakosur).

Rrumbullakosni numrat dhjetorë në çdo numër shifrash.

Më poshtë është një shembull i përpunimit për llojin float me pikë lundruese.

Nëse argumenti i dytë hiqet, ai rrumbullakoset në një numër të plotë. Lloji gjithashtu bëhet një tip int int.

f = 123.456

print(round(f))
# 123

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

Nëse argumenti i dytë specifikohet, ai kthen një tip float me pikë lundruese.

Nëse specifikohet një numër i plotë pozitiv, specifikohet numri dhjetor; nëse specifikohet një numër i plotë negativ, specifikohet vendi i plotë. -1 rrotullohet në të dhjetën më të afërt, -2 raunde në të qindtën më të afërt dhe 0 raunde në një numër të plotë (vendi i parë), por kthen një lloj float, ndryshe nga rasti kur hiqet.

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

Rrumbullakosni numrat e plotë në çdo numër shifrash.

Më poshtë është një shembull i përpunimit për llojin int të plotë.

Nëse argumenti i dytë hiqet, ose nëse specifikohet 0 ose një numër i plotë pozitiv, vlera origjinale kthehet siç është. Nëse specifikohet një numër i plotë negativ, ai rrumbullakoset në shifrën përkatëse të numrit të plotë. Në të dyja rastet, kthehet një tip int 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() rrumbullakos në një numër çift, jo në një rrumbullakim të zakonshëm

Vini re se rrumbullakimi me funksionin e integruar round() në Python 3 rrumbullakos në një numër çift, jo në një rrumbullakim të përgjithshëm.

Siç shkruhet në dokumentacionin zyrtar, 0.5 rrumbullakohet në 0, 5 rrumbullakohet në 0, e kështu me radhë.

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

Përkufizimi i rrumbullakimit në një numër çift është si më poshtë.

Nëse thyesa është më e vogël se 0,5, rrumbullakojeni atë poshtë; nëse thyesa është më e madhe se 0,5, rrumbullakojeni atë; nëse thyesa është saktësisht 0,5, rrumbullakojeni atë deri në numrin çift midis rrumbullakimit poshtë dhe rrumbullakimit lart.
Rounding – Wikipedia

0.5 nuk është gjithmonë i cunguar.

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

Në disa raste, përkufizimi i rrumbullakimit në një numër çift nuk zbatohet as për përpunimin pas dy shifrave dhjetore.

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

Kjo për faktin se numrat dhjetorë nuk mund të përfaqësohen saktësisht si numra me pikë lundruese, siç thuhet në dokumentacionin zyrtar.

Sjellja e round() për numrat me pikë lundruese mund t’ju habisë:Për shembull, raundi (2.675, 2) do t’ju japë 2.67 në vend të 2.68 siç pritej. Ky nuk është një gabim.:Ky është rezultat i faktit se shumica e numrave dhjetorë nuk mund të përfaqësohen saktësisht me numra me pikë lundruese.
round() — Built-in Functions — Python 3.10.2 Documentation

Nëse dëshironi të arrini rrumbullakim të përgjithshëm ose rrumbullakim të saktë të numrave dhjetorë në numra çift, mund të përdorni kuantizimin standard të bibliotekës dhjetore (të përshkruar më poshtë) ose të përcaktoni një funksion të ri.

Gjithashtu vini re se round() në Python 2 nuk është rrumbullakimi në një numër çift, por rrumbullakimi.

quantize() e dhjetorit standard të bibliotekës

Moduli dhjetor i bibliotekës standarde mund të përdoret për të trajtuar numrat e saktë dhjetorë me pikë lundruese.

Duke përdorur metodën quantize() të modulit dhjetor, është e mundur të rrumbullakosni numrat duke specifikuar mënyrën e rrumbullakimit.

Vlerat e vendosura për rrumbullakimin e argumentit të metodës quantize() kanë përkatësisht kuptimet e mëposhtme.

  • ROUND_HALF_UP:Rrumbullakimi i përgjithshëm
  • ROUND_HALF_EVEN:Rrumbullakimi në numra çift

Moduli dhjetor është një bibliotekë standarde, kështu që nuk kërkohet instalim shtesë, por është i nevojshëm importimi.

from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

Krijimi i një objekti dhjetor

Decimal() mund të përdoret për të krijuar objekte të tipit Decimal.

Nëse specifikoni një lloj float si argument, mund të shihni se si trajtohet në të vërtetë vlera.

print(Decimal(0.05))
# 0.05000000000000000277555756156289135105907917022705078125

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

Siç tregohet në shembull, 0.05 nuk trajtohet saktësisht si 0.05. Kjo është arsyeja pse funksioni i integruar round() i përshkruar më sipër u rrumbullakos në një vlerë të ndryshme nga ajo që pritej për vlerat dhjetore duke përfshirë 0.05 në shembull.

Meqenëse 0.5 është gjysma (-1 fuqia e 2), mund të shprehet saktësisht në shënimin binar.

print(Decimal(0.5))
# 0.5

Nëse specifikoni llojin e vargut str në vend të llojit float, ai do të trajtohet si tipi dhjetor i vlerës së saktë.

print(Decimal('0.05'))
# 0.05

Rrumbullakimi i numrave dhjetorë në çdo numër shifrash dhe rrumbullakimi në numra çift

Thirrni quantize() nga një objekt i tipit Decimal për të rrumbullakosur vlerën.

Argumenti i parë i quantize() është një varg me të njëjtin numër shifrash si numri i shifrave që dëshironi të gjeni, si ‘0,1’ ose ‘0,01’.

Për më tepër, argumenti ROUNDING specifikon mënyrën e rrumbullakosjes; nëse specifikohet ROUND_HALF_UP, përdoret rrumbullakimi i përgjithshëm.

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

Ndryshe nga funksioni i integruar round(), 0.5 rrumbullakohet në 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

Nëse rrumbullakimi i argumentit vendoset në ROUND_HALF_EVEN, rrumbullakimi kryhet në numra çift si në funksionin e integruar round().

Siç u përmend më lart, nëse një lloj float me pikë lundruese specifikohet si argumenti i Decimal(), ai trajtohet si një objekt dhjetor me një vlerë të barabartë me vlerën aktuale të llojit float, kështu që rezultati i përdorimit të quantize() metoda do të jetë e ndryshme nga ajo që pritet, ashtu si funksioni i integruar 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

Nëse argumenti i Decimal() specifikohet si një varg i tipit str, ai trajtohet si një objekt dhjetor me pikërisht atë vlerë, kështu që rezultati është ashtu siç pritej.

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

Meqenëse 0.5 mund të trajtohet saktë nga lloji float, nuk ka asnjë problem në përcaktimin e llojit float si argument i Decimal() kur rrumbullakoset në një numër të plotë, por është më e sigurt të specifikohet lloji i vargut str kur rrumbullakoset në një numër dhjetor.

Për shembull, 2.675 është në të vërtetë 2.67499…. në llojin float. Prandaj, nëse dëshironi të rrumbullakosni në dy shifra dhjetore, duhet të specifikoni një varg në Decimal(), përndryshe rezultati do të jetë i ndryshëm nga rezultati i pritur nëse rrumbullakoni në numrin më të afërt të plotë (ROUND_HALF_UP) ose në një numër çift (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

Vini re se metoda quantize() kthen një numër të tipit dhjetor, kështu që nëse dëshironi të operoni me një numër të tipit float, duhet ta konvertoni atë në një lloj float duke përdorur float(), përndryshe do të ndodhë një gabim.

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

Rrumbullakimi i numrave të plotë në çdo numër shifrash dhe rrumbullakimi në numra çift

Nëse dëshironi të rrumbullakosni në një shifër të plotë, duke specifikuar diçka si ’10’ si argument i parë nuk do t’ju japë rezultatin e dëshiruar.

i = 99518

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

Kjo ndodh sepse quantize() kryen rrumbullakim sipas eksponentit të objektit dhjetor, por eksponenti i Decimal(’10’) është 0, jo 1.

Ju mund të specifikoni një eksponent arbitrar duke përdorur E si një varg eksponenti (p.sh., ‘1E1’). Eksponenti i eksponentit mund të kontrollohet në metodën 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)

Siç është, rezultati do të jetë në shënimin eksponencial duke përdorur E. Nëse dëshironi të përdorni shënimin normal, ose nëse dëshironi të veproni me llojin int të plotë pas rrumbullakimit, përdorni int() për të kthyer rezultatin.

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

Nëse rrumbullakimi i argumentit vendoset në ROUND_HALF_UP, do të ndodhë rrumbullakimi i përgjithshëm, p.sh., 5 do të rrumbullakoset në 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

Sigurisht, nuk ka asnjë problem nëse e specifikoni atë si një varg.

Përcaktoni një funksion të ri

Metoda e përdorimit të modulit dhjetor është e saktë dhe e sigurt, por nëse nuk jeni të kënaqur me konvertimin e tipit, mund të përcaktoni një funksion të ri për të arritur rrumbullakimin e përgjithshëm.

Ka shumë mënyra të mundshme për ta bërë këtë, për shembull, funksioni i mëposhtëm.

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

Nëse nuk keni nevojë të specifikoni numrin e shifrave dhe gjithmonë të rrumbullakosni në shifrën e parë dhjetore, mund të përdorni një formë më të thjeshtë.

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

Nëse duhet të jeni të saktë, është më e sigurt të përdorni dhjetore.

Më poshtë është vetëm për referencë.

Rrumbullakosni numrat dhjetorë në çdo numër shifrash.

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

Ndryshe nga raundi, 0.5 bëhet 1 sipas rrumbullakimit të përgjithshëm.

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

Rrumbullakosni numrat e plotë në çdo numër shifrash

i = 99518

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

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

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

Ndryshe nga raundi, 5 bëhet 10 sipas rrumbullakimit të zakonshëm.

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

Shënim: Për vlerat negative

Në funksionin e shembullit të mësipërm, -0.5 rrumbullakoset në 0.

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

Ka mënyra të ndryshme për të menduar rreth rrumbullakimit për vlerat negative, por nëse doni të bëni -0,5 në -1, mund ta modifikoni si më poshtë, për shembull

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