संख्याएँ में

संख्याएँ के बारे में

Python में बिल्ट-इन संख्याओं के तीन अलग-अलग प्रकार होते हैं: पूर्णांक (int), दशमलव संख्या (float) और कॉम्प्लेक्स (complex)। भिन्न (fractions.Fraction) और डेसिमल (decimal.Decimal) भी स्टैंडर्ड लाइब्रेरी से इम्पोर्ट करके इस्तेमाल किए जा सकते हैं।

दशमलव स्थानों के बिना आने वाली पूर्ण संख्याएँ, जिनमें हेक्साडेसिमल (hex()), ऑक्टल (oct()) और बाइनरी (bin()) संख्याएँ भी शामिल हैं, भी ints मानी जाती हैं:

# Ints are whole numbers.
>>> 1234
1234
>>> type(1234)
<class 'int'>

>>> -12
-12

जिन संख्याओं में दशमलव बिंदु होता है (भिन्नात्मक भाग हों या न हों), वे floats मानी जाती हैं:

>>> 3.45
3.45
>>> type(3.45)
<class 'float'>

अंकगणित

Python इन अलग-अलग संख्या प्रकारों के बीच अंकगणित का पूरी तरह समर्थन करता है। जब इन्हें बाइनरी अंकगणितीय ऑपरेटरों (+, -, *, /, // और %) के साथ इस्तेमाल किया जाता है, तो यह कम दायरे वाले प्रकार की संख्याओं को उससे अधिक दायरे वाले प्रकार की संख्याओं के अनुरूप बदल देता है।

कॉम्प्लेक्स को छोड़कर सभी संख्याएँ सभी अंकगणितीय संक्रियाओं का समर्थन करती हैं, जिनका मूल्यांकन ऑपरेटरों की प्राथमिकता के अनुसार होता है। कॉम्प्लेक्स संख्याओं के लिए गणितीय फंक्शनों का समर्थन (+ और - से आगे) cmath मॉड्यूल में मिलता है।

जोड़ और घटाव

जोड़ और घटाव के ऑपरेटर सामान्य गणित की तरह ही काम करते हैं। अगर एक या अधिक ऑपरेंड float हों, तो बाकी int भी float में बदल दिए जाते हैं:

>>> 5 - 3
2
# The int is widened to a float here, and a float is returned.
>>> 3 + 4.0
7.0

गुणा

जोड़ और घटाव की तरह ही, गुणा भी कम दायरे वाली संख्याओं को उससे अधिक दायरे वाली संख्याओं के अनुरूप बदल देता है:

>>> 3 * 2
6

>>> 3 * 2.0
6.0

भाग

भाग का परिणाम हमेशा एक float होता है, भले ही नतीजा पूर्ण संख्या हो:

>>> 6/5
1.2

>>> 6/2
3.0

फ्लोर डिवीज़न

अगर int परिणाम चाहिए, तो आप नतीजे को छोटा करने के लिए फ्लोर डिवीज़न इस्तेमाल कर सकते हैं। फ्लोर डिवीज़न // ऑपरेटर से किया जाता है:

>>> 6//5
1

>>> 6//2
3

मॉड्यूलो

मॉड्यूलो ऑपरेटर (%) दोनों ऑपरेंडों के भाग का शेषफल लौटाता है:

# The result of % is zero here, because dividing 8 by 2 leaves no remainder
>>> 8 % 2
0

# The result of % is 2 here, because 3 only goes into 5 once, with 2 left over
>>> 5 % 3
2

5 % 3 को देखने का एक और तरीका:

>>> whole_part = int(5/3)
1

>>> decimal_part = 5/3 - whole_part
0.6666666666666667

>>> whole_remainder = decimal_part * 3
2.0

घातांक

घातांक निकालने के लिए ** ऑपरेटर इस्तेमाल होता है:

>>> 2 ** 3
8

>>> 4 ** 0.5
2

रूपांतरण

बिल्ट-इन फंक्शन int() और float() की मदद से संख्याओं को int से floats में और floats से int में बदला जा सकता है:

>>> int(3.45)
3

>>> float(3)
3.0

राउंड

Python में एक बिल्ट-इन फंक्शन round(<number>, <decimal_places>) है, जो किसी दशमलव संख्या को दिए गए दशमलव स्थानों तक राउंड कर देता है। अगर दशमलव स्थानों की संख्या न बताई जाए, तो संख्या को निकटतम पूर्णांक तक राउंड किया जाता है और यह एक int लौटाता है:

>>> round(3.1415926535, 2)
3.14

>>> round(3.1415926535)
3

प्राथमिकता और कोष्ठक

Python में आप कोष्ठक का इस्तेमाल करके एक्सप्रेशनों को समूहों में बाँध सकते हैं। यह तब काम आता है जब आप ऑपरेशनों का डिफॉल्ट क्रम बदलना चाहें।

>>> 2 + 3 * 4
14

>>> (2 + 3) * 4
20

ऑपरेटरों की प्राथमिकता के लिए Python PEMDAS नियम का पालन करता है। इसका मतलब है कि () के अंदर की गणनाओं की प्राथमिकता सबसे ऊँची होती है, उसके बाद **, फिर *, /, //, %, + और - आते हैं:

>>> 2 + 3 - 4 * 4
-11

>>> (2 + 3 - 4) * 4
4

# In the following example, the `**` operator has the highest priority, then `*`, then `+`
# Meaning we first do 4 ** 4, then 3 * 256, then 2 + 768
>>> 2 + 3 * 4 ** 4
770

परिशुद्धता और निरूपण

Python में पूर्णांकों की मनमानी परिशुद्धता होती है। इनमें अंकों की संख्या सिर्फ होस्ट सिस्टम की उपलब्ध मेमोरी से सीमित होती है।

दशमलव संख्याएँ आम तौर पर C में double से बनाई जाती हैं (15 दशमलव स्थानों तक परिशुद्धता), लेकिन इनका निरूपण होस्ट सिस्टम के हिसाब से बदलता रहता है। कॉम्प्लेक्स संख्याओं में एक real और एक imaginary भाग होता है, और दोनों को दशमलव संख्याओं से दर्शाया जाता है।

प्रोग्रामिंग भाषाओं में दशमलव संख्याओं के अंकगणित की समस्याओं और सीमाओं पर अधिक विस्तृत चर्चा के लिए 0.30000000000000004.com और Python ट्यूटोरियल देखिए।