बिजली का बिल

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

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

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

>>> -12
-12

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

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

अंकगणित

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

जोड़ और घटाव

जोड़ और घटाव के ऑपरेटर सामान्य गणित की तरह ही व्यवहार करते हैं। अगर ऑपरेंडों में से एक या अधिक 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 leftover
>>> 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

राउंड

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 * 64, then 2 + 192
>>> 2 + 3 * 4 ** 4
770

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

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

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

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