အပိုင်းကိန်းများ (ဆင်ခြင်တုံတရားကိန်းဂဏန်းများ) ကို အပိုင်းကိန်းများဖြင့် တွက်ချက်ခြင်း။

စံ Python ဒစ်ဂျစ်တိုက်၏ အပိုင်းကိန်းအပိုင်းများကို အသုံးပြု၍ အပိုင်းကိန်းများ (ဆင်ခြင်တုံတရား ကိန်းဂဏာန်းများ) ဖြင့် တွက်ချက်မှုများ လုပ်ဆောင်နိုင်သည်။

• fractions — Rational numbers — Python 3.10.2 Documentation

အောက်ပါတို့ကို ဤနေရာတွင် ရှင်းပြထားပါသည်။

• အပိုင်းအစများကို တည်ဆောက်သူ
• ပိုင်းဝေနှင့် ပိုင်းခြေတန်ဖိုးများကို ကိန်းပြည့်များအဖြစ် ရယူပါ။
• အပိုင်းကိန်းများကို တွက်ချက်ခြင်းနှင့် နှိုင်းယှဉ်ခြင်း (ဆင်ခြင်တုံတရားကိန်းဂဏန်းများ)
• အပိုင်းကိန်းများကို ဒဿမများ (float) သို့ ပြောင်းလဲခြင်း
• Fraction မှ string (str) သို့ ပြောင်းလဲခြင်း။
• ဆင်ခြင်တုံတရားကိန်းဂဏန်း အနီးစပ်ဆုံးကို ရယူပါ။

အပိုင်းအစများကို တည်ဆောက်သူ

Fraction instance တစ်ခုကို ဖန်တီးရန် နည်းလမ်းများစွာ ရှိပါသည်။ ကိစ္စရပ်တိုင်းတွင် အပိုင်းကိန်းကို အပိုင်းကိန်းများအဖြစ် အလိုအလျောက် ပိုင်းခြားပါသည်။

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

ပိုင်းဝေနှင့် ပိုင်းခြေကို ကိန်းပြည့်များအဖြစ် သတ်မှတ်ပါ။ ပိုင်းခြေကို ချန်လှပ်ထားလျှင် 1 ဟု ယူဆသည်။

from fractions import Fraction

print(Fraction(1, 3))
# 1/3

print(Fraction(2, 6))
# 1/3

print(Fraction(3))
# 3

ဒဿမအပိုင်း(float)

အပိုင်းကိန်းတန်ဖိုးကို ကျော်သွားပါက၊ ၎င်းကို အပိုင်းကိန်းတစ်ခုအဖြစ်သို့ ပြောင်းလဲသည်။

print(Fraction(0.25))
# 1/4

print(Fraction(0.33))
# 5944751508129055/18014398509481984

အများဆုံး ပိုင်းခြေကို သတ်မှတ်ခြင်းဖြင့် အနီးစပ်ဆုံး သိချင်ပါက၊ အောက်တွင်ဖော်ပြထားသော limit_denominator() နည်းလမ်းကို အသုံးပြုပါ။

ဇာတ်ကောင် string(str)

စာကြောင်းတန်ဖိုးကို ကျော်သွားပါက၊ ၎င်းကို အပိုင်းကိန်းတစ်ခုအဖြစ်သို့ ပြောင်းသည်။

print(Fraction('2/5'))
# 2/5

print(Fraction('16/48'))
# 1/3

ပိုင်းဝေနှင့် ပိုင်းခြေတန်ဖိုးများကို ကိန်းပြည့်များအဖြစ် ရယူပါ။

Fraction အမျိုးအစား၏ အရည်အချင်းများသည် သင့်အား ပိုင်းဝေနှင့် ပိုင်းခြေအတွက် ကိန်းပြည့်တန်ဖိုးများကို အသီးသီးရရှိစေသည်။ ပြောင်းလဲလို့မရပါဘူး။

• numerator
• denominator

a = Fraction(1, 3)
print(a)
# 1/3

print(a.numerator)
print(type(a.numerator))
# 1
# <class 'int'>

print(a.denominator)
print(type(a.denominator))
# 3
# <class 'int'>

# a.numerator = 7
# AttributeError: can't set attribute

အပိုင်းကိန်းများကို တွက်ချက်ခြင်းနှင့် နှိုင်းယှဉ်ခြင်း (ဆင်ခြင်တုံတရားကိန်းဂဏန်းများ)

ဂဏန်းသင်္ချာ အော်ပရေတာများကို ပေါင်းခြင်း၊ နုတ်ခြင်း စသည်တို့ကို တွက်ချက်ရန် အသုံးပြုနိုင်သည်။

result = Fraction(1, 6) ** 2 + Fraction(1, 3) / Fraction(1, 2)
print(result)
print(type(result))
# 25/36
# <class 'fractions.Fraction'>

နှိုင်းယှဉ်အော်ပရေတာများကိုလည်း အသုံးပြုနိုင်သည်။

print(Fraction(7, 13) > Fraction(8, 15))
# True

အပိုင်းကိန်းများကို ဒဿမများ (float) သို့ ပြောင်းလဲခြင်း

float() ဖြင့် အပိုင်းကိန်းများမှ ဒဿမများသို့ ပြောင်းလဲနိုင်သည်။

a_f = float(a)
print(a_f)
print(type(a_f))
# 0.3333333333333333
# <class 'float'>

ဒဿမ နံပါတ်ဖြင့် တွက်ချက်သောအခါ၊ ၎င်းကို float အမျိုးအစားသို့ အလိုအလျောက် ပြောင်းသည်။

b = a + 0.1
print(b)
print(type(b))
# 0.43333333333333335
# <class 'float'>

Fraction မှ string (str) သို့ ပြောင်းလဲခြင်း။

စာကြောင်းတစ်ခုသို့ပြောင်းရန်၊ str() ကိုသုံးပါ။

a_s = str(a)
print(a_s)
print(type(a_s))
# 1/3
# <class 'str'>

ဆင်ခြင်တုံတရားကိန်းဂဏန်း အနီးစပ်ဆုံးကို ရယူပါ။

Fraction အမျိုးအစား၏ method limit_denominator() ဖြင့် ကျိုးကြောင်းဆီလျော်သော ဂဏန်းအနီးစပ်ဆုံးကို ရနိုင်သည်။

ပိုင်းခြေသည် အငြင်းကိန်း max_denominator ထက်နည်းသော သို့မဟုတ် ညီမျှသည့် ဆင်ခြင်တုံတရားနံပါတ် (အပိုင်း) ကို ပြန်ပေးသည်။ ချန်လှပ်ထားလျှင် max_denominator=1000000။

pi နှင့် Napier နံပါတ် e ကဲ့သို့သော အနီးစပ်ဆုံး အသုံးမကျသောဂဏန်းများ

pi = Fraction(3.14159265359)
print(pi)
# 3537118876014453/1125899906842624

print(pi.limit_denominator(10))
print(pi.limit_denominator(100))
print(pi.limit_denominator(1000))
# 22/7
# 311/99
# 355/113

e = Fraction(2.71828182846)
print(e)
# 6121026514870223/2251799813685248

print(e.limit_denominator(10))
print(e.limit_denominator(100))
print(e.limit_denominator(1000))
# 19/7
# 193/71
# 1457/536

စက်ဝိုင်းပုံ ဒဿမများကို အပိုင်းကိန်းများအဖြစ် ပြောင်းပါ။

a = Fraction(0.565656565656)
print(a)
# 636872674577009/1125899906842624

print(a.limit_denominator())
# 56/99

a = Fraction(0.3333)
print(a)
# 6004199023210345/18014398509481984

print(a.limit_denominator())
print(a.limit_denominator(100))
# 3333/10000
# 1/3