અપૂર્ણાંક સાથે અપૂર્ણાંક (તર્કસંગત સંખ્યાઓ) ની ગણતરી

પ્રમાણભૂત પાયથોન લાઇબ્રેરીના અપૂર્ણાંક મોડ્યુલનો ઉપયોગ કરીને, તમે અપૂર્ણાંક (તર્કસંગત સંખ્યાઓ) સાથે ગણતરીઓ કરી શકો છો.

• fractions — Rational numbers — Python 3.10.2 Documentation

નીચે મુજબ અહીં સમજાવ્યું છે.

• અપૂર્ણાંકનો કન્સ્ટ્રક્ટર
• પૂર્ણાંક તરીકે અંશ અને છેદ મૂલ્યો મેળવો
• અપૂર્ણાંકની ગણતરી અને સરખામણી (તર્કસંગત સંખ્યાઓ)
• અપૂર્ણાંકને દશાંશમાં રૂપાંતરિત કરવું (ફ્લોટ)
• અપૂર્ણાંક થી સ્ટ્રિંગ (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

અપૂર્ણાંકને દશાંશમાં રૂપાંતરિત કરવું (ફ્લોટ)

ફ્લોટ() વડે અપૂર્ણાંકમાંથી દશાંશમાં કન્વર્ટ કરી શકાય છે.

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.

અંદાજિત અતાર્કિક સંખ્યાઓ જેમ કે pi અને નેપિયર નંબર 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