Python-இல் exception handling எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

Python பிழைகளை **`try`/`except`** blocks மூலம் கையாளுகிறது, கூடுதலாக விருப்பத்தேர்வு `else` மற்றும் `finally` உடன். Python **EAFP** கொள்கையைத் தழுவுகிறது — "Easier to Ask Forgiveness than Permission" — முதலில் நிபந்தனைகளைச் சரிபார்ப்பதைவிட ஒரு operation-ஐ முயற்சித்து exceptions-ஐ கையாள்வதை விரும்புகிறது.

## அடிப்படை அமைப்பு

```python
try:
    result = risky_operation()
except ValueError as e:           # catch a SPECIFIC exception type
    print(f"bad value: {e}")
except (KeyError, IndexError):    # catch multiple types
    print("lookup failed")
except Exception as e:            # catch-all (use sparingly, last)
    print(f"unexpected: {e}")
else:
    print("ran only if NO exception occurred")
finally:
    cleanup()                     # ALWAYS runs (success or failure)
```

- **`except SpecificError`** — குறிப்பிட்ட types-ஐ பிடிக்கவும் (வெறும் catch-all-ஐ விட விரும்பப்படுகிறது).
- **`else`** — எந்த exception-ம் எழுப்பப்படாவிட்டால் மட்டுமே இயங்குகிறது.
- **`finally`** — exception பரவினாலும் எப்போதும் இயங்குகிறது (cleanup, resources-ஐ விடுவித்தல்).

## EAFP vs LBYL — Pythonic பாணி

```python
# LBYL ("Look Before You Leap") — check first
if key in my_dict:
    value = my_dict[key]

# EAFP ("Easier to Ask Forgiveness") — try it, handle failure — more Pythonic
try:
    value = my_dict[key]
except KeyError:
    value = default
```

Python idiomatic-ஆக **EAFP**-ஐ விரும்புகிறது — operation-ஐ முயற்சித்து exception-ஐ பிடிக்கவும் — இது race conditions-ஐ தவிர்க்கிறது மற்றும் முன்-சரிபார்ப்பதைவிட பெரும்பாலும் தூய்மையானது.

## Raising மற்றும் custom exceptions

```python
if amount < 0:
    raise ValueError("amount must be positive")    # raise a built-in

class InsufficientFundsError(Exception):           # custom exception type
    pass
raise InsufficientFundsError("balance too low")
```

## சிறந்த நடைமுறைகள்

```python
# ❌ bare except hides bugs (catches EVERYTHING, even typos/KeyboardInterrupt)
try: ...
except: pass

# ✅ catch specific exceptions; re-raise what you can't handle
try: ...
except ValueError as e:
    logger.error(e)
    raise                  # re-raise to propagate
```

```text
✓ Catch SPECIFIC exceptions, not bare except
✓ Don't silently swallow errors (except: pass) — log or handle them
✓ Use finally / context managers (with) for cleanup
✓ Raise meaningful, specific exception types
```

## இது ஏன் முக்கியம்

நம்பகமான programs-க்கு உறுதியான பிழை கையாளுதல் இன்றியமையாதது, மேலும் Python-இன் அணுகுமுறையில் தெரிந்துகொள்ள வேண்டிய தனித்துவமான idioms உள்ளன: `try/except/else/finally` அமைப்பு, **EAFP** தத்துவம் (முதலில்-சரிபார்ப்பதைவிட முயற்சித்து-கையாளுதல், இது மிகவும் Pythonic மற்றும் race conditions-ஐ தவிர்க்கிறது), *குறிப்பிட்ட* exceptions-ஐ பிடித்தல் (bugs-ஐ மறைக்கும் வெறும் `except`-ஐ அல்ல), மற்றும் cleanup-க்கு `finally`/context managers-ஐ பயன்படுத்துதல்.

இவற்றைப் புரிந்துகொள்வது கையாளப்படாத பிழைகளால் ஏற்படும் crashes-ஐயும், அதிக-பரந்த அல்லது அமைதியான exception handling-ஆல் ஏற்படும் நுட்பமான, debug செய்வதற்கு கடினமான பிரச்சினைகளையும் தடுக்கிறது — நம்பகமற்ற code-இன் அடிக்கடி வரும் ஆதாரம்.