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

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

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

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(5)` | 0, 1, 2, 3, 4 |

| `range(2, 6)` | 2, 3, 4, 5 |

| `range(0, 10, 3)` | 0, 3, 6, 9 |

| `range(5, 0, -1)` | 5, 4, 3, 2, 1 |

முக்கிய விதி: வலது எல்லை வரம்பில் சேராது. `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  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 பாடநெறியின் பாடத்தில் நடைமுறையில் விளக்கப்பட்டுள்ளன.

## FAQ

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

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

**பட்டியலை தலைகீழ் வரிசையில் எப்படிக் கடப்பது?**

தொகுப்புக்கு reversed(items), எண்களுக்கு range(n - 1, -1, -1) பயன்படுத்துங்கள். reversed பட்டியலை நகலெடுப்பதில்லை; அதை இறுதியிலிருந்து கடக்கிறது.

**Python-இல் switch உள்ளதா?**

தனி switch இல்லை; அதன் பங்கை if/elif சங்கிலியும் Python 3.10-இல் வந்த match/case கட்டமைப்பும் செய்கின்றன. match கூடுதலாகச் செய்யும்: பட்டியல்கள் மற்றும் அகராதிகளை வடிவத்தின்படி பிரித்து மதிப்புகளைப் பிடிக்கும்.

**சுழலா அல்லது பட்டியல் உருவாக்கமா (list comprehension) வேகமானது?**

[x * 2 for x in items] போன்ற பட்டியல் உருவாக்கம் append உடன் கூடிய சமமான சுழலை விட பொதுவாக சற்று வேகமானது, மேலும் சுருக்கமானது. பல நிபந்தனைகளுடன் கூடிய சிக்கலான தர்க்கத்துக்கு சாதாரண சுழல் நன்றாகப் படிக்கப்படும்.

**இரண்டு உள்ளமை சுழல்களிலிருந்து ஒரே நேரத்தில் எப்படி வெளியேறுவது?**

break உள்ளக சுழலை மட்டுமே நிறுத்தும். எளிய வழி — சுழல்களை ஒரு செயல்பாட்டுக்குள் வைத்து return மூலம் வெளியேறுவது.


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