භාග සමඟ භාග (තාර්කීය සංඛ්‍යා) ගණනය කිරීම

ව්යාපාරික

සම්මත පයිතන් පුස්තකාලයේ භාග මොඩියුලය භාවිතා කරමින්, ඔබට භාග (තාර්කීය සංඛ්‍යා) සමඟ ගණනය කිරීම් සිදු කළ හැකිය.

මෙහි පහත විස්තර කෙරේ.

  • භාගයේ ඉදිකිරීම්කරු
  • සංඛ්‍යා සහ හර අගයන් පූර්ණ සංඛ්‍යා ලෙස ලබා ගන්න
  • භාග ගණනය කිරීම සහ සංසන්දනය කිරීම (තාර්කීය සංඛ්‍යා)
  • භාග දශම බවට පරිවර්තනය කිරීම (පාවෙන)
  • කොටස තන්තුවට (str) පරිවර්තනය
  • තාර්කික සංඛ්‍යා ආසන්නකරණය ලබා ගන්න

භාගයේ ඉදිකිරීම්කරු

භාග අවස්ථාවක් නිර්මාණය කිරීමට ක්‍රම කිහිපයක් තිබේ. සෑම අවස්ථාවකදීම, භාගය ස්වයංක්රීයව කොටස් වලට බෙදී ඇත.

සංඛ්‍යා සහ හරය පූර්ණ සංඛ්‍යා ලෙස සඳහන් කරන්න

අංක සහ හරය පිළිවෙළින් පූර්ණ සංඛ්‍යා ලෙස සඳහන් කරන්න. හරය ඉවත් කර ඇත්නම්, එය 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() ක්‍රමය භාවිතා කරන්න.

අක්ෂර මාලාව(str)

තන්තු අගයක් සම්මත කළහොත්, එය භාගයකට පරිවර්තනය වේ.

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

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

සංඛ්‍යා සහ හර අගයන් පූර්ණ සංඛ්‍යා ලෙස ලබා ගන්න

භාග වර්ගයේ ගුණාංග ඔබට පිළිවෙලින් අංකනය සහ හරය සඳහා පූර්ණ සංඛ්‍යා අගයන් ලබා ගැනීමට ඉඩ සලසයි. ඒවා වෙනස් කරන්න බැහැ.

  • 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() සමඟ භාග සිට දශම දක්වා පරිවර්තනය කළ හැක.

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

දශම සංඛ්‍යාවකින් ගණනය කළ විට එය ස්වයංක්‍රීයව පාවෙන වර්ගයකට පරිවර්තනය වේ.

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

කොටස තන්තුවට (str) පරිවර්තනය

තන්තුවකට පරිවර්තනය කිරීමට, str() භාවිතා කරන්න.

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

තාර්කික සංඛ්‍යා ආසන්නකරණය ලබා ගන්න

භාග වර්ගයෙහි limit_denominator() ක්‍රමය සමඟ තාර්කික සංඛ්‍යා ආසන්න කිරීමක් ලබා ගත හැක.

හරය max_denominator තර්කයට වඩා අඩු හෝ සමාන වන තාර්කික අංකය (භාගය) ලබා දෙයි. ඉවත් කර ඇත්නම්, max_denominator=1000000.

පයි සහ නේපියර් අංකය 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