Python operators: गणित, // और %, तुलना, and/or/not और python round

Python के operators वे चिह्न हैं जो values से नई values बनाते हैं: + जोड़ता है, // पूरा भाग निकालता है, and शर्तें जोड़ता है। नीचे सभी operators उदाहरणों के साथ हैं, / और // का अंतर, and, or, not का तर्क, और rounding के functions: python round, math.ceil, math.floor और abs। सारे उदाहरण REPL में डालकर जाँचे जा सकते हैं।

Python operators की सूची

Operators उनके काम के हिसाब से समूहों में बँटे हैं। पूरी तालिका याद रखना ज़रूरी नहीं: असली code में सबसे ज़्यादा गणित, तुलना और logical जोड़ने वाले operators दिखते हैं।

Arithmetic operators (गणितीय operators)

जोड़, घटाव और गुणा वैसे ही काम करते हैं जैसे स्कूल में। अगर expression में कम से कम एक float हो, तो नतीजा भी float होगा: 2 + 1.0 देता है 3.0। Python में integers overflow नहीं होते — 2 ** 100 सटीक निकलता है, चाहे कितने भी अंक बनें।

>>> 250 + 120
370
>>> 12.5 * 3
37.5
>>> 2 ** 10
1024
>>> 2 ** 0.5
1.4142135623730951

Python में घात: ** operator

घात के लिए दो तारे लगते हैं, ^ नहीं: Python में ^ का मतलब bitwise “exclusive OR” है, और 2 ^ 3 का नतीजा 1 होगा, 8 नहीं। भिन्नात्मक घात से जड़ निकलती है: 9 ** 0.5 का नतीजा 3.0। एक function pow(x, y) भी है — वही काम, साथ में तीसरा argument शेषफल के लिए: pow(2, 10, 1000) का नतीजा 24 होगा।

प्राथमिकता का ध्यान रखें: ** unary minus से पहले चलता है, इसलिए -2 ** 2 का नतीजा -4 है। ऋणात्मक संख्या का वर्ग चाहिए तो कोष्ठक लगाएँ: (-2) ** 2।

Python में भाग: /, // और %

Python में भाग के दो तरीके हैं, और नए लोगों के लिए यही सबसे बड़ी हैरानी का स्रोत है। सामान्य भाग / हमेशा float लौटाता है, भले ही भाग पूरा हो। Integer भाग // दशमलव भाग हटा देता है, और % शेषफल देता है।

>>> 7 / 2
3.5
>>> 8 / 2
4.0
>>> 7 // 2
3
>>> 7 % 2
1

Integer भाग // और शेषफल %: व्यवहार में

// और % की जोड़ी “कितने पूरे और कितना बचा” वाले सवाल हल करती है। कोर्स में खर्च ट्रैकर सटीकता खोए बिना पैसे पैसों (paise) में रखता है, और रक़म को रुपये और पैसे में बाँटता है:

paise = 125050            # पैसे में रखते हैं
rupees = paise // 100     # 1250 — पूरे रुपये
paisa = paise % 100       # 50 — शेषफल
print(rupees, paisa)      # 1250 50

print(40 // 7, "हफ़्ते और", 40 % 7, "दिन")   # 5 हफ़्ते और 5 दिन

दोनों ऑपरेशन एक साथ divmod function देता है: divmod(125050, 100) एक tuple (1250, 50) लौटाता है। शेषफल सम-विषम जाँचने के लिए भी काम आता है: n % 2 == 0 सम संख्याओं के लिए सच है।

ऋणात्मक संख्याएँ: // नीचे की ओर गोल करता है

// सिर्फ़ दशमलव नहीं हटाता, बल्कि नीचे, माइनस अनंत की ओर गोल करता है। धनात्मक संख्याओं में फ़र्क नहीं दिखता, ऋणात्मक में दिखता है। Python में % के शेषफल का चिह्न भाजक के चिह्न जैसा होता है, इसलिए हमेशा a == (a // b) * b + a % b सच रहता है।

>>> -7 // 2
-4
>>> -7 % 2
1
>>> int(-7 / 2)     # दशमलव हटाना, नीचे गोल करना नहीं
-3

शून्य से भाग: कौन सी त्रुटि आती है

तीनों में से किसी भी operator से शून्य से भाग करने पर ZeroDivisionError आता है। यह पूर्णांक और दशमलव, दोनों पर लागू होता है। इसे try/except से पकड़ा जा सकता है, या पहले से भाजक जाँचा जा सकता है।

>>> 10 / 0
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
>>> count = 0
>>> avg = 1500 / count if count else 0
>>> avg
0

Comparison operators (तुलना के operators)

तुलना True या False लौटाती है। बराबर जाँचने के लिए दो चिह्न == लिखे जाते हैं, एक = असाइनमेंट है। Strings अक्षर-कोड के हिसाब से एक-एक करके तुलना होती हैं, इसलिए "B" < "a" सच है: बड़े अक्षर छोटे अक्षरों से पहले आते हैं।

>>> 250 == 250.0
True
>>> 3 != 4
True
>>> 1 < 5 <= 10     # चेन: 1 < 5 and 5 <= 10
True
>>> 0.1 + 0.2 == 0.3
False

तुलना की चेन जैसे 0 <= x < 100 Python की सुविधा है: and लिखने की ज़रूरत नहीं। आख़िरी उदाहरण दशमलव संख्याओं की त्रुटि याद दिलाता है: 0.1 + 0.2 देता है 0.30000000000000004। दशमलव संख्याओं की तुलना math.isclose(a, b) से करें, और पैसे पैसों में या Decimal में रखें।

Logical operators: and, or, not

Python में logical operators चिह्नों && और || की जगह शब्दों में लिखे जाते हैं। and तब सच है जब दोनों भाग सच हों, or तब जब कम से कम एक सच हो, और not मान को उलट देता है।

प्राथमिकता: पहले not, फिर and, फिर or। Expression True or False and False का नतीजा True है, क्योंकि and पहले गिना जाता है। जटिल शर्तों में कोष्ठक लगाएँ — इससे आपको और साथियों को, दोनों को, बात साफ़ रहती है।

and और or असल में क्या लौटाते हैं

and और or ज़रूरी नहीं कि True या False लौटाएँ; वे किसी एक operand को लौटाते हैं। or पहला सच मान देता है (या कोई सच न हो तो आख़िरी), and पहला झूठा मान (या आख़िरी)। झूठे माने जाते हैं: 0, 0.0, खाली string, खाली collections, None और False।

>>> name = ""
>>> name or "मेहमान"
'मेहमान'
>>> 5 and 0
0
>>> not ""
True

मूल्यांकन आलसी (lazy) है: अगर बाईं ओर से नतीजा साफ़ हो जाए, तो दाईं ओर नहीं चलता। इसलिए count and total / count count == 0 पर शून्य-से-भाग से नहीं गिरता। not बाकी दो से अलग है: वह हमेशा bool लौटाता है।

is और in operators

== values की तुलना करता है, जबकि is जाँचता है कि दो नाम एक ही object की ओर इशारा करते हैं। दो अलग खाली टोकरियाँ बराबर हो सकती हैं, पर वे एक object नहीं हैं। is की ज़रूरत लगभग एक ही जगह रोज़ पड़ती है — None की जाँच: if x is None।

>>> a = [250, 120]
>>> b = [250, 120]
>>> a == b, a is b
(True, False)
>>> c = a
>>> c is a
True

Numbers और strings को is से न तोलें: कभी-कभी आंतरिक caching की वजह से यह “काम” करता है, पर नतीजा implementation पर निर्भर है, और Python x is 5 जैसे निर्माण पर SyntaxWarning देता है।

in operator सदस्यता जाँचता है: string में substring, list में element, dictionary में key। not in उसका उलटा है।

>>> "कॉफ़ी" in "कॉफ़ी साथ ले जाने के लिए"
True
>>> "खाना" in {"खाना": 450, "टैक्सी": 300}
True
>>> 5 not in [1, 2, 3]
True

Assignment operators और walrus operator :=

संयुक्त operators +=, -=, *=, //= और बाकी छोटे रूप हैं: total += 250 का मतलब है total = total + 250. Python में ++ और -- नहीं हैं: x++ syntax error देगा।

Walrus operator := (नाम उसकी आकृति से पड़ा, जो मॉर्स के दाँतों जैसी लगती है) expression के भीतर ही मान असाइन करता है। यह तब काम आता है जब मान को जाँचना भी हो और आगे इस्तेमाल भी करना हो:

items = ["कॉफ़ी", "टैक्सी", "लंच", "फ़िल्म"]
if (n := len(items)) > 3:
    print(f"बहुत सारे खर्च: {n}")

while (line := input("रक़म: ")) != "":
    print(int(line) * 2)

इसके बिना len दो बार बुलाना पड़ता या असाइनमेंट अलग लाइन में करना पड़ता। इसे ज़्यादा इस्तेमाल न करें: अगर लाइन पढ़ने में मुश्किल हो जाए, तो साधारण असाइनमेंट बेहतर है।

Python में rounding: round, ceil, floor

Python में गोल करने के लिए एक built-in function round है और math module के functions हैं। ये अलग-अलग काम करते हैं, और इन्हें मिलाना आम गलती है।

Python का round और बैंकर्स राउंडिंग

round(x, n) n दशमलव स्थानों तक गोल करता है; दूसरा argument न दें तो पूर्णांक int लौटता है। मुख्य जाल: python round “बैंकर्स” तरीके से गोल करता है — आधे को निकटतम सम संख्या तक। इसलिए round(2.5) का नतीजा 2 है, और round(3.5) का 4। इससे बड़ी गणनाओं में गोलीकरण की गलती एक ही दिशा में जमा नहीं होती।

>>> round(2.5), round(3.5)
(2, 4)
>>> round(3.14159, 2)
3.14
>>> round(1250, -2)     # सौ तक
1200
>>> round(2.675, 2)     # 2.68 नहीं: बाइनरी में यह 2.67499... है
2.67

अगर स्कूली तरीके का “आधा ऊपर” गोलीकरण चाहिए, जैसे बिल में, तो Decimal के साथ ROUND_HALF_UP मोड लें। संख्या को string में दें, ताकि float की गलती साथ न आए:

>>> from decimal import Decimal, ROUND_HALF_UP
>>> Decimal("2.5").quantize(Decimal("1"), ROUND_HALF_UP)
Decimal('3')
>>> Decimal("2.675").quantize(Decimal("0.01"), ROUND_HALF_UP)
Decimal('2.68')

कोर्स का एक और नियम: गोल सिर्फ़ आउटपुट के समय करें। सुंदर प्रिंट के लिए round की ज़रूरत नहीं — f-string काफ़ी है: f"{amount:.2f}" दो अंक दिखाएगा, और संख्या ख़ुद सटीक रहेगी।

math.ceil और math.floor: ऊपर और नीचे गोलीकरण

math.ceil तब चाहिए जब “कम पड़ना” मंज़ूर न हो: कितनी बसें बुक करें, कितने पन्ने चाहिए। math.floor तब जब सिर्फ़ पूरी इकाइयाँ गिनी जाती हैं। दोनों functions int लौटाते हैं।

import math

guests = 47
seats = 20
print(math.ceil(guests / seats))   # 3 बसें
print(math.floor(9.99))            # 9
print(-(-guests // seats))         # 3 — math के बिना ceil, // की तरकीब से

math module में और उपयोगी functions हैं: math.sqrt (जड़), math.isclose (दशमलव की तुलना), math.pi, math.gcd। Python 3.15 में पूर्णांक गणित के लिए submodule math.integer आया (PEP 791): इसमें comb, factorial, gcd, isqrt, lcm, perm हैं, और पुराने math.gcd आदि भी चलते रहते हैं।

abs function: संख्या का निरपेक्ष मान

abs(x) निरपेक्ष मान लौटाता है — शून्य से बिना चिह्न की दूरी। Import की ज़रूरत नहीं, function built-in है। पूर्णांक, दशमलव और यहाँ तक कि complex संख्याओं पर काम करता है: 3+4j के लिए वह सदिश की लंबाई देगा, 5.0।

>>> abs(-250)
250
>>> abs(-12.5)
12.5
>>> budget, spent = 5000, 5320
>>> abs(budget - spent)    # कितना भटके
320

आम इस्तेमाल: दिशा को छोड़कर अंतर, और सहनशीलता (tolerance) के साथ तुलना: abs(a - b) < 0.001। दशमलव के लिए math.isclose ज़्यादा भरोसेमंद है, क्योंकि वह संख्याओं के पैमाने को ध्यान में रखता है।

Operators की प्राथमिकता

एक expression में कई operators हों, तो Python उन्हें प्राथमिकता के क्रम में चलाता है — ऊँची से नीची तक:

1. **
2. unary -x, +x, ~x
3. * / // %
4. + -
5. bitwise shifts और operations
6. तुलना, in, is
7. not
8. and
9. or
10. :=

इस तरह 2 + 3 * 4 का नतीजा 14 है, और (2 + 3) * 4 का 20। शक हो तो कोष्ठक लगाएँ: ज़्यादा कोष्ठक से कुछ नहीं बिगड़ता, पर प्राथमिकता की गलती ढूँढने में देर लगती है।

Operators की आम गलतियाँ

निष्कर्ष

सबसे ज़रूरी बातें याद रखें: / हमेशा float देता है, // नीचे गोल करता है, % भाजक के चिह्न वाला शेषफल देता है, और घात ** है। Logical and, or, not शब्दों में लिखे जाते हैं और आलसी ढंग से चलते हैं; is की ज़रूरत None की जाँच के लिए है। Python round आधे को सम संख्या की ओर गोल करता है; ऊपर और नीचे के लिए math.ceil और math.floor हैं, और निरपेक्ष मान abs देता है। कोर्स में ये operators व्यवहार में सीखे जाते हैं — खर्च ट्रैकर में, जहाँ पैसे पैसों में रखे जाते हैं।