భిన్నాలతో కంప్యూటింగ్ భిన్నాలు (హేతుబద్ధ సంఖ్యలు).

ప్రామాణిక పైథాన్ లైబ్రరీ యొక్క భిన్నాల మాడ్యూల్‌ని ఉపయోగించి, మీరు భిన్నాలతో (హేతుబద్ధ సంఖ్యలు) గణనలను చేయవచ్చు.

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

హేతుబద్ధ సంఖ్య ఉజ్జాయింపుని పొందండి

భిన్నం రకం యొక్క పరిమితి_డినామినేటర్() పద్ధతితో హేతుబద్ధ సంఖ్య ఉజ్జాయింపును పొందవచ్చు.

ఆర్గ్యుమెంట్ max_denominator కంటే తక్కువ లేదా సమానమైన హారం ఉన్న హేతుబద్ధ సంఖ్య (భిన్నం)ని అందిస్తుంది. విస్మరించబడితే, max_denominator=1000000.

పై మరియు నేపియర్ సంఖ్య ఇ వంటి ఉజ్జాయింపు అకరణీయ సంఖ్యలు

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