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

URL: https://skillaria.top/hi/guides/python/python-operators

Operator / के नतीजे में Python हमेशा float देता है, // पूरे भाग को नीचे की ओर गोल करता है, % शेषफल देता है, और ** घात है। round(x, n) n दशमलव स्थानों तक “बैंकर्स” तरीके से गोल करता है: round(2.5) का नतीजा 2 है और round(3.5) का 4; पूर्णांक तक ऊपर और नीचे गोल करने के लिए math.ceil और math.floor हैं, और संख्या का निरपेक्ष मान abs देता है।

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 दिखते हैं।

| समूह | Operators | उदाहरण |
| --- | --- | --- |

| Arithmetic (गणित) | `+ - * / // % **` | `7 // 2` → 3 |

| Comparison (तुलना) | `== != < > <= >=` | `3 < 5` → True |

| Logical (तार्किक) | `and or not` | `not True` → False |

| Identity (पहचान) | `is`, `is not` | `x is None` |

| Membership (सदस्यता) | `in`, `not in` | `"चा" in "चाय"` → True |

| Assignment (असाइनमेंट) | `= += -= *= /= //= %= **=` | `total += 250` |

| Walrus (मॉर्स वाला) | `:=` | `if (n := len(s)) > 10:` |

| Bitwise (बिट स्तर) | `& | ^ ~ << >>` | `5 & 3` → 1 |

## 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 > 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` मान को उलट देता है।

| a | b | a and b | a or b | not a |
| --- | --- | --- | --- | --- |

| True | True | True | True | False |

| True | False | False | True | False |

| False | True | False | True | True |

| False | False | False | False | True |

प्राथमिकता: पहले `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 हैं। ये अलग-अलग काम करते हैं, और इन्हें मिलाना आम गलती है।

| Function | क्या करता है | 2.5 | -2.5 | 2.7 |
| --- | --- | --- | --- | --- |

| `round(x)` | निकटतम तक, आधे पर सम संख्या की ओर | 2 | -2 | 3 |

| `math.floor(x)` | नीचे, माइनस अनंत की ओर | 2 | -3 | 2 |

| `math.ceil(x)` | ऊपर, प्लस अनंत की ओर | 3 | -2 | 3 |

| `math.trunc(x)`, `int(x)` | दशमलव हटाना, शून्य की ओर | 2 | -2 | 2 |

### 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 की आम गलतियाँ

| गलती | क्या होता है | सही तरीका |
| --- | --- | --- |

| `if x = 5:` | SyntaxError: यह असाइनमेंट है | `if x == 5:` |

| घात की जगह `2 ^ 3` | bitwise XOR, नतीजा 1 | `2 ** 3` |

| `8 / 2` से पूर्णांक की उम्मीद | मिलता है `4.0` | `8 // 2` |

| `x == 1 or 2` | हमेशा सच: `or 2` | `x in (1, 2)` |

| `round(2.5)` से 3 की उम्मीद | बैंकर्स राउंडिंग से 2 | `Decimal` के साथ `ROUND_HALF_UP` |

| `"5" + 5` | TypeError | `int("5") + 5` |

## निष्कर्ष

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

## FAQ

**Python में संख्या को दो दशमलव स्थानों तक कैसे गोल करें?**

round(x, 2) इस्तेमाल करें। अगर सिर्फ़ सुंदर आउटपुट चाहिए, तो f-string f"{x:.2f}" लें, जो खुद मान नहीं बदलता।

**Python में round(0.5) का नतीजा 0 क्यों आता है?**

क्योंकि round आधे को निकटतम सम संख्या की ओर गोल करता है, और 0 सम है; इसी तरह round(1.5) और round(2.5) दोनों 2 देते हैं।

**भाग का पूरा हिस्सा Python में कैसे निकालें?**

// operator से: 17 // 5 का नतीजा 3 है। ऋणात्मक संख्याओं के लिए वह नीचे गोल करता है, इसलिए -17 // 5 देता है -4; अगर दशमलव हटाकर शून्य की ओर जाना है, तो int(-17 / 5) लें।

**क्या Python में ternary operator है?**

हाँ, यह शर्तीय expression है: मान_अगर_सच if शर्त else मान_अगर_झूठ, उदाहरण के लिए "सम" if n % 2 == 0 else "विषम"।

**Python में & और and में क्या अंतर है?**

and एक logical operator है जो आलसी ढंग से चलता है, जबकि & संख्याओं पर bitwise AND है और sets पर प्रतिच्छेदन (intersection)। शर्तों में if के साथ and इस्तेमाल करें।


---
Source: Skillaria.Top (https://skillaria.top)