# Python operators: கணிதம், // மற்றும் %, ஒப்பீடு, and/or/not மற்றும் python round

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

Python-இல் / எப்போதும் float தருகிறது, // — கீழ்நோக்கி முழுப் பகுதி, % — மீதம், ** — அடுக்கு. round(x, n) என்பது n தசம இலக்கங்களுக்கு «வங்கி முறையில்» வட்டமிடுகிறது: round(2.5) = 2, round(3.5) = 4; முழுமைக்கு மேல்நோக்கியும் கீழ்நோக்கியும் வட்டமிட math.ceil மற்றும் math.floor, எண்ணின் முழுமதிப்புக்கு abs.

Python operators என்பவை மதிப்புகளை புதிய மதிப்புகளாக மாற்றும் குறிகள்: `+` கூட்டுகிறது, `//` முழுமையாக வகுக்கிறது, `and` நிபந்தனைகளை இணைக்கிறது. கீழே முழு operators பட்டியல் எடுத்துக்காட்டுகளுடன், `/` மற்றும் `//` இடையேயான வேறுபாடு, `and`, `or`, `not` தர்க்கம், மற்றும் வட்டமிடும் செயற்கூறுகள்: python round, `math.ceil`, `math.floor` மற்றும் `abs`. எல்லா எடுத்துக்காட்டுகளையும் REPL-இல் ஒட்டிச் சரிபார்க்கலாம்.

## Python operators பட்டியல்

Operators நோக்கத்தின்படி குழுக்களாகப் பிரிக்கப்பட்டுள்ளன. முழு அட்டவணையையும் மனப்பாடம் செய்ய வேண்டியதில்லை: நேரடி குறியீட்டில் எண்கணிதம், ஒப்பீடு மற்றும் தர்க்க இணைப்புகள் அடிக்கடி வருகின்றன.

| குழு | Operators | எடுத்துக்காட்டு |
| --- | --- | --- |

| எண்கணிதம் | `+ - * / // % **` | `7 // 2` → 3 |

| ஒப்பீடுகள் | `== != < > <= >=` | `3 < 5` → True |

| தர்க்கம் | `and or not` | `not True` → False |

| அடையாளம் | `is`, `is not` | `x is None` |

| உறுப்பினர் | `in`, `not in` | `"ப" in "காப்பி"` → True |

| ஒதுக்கல் | `= += -= *= /= //= %= **=` | `total += 250` |

| Walrus | `:=` | `if (n := len(s)) > 10:` |

| Bitwise | `& | ^ ~ << >>` | `5 & 3` → 1 |

## எண்கணித operators

கூட்டல், கழித்தல் மற்றும் பெருக்கல் பள்ளியில் போல வேலை செய்கின்றன. வெளிப்பாட்டில் குறைந்தது ஒரு `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-இல் அடுக்கு: ** operator

அடுக்குக்கு இரண்டு நட்சத்திரக் குறிகள் — `^` அல்ல: Python-இல் `^` என்பது bitwise «exclusive OR», அதனால் `2 ^ 3` 8 அல்ல, 1 தரும். பின்னவடிவ அடுக்கு வேர் தருகிறது: `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
```

### முழு எண் வகுத்தல் // மற்றும் மீதம் %: நடைமுறை

`//` மற்றும் `%` ஜோடி «எத்தனை முழு, எவ்வளவு மீதம்» என்ற பணிகளைத் தீர்க்கிறது. பாடத்தில் செலவுக் கண்காணிப்பான் பணத்தைத் துல்லியம் இழக்காமல் இருக்க பைசாவில் சேமிக்கிறது, தொகையை ரூபாய் மற்றும் பைசாவாகப் பிரிக்கிறது:

```
paise = 125050            # பணத்தை பைசாவில் சேமிக்கிறோம்
rupees = paise // 100     # 1250 — முழு ரூபாய்கள்
ps = paise % 100          # 50 — மீதம்
print(rupees, ps)         # 1250 50

print(40 // 7, "வாரங்கள் மற்றும்", 40 % 7, "நாட்கள்")   # 5 வாரங்கள் மற்றும் 5 நாட்கள்
```

இரண்டு செயல்களையும் ஒரே நேரத்தில் `divmod` செயற்கூறு தருகிறது: `divmod(125050, 100)` டூப்பிள் `(1250, 50)` தருகிறது. இரட்டை எண்ணைச் சரிபார்க்க மீதம் பயனுள்ளது: `n % 2 == 0` இரட்டை எண்களுக்கு உண்மை.

### எதிர்மறை எண்கள்: // கீழ்நோக்கி வட்டமிடுகிறது

`//` operator வெறுமனே தசமத்தை நீக்குவதில்லை, அது கீழ்நோக்கி வட்டமிடுகிறது — கழித்தல் முடிவிலிக்கு. நேர்மறை எண்களுக்கு வித்தியாசம் இல்லை, எதிர்மறைக்கு உண்டு. Python-இல் மீதத்தின் குறி வகுப்பானின் குறியைப் பின்பற்றுகிறது, அதனால் எப்போதும் `a == (a // b) * b + a % b` சமன்பாடு உண்மை.

```
>>> -7 // 2
-4
>>> -7 % 2
1
>>> int(-7 / 2)     # பின்னத்தை நீக்குகிறது, கீழ்நோக்கி வட்டமிடாமல்
-3
```

### பூஜ்ஜியத்தால் வகுத்தல்: என்ன பிழை

மூன்று operators-இல் எதனாலும் பூஜ்ஜியத்தால் வகுத்தால் `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
```

## ஒப்பீட்டு operators

ஒப்பீடுகள் `True` அல்லது `False` தருகின்றன. சமத்துவம் இரண்டு `==` குறிகளால் சரிபார்க்கப்படுகிறது, ஒற்றை `=` — ஒதுக்கல். சரங்கள் எழுத்துக் குறியீடுகள் வழியாக எழுத்தெழுத்தாக ஒப்பிடப்படுகின்றன, அதனால் `"Б" < "а"` உண்மை: பெரிய எழுத்துகள் சிறிய எழுத்துகளுக்கு முன்னால் வருகின்றன.

```
>>> 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`-இல் சேமியுங்கள்.

## தர்க்க operators: and, or, not

Python-இல் தர்க்கச் 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`. `True or False and False` வெளிப்பாடு `True`, ஏனெனில் `and` முதலில் கருதப்படுகிறது. சிக்கலான நிபந்தனைகளில் அடைப்புக்குறிகளை வையுங்கள் — உங்களுக்கும் சக ஊழியர்களுக்கும் அது எளிதாகப் புரியும்.

### and மற்றும் or உண்மையில் என்ன திருப்புகின்றன

`and` மற்றும் `or` அவசியம் `True` அல்லது `False` தருவதில்லை, ஒரு operand-ஐத் தருகின்றன. `or` முதல் உண்மையான மதிப்பைத் தருகிறது (உண்மைகள் இல்லையென்றால் கடைசியானதை), `and` — முதல் பொய்யான மதிப்பை (இல்லையென்றால் கடைசியானதை). பொய்யானவையாகக் கருதப்படுபவை: `0`, `0.0`, வெற்றுச் சரம், வெற்றுத் தொகுப்புகள், `None` மற்றும் `False`.

```
>>> name = ""
>>> name or "விருந்தினர்"
'விருந்தினர்'
>>> 5 and 0
0
>>> not ""
True
```

மதிப்பீடு சோம்பேறித்தனமானது: இடது பகுதியிலிருந்தே முடிவு தெளிவாக இருந்தால், வலது பகுதி கணக்கிடப்படாது. அதனால் `count and total / count` `count == 0` ஆக இருக்கும்போது பூஜ்ஜியத்தால் வகுத்தலில் விழாது. `not`, மற்ற இரண்டைப் போலல்லாமல், எப்போதும் `bool` தருகிறது.

## is மற்றும் in operators

`==` மதிப்புகளை ஒப்பிடுகிறது, `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` operator உறுப்பினர் சரிபார்ப்பு செய்கிறது: சரத்தில் துணைச்சரம், பட்டியலில் உறுப்பு, அகராதியில் விசை. `not in` — அதன் எதிர் சரிபார்ப்பு.

```
>>> "காபி" in "காபி எடுத்துக்கொள்ளலாம்"
True
>>> "உணவு" in {"உணவு": 450, "டாக்சி": 300}
True
>>> 5 not in [1, 2, 3]
True
```

## ஒதுக்கல் operators மற்றும் walrus operator :=

`+=`, `-=`, `*=`, `//=` மற்றும் பிற கூட்டு operators — சுருக்கம்: `total += 250` என்பது `total = total + 250`. Python-இல் `++` மற்றும் `--` operators இல்லை: `x++` தொடரியல் பிழை தரும்.

Walrus operator `:=` (யானைத் தந்தம் மற்றும் கண்களைப் போல இருப்பதால் இப்பெயர்) வெளிப்பாட்டின் உள்ளேயே மதிப்பை ஒதுக்குகிறது. மதிப்பைச் சரிபார்க்கவும் பின்னர் பயன்படுத்தவும் தேவைப்படும்போது இது பயனுள்ளது:

```
items = ["காபி", "டாக்சி", "மதிய உணவு", "சினிமா"]
if (n := len(items)) > 3:
    print(f"அதிக செலவுகள்: {n}")

while (line := input("தொகை: ")) != "":
    print(int(line) * 2)
```

walrus இல்லாவிட்டால் `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)` முழுமதிப்பைத் தருகிறது — பூஜ்ஜியத்திலிருந்து குறியின்றி உள்ள தூரம். இறக்குமதி தேவையில்லை, செயற்கூறு உள்ளமைந்தது. முழு, தசம மற்றும் சிக்கலான (complex) எண்களுடனும் வேலை செய்யும்: `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` நம்பகமானது, ஏனெனில் அது எண்களின் அளவையும் கணக்கில் கொள்கிறது.

## Operators முன்னுரிமை

வெளிப்பாட்டில் பல operators இருக்கும்போது Python அவற்றை முன்னுரிமைப்படி — அதிகத்திலிருந்து குறைவுக்கு — இயக்குகிறது:

1. `**`
2. ஒற்றை `-x`, `+x`, `~x`
3. `* / // %`
4. `+ -`
5. bit நகர்த்தல்கள் மற்றும் செயல்கள்
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 தருகிறது | `ROUND_HALF_UP`-உடன் `Decimal` |

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

## முடிவு

முக்கியமானதை நினைவில் வையுங்கள்: `/` எப்போதும் float தருகிறது, `//` கீழ்நோக்கி வட்டமிடுகிறது, `%` வகுப்பானின் குறியுடன் மீதத்தைத் தருகிறது, அடுக்கு — `**`. தர்க்கம் `and`, `or`, `not` சொற்களாக எழுதப்பட்டு சோம்பேறியாக மதிப்பிடப்படுகின்றன, `is` — `None` சரிபார்ப்புக்கு. Python round இரட்டை எண்ணுக்கு வட்டமிடுகிறது; மேல்நோக்கி மற்றும் கீழ்நோக்கி வட்டமிட `math.ceil` மற்றும் `math.floor` உள்ளன, எண்ணின் முழுமதிப்புக்கு `abs`. பாடத்தில் இந்த operators நடைமுறையில் விளக்கப்படுகின்றன — பணம் காசுகளில் சேமிக்கப்படும் செலவுக் கண்காணிப்பானில்.

## FAQ

**Python-இல் ஒரு எண்ணை இரண்டு தசம இலக்கங்களுக்கு எப்படி வட்டமிடுவது?**

round(x, 2) பயன்படுத்துங்கள்; எண்ணை வெறும் அழகாகக் காட்ட வேண்டுமென்றால் f-சரம் 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 உள்ளதா?**

ஆம், அது நிபந்தனை வெளிப்பாடு: மதிப்பு_உண்மையெனில் if நிபந்தனை else மதிப்பு_பொய்யெனில், எடுத்துக்காட்டாக "இரட்டை" if n % 2 == 0 else "ஒற்றை".

**Python-இல் & மற்றும் and இடையே என்ன வேறுபாடு?**

and என்பது சோம்பேறி மதிப்பீடு கொண்ட தர்க்க operator, & — எண்களுக்கான bitwise AND மற்றும் கணங்களுக்கான வெட்டுப்பகுதி; if நிபந்தனைகளில் and-ஐப் பயன்படுத்துங்கள்.


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