# Python-এর অপারেটর: গণিত, // ও %, তুলনা, and/or/not এবং python round

URL: https://skillaria.top/bn/guides/python/python-operators-round-floor-ceil

Python-এ / সবসময় float দেয়, // পূর্ণসংখ্যা ভাগ করে নিচের দিকে গোল করে, % অবশিষ্ট দেয়, ** ঘাত। round(x, n) n দশমিক ঘর পর্যন্ত গোল করে ব্যাংকার্স রাউন্ডিংয়ে: round(2.5) হয় 2, round(3.5) হয় 4; উপরে ও নিচে পূর্ণসংখ্যায় গোল করতে math.ceil ও math.floor, সংখ্যার মান পেতে abs।

Python-এর অপারেটর হলো চিহ্ন, যা মানকে নতুন মানে রূপান্তর করে: `+` যোগ করে, `//` পূর্ণ ভাগ করে, `and` শর্তগুলো যুক্ত করে। নিচে অপারেটরের সম্পূর্ণ তালিকা উদাহরণসহ দেওয়া হলো, `/` ও `//`-এর পার্থক্য, `and`, `or`, `not`-এর যুক্তি, এবং গোল করার উপায়: python round, `math.ceil`, `math.floor` ও `abs`। প্রতিটি উদাহরণ REPL-এ বসিয়ে যাচাই করতে পারবেন।

## Python অপারেটরের তালিকা

অপারেটরগুলো কাজ অনুযায়ী ভাগ করা যায়। পুরো টেবিল মুখস্থ করার দরকার নেই: বাস্তব কোডে সবচেয়ে বেশি দেখা যায় গাণিতিক, তুলনা ও যুক্তির অপারেটর।

| দল | অপারেটর | উদাহরণ |
| --- | --- | --- |

| গাণিতিক | `+ - * / // % **` | `7 // 2` → 3 |

| তুলনা | `== != < > <= >=` | `3 < 5` → True |

| যৌক্তিক | `and or not` | `not True` → False |

| অভিন্নতা | `is`, `is not` | `x is None` |

| অন্তর্ভুক্তি | `in`, `not in` | `"a" in "cafe"` → True |

| অ্যাসাইনমেন্ট | `= += -= *= /= //= %= **=` | `total += 250` |

| ওয়ালরাস | `:=` | `if (n := len(s)) > 10:` |

| বিট-ভিত্তিক | `& | ^ ~ << >>` | `5 & 3` → 1 |

## গাণিতিক অপারেটর

যোগ, বিয়োগ ও গুণ স্কুলের মতোই কাজ করে। রাশিতে অন্তত একটি `float` থাকলে ফলও `float` হয়: `2 + 1.0` দেয় `3.0`। Python-এর পূর্ণসংখ্যা উপচে পড়ে না — `2 ** 100` নির্ভুলভাবে গণনা হয়, সংখ্যাটি যত বড়ই হোক।

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

### Python-এ ঘাত: ** অপারেটর

ঘাতের জন্য দুটি তারকাচিহ্ন লেখা হয়, `^` নয়: Python-এ `^` মানে বিট-ভিত্তিক «এক্সক্লুসিভ OR», তাই `2 ^ 3` দেবে 1, 8 নয়। ভগ্নাংশ ঘাতে মূল পাওয়া যায়: `9 ** 0.5` হয় `3.0`। আছে `pow(x, y)` ফাংশনও — একই কাজ, সঙ্গে তৃতীয় আর্গুমেন্টে অবশিষ্ট: `pow(2, 10, 1000)` দেবে 24।

অগ্রাধিকারের দিকে নজর দিন: `**` আগে চলে একমুখী ঋণাত্মক চিহ্নের আগে, তাই `-2 ** 2` হয় `-4`। ঋণাত্মক সংখ্যার বর্গ চাইলে বন্ধনী লিখুন: `(-2) ** 2`।

## Python-এ ভাগ: /, // ও %

Python-এ দুই ধরনের ভাগ আছে, আর নতুনদের বিস্ময়ের প্রধান উৎস এটিই। সাধারণ ভাগ `/` সবসময় `float` দেয়, এমনকি পূর্ণ ভাগ হলেও। পূর্ণসংখ্যা ভাগ `//` দশমিক অংশ বাদ দেয়, আর `%` দেয় অবশিষ্ট।

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

### পূর্ণ ভাগ // ও অবশিষ্ট %: বাস্তব ব্যবহার

`//` ও `%` জোড়া মেলে «কয়টি পূর্ণ আর কী পরিমাণ বাকি» ধরনের সমস্যায়। কোর্সের খরচ ট্র্যাকারে টাকা নির্ভুলতা হারাতে না দিতে পয়সায় রাখা হয় এবং যোগফলটি টাকা ও পয়সায় ভাঙা হয়:

```
kopecks = 125050          # টাকা রাখা হচ্ছে পয়সায়
rub = kopecks // 100      # 1250 — পূর্ণ টাকা
kop = kopecks % 100       # 50 — অবশিষ্ট
print(rub, kop)           # 1250 50

print(40 // 7, "সপ্তাহ আর", 40 % 7, "দিন")   # 5 সপ্তাহ আর 5 দিন
```

দুটি কাজ একসঙ্গে দেয় অন্তর্নির্মিত `divmod` ফাংশন: `divmod(125050, 100)` দেয় `(1250, 50)` টাপল। জোড়-বিজোড় যাচাইয়েও অবশিষ্ট কাজে লাগে: `n % 2 == 0` জোড় সংখ্যার জন্য সত্য।

### ঋণাত্মক সংখ্যা: // নিচের দিকে গোল করে

`//` শুধু দশমিক অংশ বাদ দেয় না, বরং নিচের দিকে গোল করে — ঋণাত্মক অসীমের দিকে। ধনাত্মক সংখ্যায় পার্থক্য নেই, ঋণাত্মকে আছে। Python-এ অবশিষ্টের চিহ্ন ভাজকের চিহ্নের সমান, তাই `a == (a // b) * b + a % b` সবসময় সত্য।

```
>>> -7 // 2
-4
>>> -7 % 2
1
>>> int(-7 / 2)     # দশমিক অংশ বাদ, গোল নয়
-3
```

### শূন্য দিয়ে ভাগ: কোন ত্রুটি

তিনটি অপারেটরের যেকোনোটি দিয়ে শূন্যে ভাগ করলে আসে `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
```

## তুলনা অপারেটর

তুলনা `True` বা `False` ফেরত দেয়। সমানতা যাচাই হয় দুটি `==` চিহ্নে, একটি `=` হলো অ্যাসাইনমেন্ট। স্ট্রিং তুলনা হয় অক্ষরের কোড অনুযায়ী, তাই `"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`-এ।

## যৌক্তিক অপারেটর and, or, not

Python-এ যৌক্তিক অপারেটর লেখা হয় শব্দে, অন্য ভাষার `&&` ও `||`-এর বদলে। `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`। `True or False and False` হয় `True`, কারণ `and` আগে গণনা হয়। জটিল শর্তে বন্ধনী দিন — তাতে আপনার ও সহকর্মীর জন্য কোড স্পষ্ট হয়।

### and ও or আসলে কী ফেরত দেয়

`and` ও `or` সবসময় `True` বা `False` দেয় না, বরং দুই অপারেন্ডের একটি ফেরত দেয়। `or` প্রথম সত্য মানটি দেয় (সত্য না থাকলে শেষটি), `and` — প্রথম মিথ্যা মানটি (না থাকলে শেষটি)। মিথ্যা হিসেবে গণ্য হয় `0`, `0.0`, খালি স্ট্রিং, খালি সংগ্রহ, `None` ও `False`।

```
>>> name = ""
>>> name or "অতিথি"
'অতিথি'
>>> 5 and 0
0
>>> not ""
True
```

মূল্যায়ন আলসে: বাঁ দিক থেকেই ফল বোঝা গেলে ডান দিক গণনা হয় না। তাই `count == 0` হলে `count and total / count` শূন্য ভাগের ত্রুটি দেয় না। `not` অন্য দুটির মতো নয় — সবসময় `bool` দেয়।

## is ও in অপারেটর

`==` মান তুলনা করে, আর `is` যাচাই করে দুটি নাম একই অবজেক্টকে নির্দেশ করছে কিনা। দুটি আলাদা খালি ঝুড়ি সমান, কিন্তু একই অবজেক্ট নয়। `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
```

সংখ্যা ও স্ট্রিং `is` দিয়ে তুলনা করবেন না: কখনো কখনো অভ্যন্তরীণ ক্যাশের কারণে তা কাজ করে, কিন্তু ফলাফল বাস্তবায়নের উপর নির্ভর করে, আর `x is 5`-এর মতো কোডে Python `SyntaxWarning` দেয়।

`in` অন্তর্ভুক্তি যাচাই করে: স্ট্রিংয়ে সাবস্ট্রিং, তালিকায় উপাদান, ডিকশনারিতে কী। `not in` উল্টো যাচাই।

```
>>> "coffee" in "coffee with milk"
True
>>> "food" in {"food": 450, "taxi": 300}
True
>>> 5 not in [1, 2, 3]
True
```

## অ্যাসাইনমেন্ট অপারেটর ও ওয়ালরাস অপারেটর :=

যৌগিক অপারেটর `+=`, `-=`, `*=`, `//=` ইত্যাদি সংক্ষিপ্ত রূপ: `total += 250` মানে `total = total + 250`। Python-এ `++` ও `--` নেই: `x++` লিখলে সিনট্যাক্স ত্রুটি হবে।

ওয়ালরাস অপারেটর `:=` (নামটি এসেছে ওয়ালরাসের চোখ ও দাঁতের মিল থেকে) মানটি অ্যাসাইন করে সরাসরি একটি এক্সপ্রেশনের ভেতরে। যখন মান একসঙ্গে যাচাই ও ব্যবহার করতে হয়, তখন কাজে লাগে:

```
items = ["coffee", "taxi", "lunch", "movie"]
if (n := len(items)) > 3:
    print(f"অনেক খরচ: {n}")

while (line := input("পরিমাণ: ")) != "":
    print(int(line) * 2)
```

এটি ছাড়া `len` দুইবার ডাকতে হতো, বা অ্যাসাইনমেন্ট আলাদা লাইনে রাখতে হতো। অতিরিক্ত ব্যবহার করবেন না: লাইন পড়া কঠিন হয়ে গেলে সাধারণ অ্যাসাইনমেন্টই ভালো।

## Python-এ গোল করা: round, ceil, floor

গোল করার জন্য Python-এ আছে অন্তর্নির্মিত `round` ফাংশন এবং `math` মডিউলের ফাংশন। এরা আলাদা কাজ করে, আর এগুলো গুলিয়ে ফেলা একটি সাধারণ ভুল।

| ফাংশন | কী করে | 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` দশমিক ঘর পর্যন্ত গোল করে; দ্বিতীয় আর্গুমেন্ট না দিলে ফল হয় পূর্ণসংখ্যা `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
```

যদি স্কুলের চেনা «মধ্যবিন্দু উপরে» গোল দরকার হয়, যেমন রসিদে, তবে `ROUND_HALF_UP` মোডসহ `Decimal` ব্যবহার করুন। সংখ্যাটি স্ট্রিং হিসেবে দিন, যাতে `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-স্ট্রিংই যথেষ্ট: `f"{amount:.2f}"` দুই ঘর দেখায়, কিন্তু সংখ্যাটি নিজে নির্ভুল থাকে।

### math.ceil ও math.floor: উপরে ও নিচে গোল

`math.ceil` লাগে যখন «কম পড়া» গ্রহণযোগ্য নয়: কতটি বাস বুক করতে হবে, কয়টি পৃষ্ঠা লাগবে। `math.floor` — যখন শুধু পূর্ণ একক গোনা হয়। দুটি ফাংশনই `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` মডিউলে আরও কাজের ফাংশন আছে: `math.sqrt` (বর্গমূল), `math.isclose` (ভগ্নাংশ তুলনা), `math.pi`, `math.gcd`। Python 3.15-এ এসেছে পূর্ণসংখ্যার গণিতের উপ-মডিউল `math.integer` (PEP 791): সেখানে `comb`, `factorial`, `gcd`, `isqrt`, `lcm`, `perm` আছে, আর পুরনো `math.gcd` ও অন্যগুলো কাজ করে চলে।

## abs ফাংশন: সংখ্যার মান

`abs(x)` মডিউল ফেরত দেয় — শূন্য থেকে চিহ্নবিহীন দূরত্ব। ইমপোর্ট লাগে না, ফাংশনটি অন্তর্নির্মিত। পূর্ণসংখ্যা, ভগ্নাংশ এবং জটিল সংখ্যায়ও কাজ করে: `3+4j`-এর জন্য দেয় ভেক্টরের দৈর্ঘ্য, `5.0`।

```
>>> abs(-250)
250
>>> abs(-12.5)
12.5
>>> budget, spent = 5000, 5320
>>> abs(budget - spent)    # কতটা বিচ্যুত হয়েছি
320
```

সাধারণ ব্যবহার — দিক বাদ দিয়ে পার্থক্য এবং সহনশীলতা সহ তুলনা: `abs(a - b) < 0.001`। ভগ্নাংশের ক্ষেত্রে `math.isclose` নির্ভরযোগ্য, কারণ সেটি সংখ্যার মাপও বিবেচনা করে।

## অপারেটরের অগ্রাধিকার

একটি রাশিতে একাধিক অপারেটর থাকলে Python অগ্রাধিকার অনুযায়ী চালায় — বেশি থেকে কম:

1. `**`
2. একমুখী `-x`, `+x`, `~x`
3. `* / // %`
4. `+ -`
5. বিট-শিফট ও বিট-অপারেশন
6. তুলনা, `in`, `is`
7. `not`
8. `and`
9. `or`
10. `:=`

তাই `2 + 3 * 4` হয় 14, আর `(2 + 3) * 4` — 20। সন্দেহ হলে বন্ধনী দিন: অতিরিক্ত বন্ধনীতে ক্ষতি নেই, কিন্তু অগ্রাধিকারের ভুল খুঁজতে অনেক সময় যায়।

## অপারেটরের সাধারণ ভুল

| ভুল | কী হয় | সঠিক উপায় |
| --- | --- | --- |

| `if x = 5:` | SyntaxError: এটি অ্যাসাইনমেন্ট | `if x == 5:` |

| ঘাতের বদলে `2 ^ 3` | বিট-ভিত্তিক 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 দেয়, `//` নিচের দিকে গোল করে, `%` দেয় ভাজকের চিহ্নের অবশিষ্ট, আর ঘাত হলো `**`। যৌক্তিক `and`, `or`, `not` শব্দে লেখা হয় এবং আলসে মূল্যায়িত হয়; `None` যাচাইয়ে লাগে `is`। Python round জোড়ের দিকে গোল করে; উপরে ও নিচে গোল করতে আছে `math.ceil` ও `math.floor`, আর সংখ্যার মান দেয় `abs`। কোর্সে এই অপারেটরগুলো হাতে-কলমে শেখানো হয় খরচ ট্র্যাকারে, যেখানে টাকা রাখা হয় পয়সায়।

## FAQ

**Python-এ সংখ্যাকে দুই দশমিক ঘর পর্যন্ত কীভাবে গোল করবেন?**

round(x, 2) ব্যবহার করুন। যদি শুধু সুন্দরভাবে দেখাতে চান, তবে f-স্ট্রিং f"{x:.2f}" নিন — তাতে সংখ্যার মান বদলায় না।

**কেন Python-এ round(0.5) 0 দেয়?**

কারণ round মধ্যবিন্দু গোল করে নিকটতম জোড় সংখ্যায়, আর 0 জোড়। একইভাবে round(1.5) ও round(2.5) দেয় 2।

**Python-এ ভাগের পূর্ণ অংশ কীভাবে পাবেন?**

// অপারেটর দিয়ে: 17 // 5 দেয় 3। ঋণাত্মক সংখ্যায় এটি নিচের দিকে গোল করে, তাই -17 // 5 দেয় -4; শূন্যের দিকে দশমিক অংশ বাদ দিতে int(-17 / 5) ব্যবহার করুন।

**Python-এ কি টার্নারি অপারেটর আছে?**

হ্যাঁ, এটি শর্তসাপেক্ষ এক্সপ্রেশন: মান_যদি_হ্যাঁ if শর্ত else মান_যদি_না, যেমন "জোড়" if n % 2 == 0 else "বিজোড়"।

**Python-এর & ও and-এর পার্থক্য কী?**

and একটি যৌক্তিক অপারেটর, যা আলসে মূল্যায়ন করে; & সংখ্যার বিট-ভিত্তিক AND এবং সেটের ছেদ। শর্তে if-এর সঙ্গে and ব্যবহার করুন।


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