Python-da “round” və “Decimal.quantize” ilə onluq və tam ədədlərin yuvarlaqlaşdırılması

Biznes

Aşağıda Python-da ədədləri yuvarlaqlaşdırma və ya cüt ədədə yuvarlaqlaşdırma yolu izah edilir. Rəqəmlərin üzən nöqtəli float və ya tam int tipli olduğu güman edilir.

  • daxili funksiya (məsələn, proqramlaşdırma dilində):round()
    • Onluqları istənilən sayda rəqəmə yuvarlaqlaşdırın.
    • Tam ədədləri istənilən sayda rəqəmə yuvarlaqlaşdırın.
    • round() ümumi yuvarlaqlaşdırmaya deyil, cüt ədədə yuvarlaqlaşdırır
  • standart kitabxanadecimalquantize()
    • DecimalObyektin yaradılması
    • Onluqların istənilən sayda rəqəmə yuvarlaqlaşdırılması və cüt ədədlərə yuvarlaqlaşdırılması
    • Tam ədədlərin istənilən sayda rəqəmə yuvarlaqlaşdırılması və cüt ədədlərə yuvarlaqlaşdırılması
  • Yeni funksiyanı təyin edin
    • Onluqları istənilən sayda rəqəmə yuvarlaqlaşdırın.
    • Tam ədədləri istənilən sayda rəqəmə yuvarlaqlaşdırın
    • Qeyd: Mənfi dəyərlər üçün

Qeyd edək ki, yuxarıda qeyd edildiyi kimi, daxili funksiya dəyirmi ümumi yuvarlaqlaşdırma deyil, cüt ədədə yuvarlaqlaşdırmadır. Ətraflı məlumat üçün aşağıya baxın.

daxili funksiya (məsələn, proqramlaşdırma dilində):round()

Round() daxili funksiya kimi təqdim olunur. Heç bir modul idxal etmədən istifadə edilə bilər.

Birinci arqument orijinal nömrədir, ikinci arqument isə rəqəmlərin sayıdır (neçə rəqəmə yuvarlaqlaşdırılmalı).

Onluqları istənilən sayda rəqəmə yuvarlaqlaşdırın.

Aşağıda üzən nöqtəli float növü üçün emal nümunəsidir.

İkinci arqument buraxılıbsa, o, tam ədədə yuvarlaqlaşdırılır. Növ həm də tam ədəd int tipinə çevrilir.

f = 123.456

print(round(f))
# 123

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

İkinci arqument göstərilibsə, o, üzən nöqtəli float növünü qaytarır.

Müsbət tam ədəd göstərilibsə, ondalıq yer göstərilir; mənfi tam ədəd göstərilibsə, tam yer göstərilir. Ən yaxın ondalığa -1 dövrə, ən yaxın yüzliyə -2 dövrə və tam ədədə (birinci yerə) 0 dövrə, lakin buraxılmışdan fərqli olaraq float növünü qaytarır.

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

Tam ədədləri istənilən sayda rəqəmə yuvarlaqlaşdırın.

Aşağıda tam ədəd int növü üçün emal nümunəsidir.

İkinci arqument buraxılıbsa və ya 0 və ya müsbət tam ədəd göstərilibsə, orijinal dəyər olduğu kimi qaytarılır. Mənfi tam ədəd göstərilibsə, o, müvafiq tam rəqəmə yuvarlaqlaşdırılır. Hər iki halda tam ədəd int tipi qaytarılır.

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() ümumi yuvarlaqlaşdırmaya deyil, cüt ədədə yuvarlaqlaşdırır

Qeyd edək ki, Python-da daxili round() funksiyası ilə yuvarlaqlaşdırma ümumi yuvarlaqlaşdırmaya deyil, cüt nömrəyə 3 dövrə edir.

Rəsmi sənədlərdə yazıldığı kimi, 0,5 0-a yuvarlaqlaşdırılır, 5 0-a yuvarlaqlaşdırılır və s.

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

Cüt ədədə yuvarlaqlaşdırmanın tərifi aşağıdakı kimidir.

Əgər kəsr 0,5-dən azdırsa, onu aşağı yuvarlaqlaşdırın; kəsr 0,5-dən çox olarsa, yuvarlaqlaşdırın; kəsr tam olaraq 0,5 olarsa, aşağı yuvarlaqlaşdırma və yuxarı yuvarlaqlaşdırma arasındakı cüt ədədə qədər yuvarlaqlaşdırın.
Rounding – Wikipedia

0.5 həmişə kəsilmir.

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

Bəzi hallarda cüt ədədə yuvarlaqlaşdırmanın tərifi hətta iki onluqdan sonra işləməyə də aid edilmir.

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

Bu, rəsmi sənədlərdə göstərildiyi kimi onluqların tam olaraq üzən nöqtəli ədədlər kimi göstərilə bilməməsi ilə əlaqədardır.

Üzən nöqtəli ədədlər üçün round() funksiyasının davranışı sizi təəccübləndirə bilər:Məsələn, round(2.675, 2) sizə gözlənildiyi kimi 2.68 əvəzinə 2.67 verəcək. Bu səhv deyil.:Bu, əksər onluqların tam olaraq üzən nöqtəli ədədlərlə göstərilə bilməməsinin nəticəsidir.
round() — Built-in Functions — Python 3.10.2 Documentation

Əgər siz ümumi yuvarlaqlaşdırmaya və ya ondalıq hissələrin cüt ədədlərə dəqiq yuvarlaqlaşdırılmasına nail olmaq istəyirsinizsə, standart kitabxana onluq kvantlamasından (aşağıda təsvir edilmişdir) istifadə edə və ya yeni funksiya təyin edə bilərsiniz.

Onu da qeyd edək ki, Python 2-də round() cüt ədədə yuvarlaqlaşdırma deyil, yuvarlaqlaşdırmadır.

standart kitabxananın onluq hissəsinin quantize().

Standart kitabxananın onluq modulu dəqiq ondalıq üzən nöqtə nömrələrini idarə etmək üçün istifadə edilə bilər.

Onluq modulun quantize() metodundan istifadə edərək, yuvarlaqlaşdırma rejimini təyin etməklə ədədləri yuvarlaqlaşdırmaq mümkündür.

quantize() metodunun arqument yuvarlaqlaşdırılması üçün müəyyən edilmiş dəyərlər müvafiq olaraq aşağıdakı mənalara malikdir.

  • ROUND_HALF_UP:Ümumi yuvarlaqlaşdırma
  • ROUND_HALF_EVEN:Cüt ədədlərə yuvarlaqlaşdırma

Onluq modul standart kitabxanadır, ona görə də əlavə quraşdırma tələb olunmur, lakin idxal zəruridir.

from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

Ondalıq obyektin yaradılması

Decimal() Ondalıq tipli obyektlər yaratmaq üçün istifadə edilə bilər.

Arqument kimi float tipini təyin etsəniz, dəyərin əslində nə kimi qəbul edildiyini görə bilərsiniz.

print(Decimal(0.05))
# 0.05000000000000000277555756156289135105907917022705078125

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

Nümunədə göstərildiyi kimi, 0,05 tam olaraq 0,05 kimi qəbul edilmir. Yuxarıda təsvir edilən round() daxili funksiyasının misalda 0,05 daxil olmaqla, onluq dəyərlər üçün gözləniləndən fərqli bir dəyərə yuvarlaqlaşdırılmasının səbəbi budur.

0,5 bir yarım olduğundan (2-nin -1 gücü), onu tam olaraq ikili notasiya ilə ifadə etmək olar.

print(Decimal(0.5))
# 0.5

Əgər float növü əvəzinə str sətir tipini təyin etsəniz, o, dəqiq dəyərin Ondalıq növü kimi qəbul ediləcək.

print(Decimal('0.05'))
# 0.05

Onluqların istənilən sayda rəqəmə yuvarlaqlaşdırılması və cüt ədədlərə yuvarlaqlaşdırılması

Dəyəri yuvarlaqlaşdırmaq üçün Ondalıq tipli obyektdən quantize() çağırın.

quantize() funksiyasının birinci arqumenti tapmaq istədiyiniz rəqəmlərin sayı ilə eyni sayda rəqəmə malik sətirdir, məsələn, ‘0,1’ və ya ‘0,01’.

Bundan əlavə, ROUNDING arqumenti yuvarlaqlaşdırma rejimini təyin edir; ROUND_HALF_UP göstərilibsə, ümumi yuvarlaqlaşdırma istifadə olunur.

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

Daxili round() funksiyasından fərqli olaraq 0,5 1-ə yuvarlaqlaşdırılır.

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

Əgər arqumentin yuvarlaqlaşdırılması ROUND_HALF_EVEN olaraq təyin edilibsə, yuvarlaqlaşdırma daxili funksiya round()-da olduğu kimi cüt ədədlərə aparılır.

Yuxarıda qeyd edildiyi kimi, əgər üzən nöqtəli float növü Ondalıq() arqumenti kimi göstərilibsə, o, float növünün faktiki dəyərinə bərabər dəyəri olan Ondalıq obyekt kimi qəbul edilir, beləliklə quantize() funksiyasından istifadənin nəticəsi metodu gözləniləndən fərqli olacaq, eynilə daxili funksiya round() kimi.

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() arqumenti str tipli sətir kimi göstərilibsə, o, məhz həmin dəyərdə Ondalıq obyekti kimi qəbul edilir, beləliklə nəticə gözlənilən kimi olur.

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 növü ilə düzgün idarə oluna bildiyinə görə, tam ədədə yuvarlaqlaşdırılarkən float tipinin Ondalıq() arqumenti kimi göstərilməsində problem yoxdur, lakin onluq yerə yuvarlaqlaşdırarkən str sətirinin növünü təyin etmək daha təhlükəsizdir.

Məsələn, float tipində 2.675 əslində 2.67499….-dir. Buna görə də, iki onluq yerə yuvarlaqlaşdırmaq istəyirsinizsə, Ondalığa() sətir təyin etməlisiniz, əks halda nəticə gözlənilən nəticədən fərqli olacaq, istər ən yaxın tam ədədə (ROUND_HALF_UP), istərsə də cüt ədədə (ROUND_HALF_EVEN) yuvarlaqlaşdırın ).

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

Qeyd edək ki, quantize() metodu Ondalıq tipli nömrə qaytarır, ona görə də əgər siz float tipli nömrə ilə işləmək istəyirsinizsə, onu float() istifadə edərək float tipinə çevirməlisiniz, əks halda xəta baş verəcək.

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

Tam ədədlərin istənilən sayda rəqəmə yuvarlaqlaşdırılması və cüt ədədlərə yuvarlaqlaşdırılması

Əgər siz tam rəqəmə yuvarlaqlaşdırmaq istəyirsinizsə, ilk arqument kimi ’10’ kimi bir şey göstərmək sizə istədiyiniz nəticəni verməyəcək.

i = 99518

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

Bunun səbəbi, quantize() funksiyasının Ondalıq obyektinin eksponentinə uyğun yuvarlaqlaşdırma həyata keçirməsidir, lakin Ondalığın(’10’) eksponenti 1 deyil, 0-dır.

E-dən eksponent sətir kimi istifadə etməklə ixtiyari eksponent təyin edə bilərsiniz (məsələn, ‘1E1’). Eksponent göstəricisi as_tuple metodunda yoxlanıla bilər.

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)

Necə ki, nəticə E-dən istifadə edərək eksponensial notasiyada olacaq. Normal notasiyadan istifadə etmək istəyirsinizsə və ya yuvarlaqlaşdırmadan sonra tam ədəd int növü ilə işləmək istəyirsinizsə, nəticəni çevirmək üçün int() istifadə edin.

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

Arqumentin yuvarlaqlaşdırılması ROUND_ALF_UP olaraq təyin edilərsə, ümumi yuvarlaqlaşdırma baş verəcək, məsələn, 5 10-a yuvarlaqlaşdırılacaq.

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

Təbii ki, onu sətir kimi qeyd etsəniz, problem yoxdur.

Yeni funksiyanı təyin edin

Onluq moduldan istifadə üsulu dəqiq və təhlükəsizdir, lakin növün dəyişdirilməsi ilə rahat deyilsinizsə, ümumi yuvarlaqlaşdırmaya nail olmaq üçün yeni funksiya təyin edə bilərsiniz.

Bunu etmək üçün bir çox mümkün yol var, məsələn, aşağıdakı funksiya.

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

Rəqəmlərin sayını göstərməyə ehtiyac yoxdursa və həmişə birinci onluq yerə yuvarlaqlaşdırılırsa, daha sadə formadan istifadə edə bilərsiniz.

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

Dəqiq olmaq lazımdırsa, ondalık saydan istifadə etmək daha təhlükəsizdir.

Aşağıdakılar yalnız istinad üçündür.

Onluqları istənilən sayda rəqəmə yuvarlaqlaşdırın.

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

Dəyirmidən fərqli olaraq, ümumi yuvarlaqlaşdırmaya görə 0,5 1 olur.

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

Tam ədədləri istənilən sayda rəqəmə yuvarlaqlaşdırın

i = 99518

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

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

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

Dəyirmidən fərqli olaraq, ümumi yuvarlaqlaşdırmaya görə 5 10-a çevrilir.

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

Qeyd: Mənfi dəyərlər üçün

Yuxarıdakı misal funksiyada -0,5 0-a yuvarlaqlaşdırılıb.

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

Mənfi dəyərlər üçün yuvarlaqlaşdırma haqqında düşünməyin müxtəlif yolları var, lakin -0,5-i -1 etmək istəyirsinizsə, onu aşağıdakı kimi dəyişdirə bilərsiniz, məsələn

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