Python-இல் சுழல்களும் நிபந்தனைகளும்: for, while, range, enumerate, break, if/elif மற்றும் match/case

Python-இல் சுழல்கள் ஒரு செயலை மீண்டும் செய்யப் பயன்படுகின்றன: வாங்கும் பட்டியலின் ஒவ்வொரு உருப்படியையும் கடப்பது, கோப்பின் ஒவ்வொரு வரியையும் செயலாக்குவது, பயனர் சரியான எண்ணை உள்ளிடும் வரை கேட்பது. மொழியில் இரண்டு சுழல்கள் உள்ளன — for மற்றும் while; அவற்றுக்குள் முடிவுகளை if/elif/else நிபந்தனைகளும் match/case கட்டமைப்பும் எடுக்க உதவுகின்றன. ஒவ்வொரு கருவியையும் வேலை செய்யும் எடுத்துக்காட்டுகளுடன் பார்ப்போம்.

நிபந்தனைகள்: if, elif, else

நிபந்தனைக் கூற்று வெளிப்பாடு உண்மையானால் மட்டுமே குறியீட்டுத் தொகுதியை இயக்கும். தொகுதி 4 இடைவெளி உள்தள்ளலால் குறிக்கப்படுகிறது — Python-இல் சுருள் அடைப்புக்குறிகள் இல்லை; தவறான உள்தள்ளல் உடனே IndentationError தரும்.

spent = 4200
limit = 5000

if spent > limit:
    print("வரம்பு மீறப்பட்டது")
elif spent > limit * 0.8:
    print("பட்ஜெட்டில் 20%-க்கும் குறைவு மீதம்")
else:
    print("எல்லாம் சரியாக உள்ளது")

elif கிளைகள் மேலிருந்து கீழாகச் சரிபார்க்கப்படும்; பொருந்தும் முதல் கிளை மட்டுமே இயங்கும். அதனால் கடுமையான நிபந்தனைகளை மேலே வையுங்கள்: spent > limit * 0.8 சரிபார்ப்பு முதலில் இருந்தால், வரம்பு மீறப்பட்ட செய்தி ஒருபோதும் தோன்றாது.

எது உண்மையாகக் கருதப்படுகிறது

நிபந்தனையில் ஒப்பீடு எழுதத் தேவையில்லை. பொய்யாகக் கருதப்படுவவை: False, None, பூஜ்ஜியம் (0, 0.0) மற்றும் வெற்றுத் தொகுப்புகள்: "", [], {}. மற்றவை எல்லாம் உண்மை. அதனால் "பட்டியல் வெற்றிடமில்லை" சரிபார்ப்பு சுருக்கமாக எழுதப்படுகிறது:

expenses = []
if not expenses:
    print("இதுவரை செலவுகள் இல்லை")

நிபந்தனைகளை and, or, not மூலம் இணைக்கலாம்; வரம்பைச் சரிபார்க்க ஒப்பீடுகளின் தொடர் வசதியானது: if 0 < amount <= 100_000:. குறுகிய தேர்வுக்கு மூன்றாம் நிலை (ternary) கூற்றும் உண்டு: status = "அதிகம்" if spent > limit else "சாதாரணம்".

Python for சுழல்: தொடரியலும் எடுத்துக்காட்டுகளும்

Python-இன் for சுழல் C போன்ற எண்ணி அல்ல, அது உறுப்புகளை ஒவ்வொன்றாகக் கடக்கும். அது பட்டியல், சரம், அகராதி, கோப்பு, வரம்பு — எந்த மீண்டும் சுற்றக்கூடிய பொருளையும் எடுக்கும். மற்ற மொழிகளின் foreach-இன் பங்கை இங்கே சாதாரண for செய்கிறது.

expenses = [350, 1200, 89, 4500]
total = 0
for amount in expenses:
    total += amount
print(total)  # 6139

for சுழலின் தொடரியல்: for மாறி in தொகுப்பு:, அதைத் தொடர்ந்து உள்தள்ளப்பட்ட தொகுதி. சுழலுக்குப் பிறகும் மாறி கடைசி மதிப்பைத் தக்கவைக்கும் — சில நேரங்களில் அது பயனுள்ளது, ஆனால் பெரிய நிரல்களில் அதை நம்பாதீர்கள்.

சரம், பட்டியல் மற்றும் அகராதியில் சுழல்

சரம் எழுத்து எழுத்தாகக் கடக்கப்படும், பட்டியல் உறுப்புகளாக. அகராதியில் சுழல் இயல்பாக விசைகள் மீது செல்லும்; விசையும் மதிப்பும் ஒன்றாகப் பெற .items() பயன்படுத்துங்கள்:

by_category = {"உணவு": 3200, "போக்குவரத்து": 900, "சினிமா": 600}

for category, amount in by_category.items():
    print(f"{category}: {amount} ₹")

மதிப்புகளை மட்டும் பெற .values() உண்டு. சுழல் நடக்கும்போது அகராதியின் அளவை மாற்றக்கூடாது — RuntimeError: dictionary changed size during iteration வரும். உறுப்புகளை நீக்க வேண்டுமெனில் நகலின் மீது சுழலுங்கள்: for key in list(d):.

range செயல்பாடு: எண்களின் மீது சுழல்

எண்களை வரிசையாகக் கடக்க range() உதவுகிறது. அது நினைவகத்தில் பட்டியல் உருவாக்குவதில்லை; எண்களை ஒவ்வொன்றாகத் தருகிறது, அதனால் range(10**9) உடனே இயங்கும்.

முக்கிய விதி: வலது எல்லை வரம்பில் சேராது. range(1, 10) 9-இல் முடியும் — "ஒன்று குறைவு" பிழைக்கு இதுவே பொதுவான காரணம். படி எதிர்மறையாக இருக்கலாம், ஆனால் பூஜ்ஜியமாக இருக்கக்கூடாது.

for i in range(1, 4):
    print(f"நாள் {i}")
# நாள் 1
# நாள் 2
# நாள் 3

enumerate: சுழலில் எண்ணிக்கை

உறுப்பின் எண் தெரிய வேண்டுமென்று தொடக்கநிலையாளர்கள் அடிக்கடி for i in range(len(items)) எழுதுகின்றனர். அது வேலை செய்கிறது, ஆனால் படிக்க கடினம். enumerate() செயல்பாடு "எண், உறுப்பு" ஜோடிகளைத் தருகிறது; start அளவுரு எந்த எண்ணிலிருந்து எண்ணுவது என்று சொல்கிறது:

items = ["காபி", "டாக்ஸி", "மதிய உணவு"]
for n, item in enumerate(items, start=1):
    print(n, item)
# 1 காபி
# 2 டாக்ஸி
# 3 மதிய உணவு

இரண்டு பட்டியல்களை இணையாகச் சுற்ற zip() உண்டு: for name, price in zip(names, prices):. அது மிகக் குறுகிய பட்டியலில் நிற்கும்; Python 3.10 முதல் strict=True கொடுக்கலாம், அப்போது நீளம் வேறுபட்டால் பிழை வரும்.

Python while சுழல்

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

balance = 10_000
month = 0
while balance > 0:
    balance -= 2_700
    month += 1
print(f"பணம் {month} மாதத்துக்கு போதும்")  # 4

முக்கிய ஆபத்து — நிபந்தனையில் உள்ள மாறியை மாற்ற மறப்பது. அப்போது சுழல் ஒருபோதும் முடியாது. நிரல் "உறைந்துவிட்டால்" Ctrl+C அழுத்துங்கள்: Python KeyboardInterrupt மூலம் இயக்கத்தை நிறுத்தும்.

முடிவற்ற சுழல் மற்றும் do while

சில நேரங்களில் முடிவற்ற சுழலை வேண்டுமென்றே எழுதுகிறோம்: while True:, break மூலம் வெளியேறுதல். பின் நிபந்தனைச் சுழலுக்கும் இதே முறைதான் — Python-இல் do while கட்டமைப்பு இல்லை; அதை இந்த முறை மாற்றுகிறது: தொகுதி குறைந்தது ஒருமுறை இயங்கும், சரிபார்ப்பு முடிவில் இருக்கும்.

while True:
    raw = input("தொகை: ")
    if raw.isdigit():
        amount = int(raw)
        break
    print("முழு எண்ணை உள்ளிடவும்")

for சுழல் முடிவற்றதாக இருப்பது அரிது — எல்லையற்ற iterator-ஐக் கடக்கும்போது மட்டும், உதாரணமாக itertools.count().

break மற்றும் continue: சுழலிலிருந்து வெளியேறுதல் மற்றும் சுற்றைத் தவிர்த்தல்

break சுழலை உடனே நிறுத்துகிறது; இயக்கம் அதற்குப் பின் உள்ள குறியீட்டுக்குச் செல்லும். continue நடப்புச் சுற்றின் மீதியைத் தவிர்த்து அடுத்த சுற்றுக்குச் செல்லும்.

expenses = [350, -10, 1200, 0, 99_999, 89]

for amount in expenses:
    if amount <= 0:
        continue          # இந்தச் சுற்றைத் தவிர்
    if amount > 50_000:
        print("சந்தேகத்துக்குரிய தொகை, நிறுத்து")
        break             # சுழலிலிருந்து வெளியேறு
    print(amount)

350 மற்றும் 1200 அச்சிடப்படும், பிறகு செய்தி வரும் — 89-ஐ சுழல் அடையாது. இரண்டு கூற்றுகளும் தாங்கள் அமைந்துள்ள அருகிலுள்ள சுழலுக்கு மட்டுமே பொருந்தும்.

சுழலின் else

for மற்றும் while-க்கு அசாதாரணமான else கிளை உண்டு: சுழல் break இல்லாமல் தானாக முடிந்தால் அது இயங்கும். தேடலுக்கு இது வசதியானது:

for amount in expenses:
    if amount > 50_000:
        print("பெரிய செலவு கண்டுபிடிக்கப்பட்டது")
        break
else:
    print("பெரிய செலவுகள் இல்லை")

உள்ளமை சுழல்கள்

ஒரு சுழலுக்குள் மற்றொன்று வெளிப்புறச் சுழலின் ஒவ்வொரு சுற்றிலும் உள்ளக சுழலை முழுமையாக இயக்கும். அட்டவணைகள், மெட்ரிக்ஸ்கள், ஜோடிகளைக் கடக்க இது பயன்படுகிறது.

for row in range(1, 4):
    for col in range(1, 4):
        print(row * col, end="\t")
    print()

இரண்டு விஷயங்களை கவனியுங்கள். ஒன்று, சிக்கல் வேகமாக வளரும்: 10 000 உறுப்புகள் கொண்ட இரண்டு உள்ளமை சுழல்கள் 100 மில்லியன் செயல்பாடுகள். இரண்டாவது, break உள்ளக சுழலிலிருந்து மட்டுமே வெளியேறும். இரண்டையும் நிறுத்த, சுழல்களை ஒரு செயல்பாட்டுக்குள் வைத்து return பயன்படுத்துங்கள் — கொடிகளை (flags) விட இது சுத்தமானது.

match/case கட்டமைப்பு

Python 3.10 முதல் நீண்ட if cmd == ... elif ... சங்கிலியை match கட்டமைப்பால் மாற்றலாம் (PEP 634). இது வெறும் switch அல்ல: மதிப்பை தரவின் வடிவத்துடன் ஒப்பிட்டு, அதன் பகுதிகளை உடனே மாறிகளில் பிரிக்கிறது.

def parse(text):
    match text.split():
        case ["add", item, amount]:
            return f"சேர்: {item}: {amount}"
        case ["list"] | ["ls"]:
            return "செலவுகளைக் காட்டு"
        case ["quit"]:
            return "வெளியேறு"
        case _:
            return "தெரியாத கட்டளை"

print(parse("add காபி 250"))  # சேர்: காபி: 250
print(parse("add காபி"))      # தெரியாத கட்டளை

பட்டியல் வடிவம் ["add", item, amount] சரியாக மூன்று உறுப்புகள் கொண்ட பட்டியலுடன் மட்டுமே பொருந்தும்; முதல் உறுப்பு "add" ஆக இருக்க வேண்டும். அதனால் தொகை இல்லாத கட்டளை எல்லாவற்றையும் பிடிக்கும் _ கிளைக்குச் செல்லும். | குறி மாற்றுகளை இணைக்கிறது.

அகராதிகள், வகைகள் மற்றும் காவல் நிபந்தனை

அகராதி வடிவம் குறிப்பிட்ட விசைகளை மட்டும் சரிபார்க்கும்; மற்றவை புறக்கணிக்கப்படும். int(a) வகையைச் சரிபார்த்து மதிப்பைப் பிடிக்கிறது; வடிவத்துக்குப் பின் வரும் if கூடுதல் நிபந்தனையைச் (guard) சேர்க்கிறது:

match event:
    case {"type": "expense", "amount": int(a)} if a > 10_000:
        print("பெரிய செலவு", a)
    case {"type": "expense", "amount": int(a)}:
        print("செலவு", a)

match-இன் முக்கிய பொறி

case-இல் வெறும் பெயர் ஒரு பிடிப்பு (capture), மாறியுடன் ஒப்பீடு அல்ல. case limit: எந்த மதிப்புடனும் பொருந்தி அதை limit-இல் எழுதும். மாறிலிகளுடன் ஒப்பிட புள்ளியுடன் கூடிய பெயரைப் பயன்படுத்துங்கள், உதாரணமாக case Color.RED:, அல்லது நேரடி மதிப்புகள்.

3.10-இலிருந்து match-இன் தொடரியல் கிட்டத்தட்ட மாறவில்லை. Python 3.15-இல் ஒரு சிறிய சமச்சீரின்மை சரி செய்யப்பட்டது: நேரடி மதிப்பு வடிவங்களில் முன்பு எண்ணுக்கு முன் கழித்தல் குறி மட்டுமே அனுமதிக்கப்பட்டது, இப்போது case +1: எழுதலாம். பழைய பதிப்புகளில் அப்படிப்பட்ட குறியீடு தொடரியல் பிழை தரும்.

சுழல்களில் பொதுவான தவறுகள்

• சுழல் நடக்கும்போது பட்டியலை மாற்றுவது. for-இல் உறுப்புகளை நீக்குவது அருகிலுள்ளவற்றைத் தவிர்க்கும். புதிய பட்டியலை உருவாக்குவது நல்லது: clean = [x for x in items if x > 0].
• range-இன் எல்லை. range(1, n) n-ஐ உள்ளடக்காது.
• while-இல் நிபந்தனை மாற்றப்படாமை — முடிவற்ற சுழல்.
• சுழலில் += மூலம் சரங்களை இணைப்பது பெரிய அளவில் "".join(parts)-ஐ விட மெதுவாக இருக்கும்.
• ஒப்பீட்டுக்குப் பதிலாக ஒதுக்கீடு: if x = 5 தொடரியல் பிழை; ஒப்பீடு == மூலம் எழுதப்படுகிறது.

பயிற்சிக்கான சுழல் பணிகள்

1. செலவுப் பட்டியலுக்கு கூட்டுத்தொகையும் சராசரியும் கணக்கிடுங்கள்; எதிர்மறை மதிப்புகளைத் தவிர்த்து.
2. உள்ளமை சுழல்கள் மூலம் 1–9 பெருக்கல் அட்டவணையை அச்சிடுங்கள்.
3. பயனர் வெற்று வரியை உள்ளிடும் வரை எண்களைக் கேளுங்கள், பிறகு அதிகபட்சத்தை அச்சிடுங்கள்.
4. பட்டியலில் 1000-ஐ விட பெரிய முதல் எண்ணைக் கண்டறியுங்கள்; அப்படி எதுவும் இல்லையென்றால் அறிவியுங்கள் (for ... else மூலம்).
5. add, del, list கட்டளைகளை match மூலம் பிரித்துப் பாருங்கள்.

சுருக்கம்

Python சுழல்கள் இரண்டு கட்டமைப்புகளுக்குள் அடங்கும்: for தொகுப்பின் அல்லது range()-இன் உறுப்புகளைக் கடக்கும், while நிபந்தனை இயங்கும் வரை இயங்கும். break மற்றும் continue சுழலின் போக்கைக் கட்டுப்படுத்தும், enumerate() மற்றும் zip() கையால் எண்ணும் சுழல் மாறிகளைத் தேவையற்றதாக்கும், if/elif/else மற்றும் match/case முடிவுகளைக் கையாளும். இந்தக் கருவிகள் அனைத்தும் செலவு கண்காணிப்பானின் எடுத்துக்காட்டில் Python பாடநெறியின் பாடத்தில் நடைமுறையில் விளக்கப்பட்டுள்ளன.