Python ရှိ ဒဿမများနှင့် ကိန်းပြည့်များကို “ အဝိုင်း” နှင့် “ Decimal.quantize ဖြင့် အလုံးခြင်း

အောက်ပါတို့သည် Python တွင် နံပါတ်များကို အဝိုင်းပုံ (သို့) ကိန်းတစ်ခုသို့ အဝိုင်းလိုက်ပုံဖြင့် ရှင်းပြထားသည်။ ဂဏန်းများကို မျှော့ဖျော့ သို့မဟုတ် ကိန်းပြည့် int အမျိုးအစားဟု ယူဆပါသည်။

• built-in လုပ်ဆောင်ချက် (ဥပမာ ပရိုဂရမ်းမင်း ဘာသာစကား):round()
  • ဒဿမအဝိုင်းသည် မည်သည့်ဂဏန်းများအထိ၊
  • ကိန်းပြည့်ဂဏန်းမှန်သမျှသို့ အဝိုင်းကိန်းများ။
  • round() သည် ဘုံအလှည့်မဟုတ်သော ကိန်းတစ်ခုသို့ လှည့်သည်။
• စံစာကြည့်တိုက်decimalquantize()
  • Decimalအရာဝတ္ထုတစ်ခုဖန်တီးခြင်း။
  • ဒဿမများကို ဂဏန်းများ၏ မည်သည့် အရေအတွက်သို့ ပေါင်းကာ ဂဏန်းများအထိ အဝိုင်းလုပ်ခြင်း။
  • ကိန်းပြည့်များကို ဂဏန်းများ၏ မည်သည့်ဂဏန်းသို့ ပေါင်းကာ ကိန်းဂဏန်းများအထိ လှည့်ခြင်း။
• လုပ်ဆောင်ချက်အသစ်ကို သတ်မှတ်ပါ။
  • ဒဿမများကို မည်သည့်ဂဏန်းအရေအတွက်သို့မဆို ဖယ်ထုတ်ပါ။
  • ကိန်းပြည့်ဂဏန်းမှန်သမျှသို့ အဝိုင်းကိန်းများ
  • မှတ်ချက်- အနှုတ်တန်ဖိုးများအတွက်

အထက်တွင်ဖော်ပြထားသည့်အတိုင်း၊ built-in function round သည် ယေဘူယျအားဖြင့် လှည့်ခြင်းမဟုတ်သော်လည်း ကိန်းတစ်ခုသို့ အဝိုင်းလိုက်ခြင်းကို သတိပြုပါ။ အသေးစိတ်ကို အောက်တွင် ကြည့်ပါ။

built-in လုပ်ဆောင်ချက် (ဥပမာ ပရိုဂရမ်းမင်း ဘာသာစကား):round()

Round() ကို built-in လုပ်ဆောင်ချက်အဖြစ် ပံ့ပိုးထားသည်။ မည်သည့် module မှမတင်သွင်းဘဲအသုံးပြုနိုင်သည်။

• round() — Built-in Functions — Python 3.10.2 Documentation

ပထမအငြင်းအခုံသည် မူရင်းနံပါတ်ဖြစ်ပြီး ဒုတိယအငြင်းအခုံမှာ ဂဏန်းအရေအတွက် (ဂဏန်းမည်မျှပတ်ရန်)။

ဒဿမအဝိုင်းသည် မည်သည့်ဂဏန်းများအထိ၊

အောက်ဖော်ပြပါသည် Float-point float အမျိုးအစားအတွက် လုပ်ဆောင်ခြင်း၏ ဥပမာတစ်ခုဖြစ်သည်။

ဒုတိယအငြင်းအခုံကို ချန်လှပ်ထားလျှင် ၎င်းကို ကိန်းပြည့်အဖြစ် ဝိုင်းထားသည်။ အမျိုးအစားသည် ကိန်းပြည့် int အမျိုးအစား ဖြစ်လာသည်။

f = 123.456

print(round(f))
# 123

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

ဒုတိယအငြင်းအခုံကို သတ်မှတ်ထားပါက၊ ၎င်းသည် floating-point float အမျိုးအစားကို ပြန်ပေးသည်။

အပြုသဘော ကိန်းပြည့်ကို သတ်မှတ်ပါက၊ ဒဿမ နေရာကို သတ်မှတ်သည်။ အနုတ်ကိန်းပြည့်ကို သတ်မှတ်ပါက၊ ကိန်းပြည့်နေရာကို သတ်မှတ်သည်။ အနီးဆုံး ဒသမသို့ 1 ပတ်၊ အနီးဆုံး ရာဂဏန်းအထိ -2 ကျော့၊ နှင့် 0 အဝိုင်းသည် ကိန်းပြည့် (ပထမနေရာ) သို့ 0 ကျော့ခြင်းဖြစ်သော်လည်း ချန်လှပ်ထားသည့်အခါနှင့်မတူဘဲ float အမျိုးအစားကို ပြန်ပေးသည်။

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 တွင် built-in round() function ဖြင့် rounding ကို ယေဘူယျအားဖြင့် မဟုတ်ဘဲ ကိန်းဂဏန်းတစ်ခုသို့ လှည့်ခြင်းအား သတိပြုပါ။

တရားဝင်စာရွက်စာတမ်းတွင် ရေးထားသည့်အတိုင်း 0.5 ကို 0 သို့ ပတ်ပြီး၊ 5 သည် 0 သို့ စသည်တို့ဖြစ်သည်။

• round() — Built-in Functions — Python 3.10.2 Documentation

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

၎င်းမှာ တရားဝင်စာရွက်စာတမ်းများတွင်ဖော်ပြထားသည့်အတိုင်း ဒဿမများကို Floating Point နံပါတ်များအဖြစ် အတိအကျ ကိုယ်စားပြု၍မရနိုင်သောကြောင့်ဖြစ်သည်။

Floating အမှတ်များအတွက် round() ၏အပြုအမူသည် သင့်အား အံ့အားသင့်စေနိုင်ပါသည်။:ဥပမာအားဖြင့်၊ round(2.675၊ 2) သည် သင့်အား မျှော်လင့်ထားသည့်အတိုင်း 2.68 အစား 2.67 ပေးလိမ့်မည်။ ဒါဟာ bug မဟုတ်ပါ။:ဤသည်မှာ ဒဿမအများစုကို Floating Point နံပါတ်များဖြင့် အတိအကျ ကိုယ်စားပြု၍မရနိုင်သောကြောင့် ရလဒ်ဖြစ်သည်။
round() — Built-in Functions — Python 3.10.2 Documentation

ယေဘူယျအားဖြင့် ဒဿမများကို ကိန်းဂဏန်းများအထိ အတိအကျ ပေါင်းခြင်း သို့မဟုတ် တိကျသော ဒဿမများကို လုံးခြင်းအောင်မြင်လိုပါက၊ သင်သည် စံဒစ်ဂျစ်တိုက်၏ ဒဿမအရေအတွက် (အောက်တွင်ဖော်ပြထားသော) ကိုသုံးနိုင်သည် သို့မဟုတ် လုပ်ဆောင်ချက်အသစ်ကို သတ်မှတ်ပါ။

Python 2 တွင် round() သည် ကိန်းဂဏန်းတစ်ခုသို့ လှည့်ခြင်းမဟုတ်သော်လည်း အဝိုင်းဖြစ်ကြောင်းကိုလည်း သတိပြုပါ။

စံစာကြည့်တိုက် ဒဿမ၏ quantize()

စံဒစ်ဂျစ်တိုက်၏ ဒဿမ မော်ဂျူးကို အတိအကျ ဒဿမ ရေပေါ်အမှတ် နံပါတ်များကို ကိုင်တွယ်ရန် အသုံးပြုနိုင်သည်။

• decimal — Decimal fixed point and floating point arithmetic — Python 3.10.2 Documentation

ဒဿမ မော်ဂျူး၏ quantize() နည်းလမ်းကို အသုံးပြု၍ အဝိုင်းမုဒ်ကို သတ်မှတ်ခြင်းဖြင့် ဂဏန်းများကို ပတ်နိုင်သည်။

• decimal quantize() — Decimal fixed point and floating point arithmetic — Python 3.10.2 Documentation
• Rounding modes — Decimal fixed point and floating point arithmetic — Python 3.10.2 Documentation

quantize() method ၏ argument rounding အတွက် သတ်မှတ်တန်ဖိုးများသည် အောက်ပါ အဓိပ္ပါယ်များ အသီးသီးရှိသည်။

• ROUND_HALF_UP:အထွေထွေ ရှာနိုင်ပါတယ်။
• ROUND_HALF_EVEN:ကိန်းဂဏန်းများသို့ လှည့်ခြင်း။

ဒဿမ မော်ဂျူးသည် စံပြစာကြည့်တိုက်ဖြစ်သောကြောင့် ထပ်လောင်းထည့်သွင်းရန် မလိုအပ်သော်လည်း ထည့်သွင်းရန် လိုအပ်ပါသည်။

from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

Decimal object တစ်ခုကို ဖန်တီးခြင်း။

Decimal() အမျိုးအစား Decimal ၏ အရာဝတ္ထုများကို ဖန်တီးရန် အသုံးပြုနိုင်သည်။

အကယ်၍ သင်သည် float အမျိုးအစားကို အငြင်းအခုံတစ်ခုအဖြစ် သတ်မှတ်ပါက၊ မည်သည့်တန်ဖိုးကို အမှန်တကယ် သဘောထားသည်ကို သင်တွေ့မြင်နိုင်ပါသည်။

print(Decimal(0.05))
# 0.05000000000000000277555756156289135105907917022705078125

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

ဥပမာတွင် ပြထားသည့်အတိုင်း 0.05 ကို အတိအကျ 0.05 အဖြစ် မသတ်မှတ်ပါ။ ဤသည်မှာ အထက်တွင်ဖော်ပြထားသော Built-in လုပ်ဆောင်ချက် round() ကို ဥပမာရှိ ဒဿမတန်ဖိုးများအတွက် မျှော်လင့်ထားသည်ထက် မတူညီသောတန်ဖိုးသို့ ဝိုင်းစက်နေသည့် အကြောင်းရင်းဖြစ်သည်။

0.5 သည် တစ်ခြမ်း (-1 ၏ 2 ပါဝါ) ဖြစ်သောကြောင့်၊ ၎င်းကို ဒွိအမှတ်အသားဖြင့် အတိအကျဖော်ပြနိုင်သည်။

print(Decimal(0.5))
# 0.5

float အမျိုးအစားအစား string အမျိုးအစား str ကို သတ်မှတ်ပါက၊ ၎င်းကို အတိအကျတန်ဖိုး၏ 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

Built-in function 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() ကဲ့သို့ ကိန်းဂဏန်းများအထိ လှည့်ပတ်ခြင်းကို လုပ်ဆောင်သည်။

အထက်တွင်ဖော်ပြခဲ့သည့်အတိုင်း Float-Point float အမျိုးအစားကို Decimal() ၏ argument အဖြစ်သတ်မှတ်ပါက၊ ၎င်းကို float အမျိုးအစား၏ အမှန်တကယ်တန်ဖိုးနှင့်ညီမျှသောတန်ဖိုးဖြင့် Decimal object တစ်ခုအဖြစ် သတ်မှတ်သည်၊ ထို့ကြောင့် quantize() ကိုအသုံးပြုခြင်း၏ရလဒ်၊ built-in function round() ကဲ့သို့ပင် method သည် မျှော်လင့်ထားသည့်အရာနှင့် ကွဲပြားလိမ့်မည်။

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() ၏ argument ကို type str ၏ string တစ်ခုအဖြစ် သတ်မှတ်ပါက၊ ၎င်းကို အတိအကျတန်ဖိုး၏ Decimal object တစ်ခုအဖြစ် သတ်မှတ်သည်၊ ထို့ကြောင့် ရလဒ်သည် မျှော်လင့်ထားသည့်အတိုင်းဖြစ်သည်။

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 အမျိုးအစားဖြင့် မှန်ကန်စွာ ကိုင်တွယ်နိုင်သောကြောင့်၊ ကိန်းပြည့်သို့ လှည့်သည့်အခါ Decimal() ၏ argument အဖြစ် float အမျိုးအစားကို သတ်မှတ်ရာတွင် ပြဿနာမရှိသော်လည်း ဒဿမနေရာသို့ ပေါင်းသည့်အခါ string str အမျိုးအစားကို သတ်မှတ်ရန် ပိုလုံခြုံပါသည်။

ဥပမာအားဖြင့် 2.675 သည် float အမျိုးအစားတွင် အမှန်တကယ် 2.67499…. ဖြစ်သည်။ ထို့ကြောင့်၊ အကယ်၍ သင်သည် ဒဿမနေရာနှစ်ခုသို့ လှည့်လိုပါက၊ သင်သည် Decimal() သို့ စာကြောင်းတစ်ကြောင်းကို သတ်မှတ်ရမည်ဖြစ်ပြီး၊ သို့မဟုတ်ပါက သင်သည် အနီးဆုံးနံပါတ်တစ်ခုလုံး (ROUND_HALF_UP) သို့ လှည့်သည်ဖြစ်စေ ရလဒ်သည် မျှော်လင့်ထားသည့်ရလဒ်နှင့် ကွဲပြားလိမ့်မည် )

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 object ၏ ထပ်ညွှန်းအတိုင်း ဝိုင်းခြင်းကို လုပ်ဆောင်သောကြောင့်၊ သို့သော် 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

ကြိုးတစ်ချောင်းအဖြစ် သတ်မှတ်ပါက ပြဿနာမရှိပါ။

လုပ်ဆောင်ချက်အသစ်ကို သတ်မှတ်ပါ။

ဒဿမ မော်ဂျူးကို အသုံးပြုသည့်နည်းလမ်းသည် တိကျပြီး လုံခြုံသော်လည်း အမျိုးအစားပြောင်းခြင်းအတွက် အဆင်မပြေပါက၊ အထွေထွေအဝိုင်းကို အောင်မြင်စေရန် လုပ်ဆောင်ချက်အသစ်ကို သင်သတ်မှတ်နိုင်ပါသည်။

ဥပမာအားဖြင့် အောက်ပါလုပ်ဆောင်ချက်ကို ပြုလုပ်ရန် ဖြစ်နိုင်သော နည်းလမ်းများစွာရှိပါသည်။

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