भिन्न में

भिन्न के बारे में

fractions मॉड्यूल की मदद से हम rational numbers बना सकते हैं और उनके साथ काम कर सकते हैं: ऐसी भिन्न जिनमें एक पूर्णांक अंश को एक पूर्णांक हर से विभाजित किया जाता है।

उदाहरण के लिए, हम 2/3 को अनुमानित float वैल्यू 0.6666... के बजाय एक सटीक भिन्न के रूप में रख सकते हैं।

भिन्न बनाना

int, float और complex संख्याओं के विपरीत, भिन्न का कोई लिटरल रूप नहीं होता। लेकिन भिन्न का कंस्ट्रक्टर काफी लचीला होता है।

सबसे स्पष्ट तरीका यह है कि इसे दो पूर्णांक दिए जा सकते हैं। सामान्य गुणनखंड अपने आप हट जाते हैं, जिससे भिन्न अपने "सरलतम रूप" में आ जाता है (वे सबसे छोटे पूर्णांक जो भिन्न को सटीक रूप से दर्शाते हैं):

>>> from fractions import Fraction

>>> f1 = Fraction(2, 3) # 2/3
>>> f1
Fraction(2, 3)

>>> f2 = Fraction(6, 9)
>>> f2
Fraction(2, 3)  # automatically simplified

>>> f1 == f2
True

भिन्न का कंस्ट्रक्टर स्ट्रिंग के रूप में दिए गए मान को भी पढ़ सकता है:

>>> f3 = Fraction('2/3')
>>> f3
Fraction(2, 3)

यह float पैरामीटर के साथ भी काम कर सकता है, लेकिन दशमलव वैल्यू को भीतर से बाइनरी के रूप में दर्शाना अनुमानित होता है, जिससे समस्याएँ आ सकती हैं। इस दर्शाव से जुड़ी समस्या के बारे में अधिक जानने के लिए 0.30000000000000004 वेबसाइट देखिए, और Python के डॉक्युमेंटेशन में फ्लोटिंग पॉइंट अंकगणित: समस्याएँ और सीमाएँ देखिए।

भिन्न के साथ दशमलव संख्याएँ इस्तेमाल करते समय ज़्यादा भरोसेमंद नतीजा पाने के लिए <fraction>.limit_denominator() मेथड मौजूद है।

अगर आपकी कोई खास ज़रूरतें हों तो .limit_denominator() एक पूर्णांक पैरामीटर ले सकता है, लेकिन डिफॉल्ट मान (max_denominator=1000000) भी अच्छी तरह काम करता है और एक स्वीकार्य, सरल अनुमान देता है।

>>> Fraction(1.2)
Fraction(5404319552844595, 4503599627370496)

>>> Fraction(1.2).limit_denominator()
Fraction(6, 5)

भिन्नों के साथ अंकगणित

आमतौर पर इस्तेमाल होने वाले arithmetic operators + - * / ** भी दूसरे संख्यात्मक टाइप की तरह भिन्नों के साथ काम करते हैं।

पूर्णांक और दूसरे Fraction भी शामिल किए जा सकते हैं, और परिणाम एक Fraction ही मिलता है। एक्सप्रेशन में float शामिल करने पर float आउटपुट मिलता है, जिससे सटीकता में (संभावित) कमी आ सकती है।

>>> Fraction(2, 3) + Fraction(1, 4) # addition
Fraction(11, 12)

>>> Fraction(2, 3) * Fraction(6, 5) # multiply fractions
Fraction(4, 5)

>>> Fraction(2, 3) * 6 / 5 # fraction with integers
Fraction(4, 5)

>>> Fraction(2, 3) * 1.2  # fraction with float -> float
0.7999999999999999

>>> Fraction(2, 3) ** 2  # exponentiation with integer
Fraction(4, 9)

भिन्न में और भिन्न से रूपांतरण

बीच की गणनाओं में सटीकता बनाए रखने के लिए भिन्न बहुत काम के हैं, लेकिन अंतिम आउटपुट के रूप में शायद आप उन्हें नहीं चाहेंगे।

अंश और हर को अलग-अलग या एक टपल के रूप में प्राप्त किया जा सकता है (tuples पर आगे किसी कॉन्सेप्ट में चर्चा की जाएगी):

>>> Fraction(2, 3).numerator
2
>>> Fraction(2, 3).denominator
3
>>> Fraction(2, 3).as_integer_ratio()
(2, 3)

Python के कई मानक संख्यात्मक फंक्शन भी वही परिणाम देते हैं जो आप int और float टाइप के साथ काम करते समय उम्मीद करेंगे:

>>> round(Fraction(11, 3))
4

>>> from math import floor, ceil
>>> floor(Fraction(11, 3))
3
>>> ceil(Fraction(11, 3))
4

>>> float(Fraction(11, 3))
3.6666666666666665