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

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

Python operators பட்டியல்

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

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

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

Python-இல் தர்க்கச் operators சொற்களாக எழுதப்படுகின்றன, மற்ற மொழிகளைப் போல && மற்றும் || குறிகளாக அல்ல. and இரு பகுதிகளும் உண்மையாக இருந்தால் உண்மை, or — குறைந்தது ஒன்று உண்மையாக இருந்தால், not மதிப்பைத் தலைகீழாக்குகிறது.

முன்னுரிமை: முதலில் 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 தொகுதியின் செயற்கூறுகளும் உள்ளன. அவை வெவ்வேறு பணிகளைத் தீர்க்கின்றன, இவற்றைக் குழப்புவது பொதுவான தவறு.

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-உடன் அடிக்கடி ஏற்படும் தவறுகள்

முடிவு

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