Python માં એક્સેપ્શન હેન્ડલિંગ કેવી રીતે કામ કરે છે?

Question

Accepted Answer

Python **`try`/`except`** બ્લૉક્સ સાથે, વધુમાં વૈકલ્પિક `else` અને `finally` સાથે ભૂલો સંભાળે છે. Python **EAFP** સિદ્ધાંતને આલિંગન કરે છે — "Easier to Ask Forgiveness than Permission" — પ્રથમ શરતોને તપાસવાના બદલે ઑપરેશન પર પ્રયાસ કરવાને અને અપવાદો સંભાળવાને પ્રાધાન્ય આપે છે.

## મૂળ માળખું

```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`** — ચોક્કસ પ્રકારો પકડો (શુદ્ધ કેચ-ઓલ કરતાં વધુ સારું).
- **`else`** — માત્ર તો જ ચાલે છે જો કોઈ અપવાદ ઊભો નહીં થયો હોય.
- **`finally`** — હંમેશા ચાલે છે (સાફ કરો, સંસાધનો છોડો), જો કે અપવાદ ફેલાય તો પણ.

## 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** ને પસંદ કરે છે — ઑપરેશન પર પ્રયાસ કરો અને અપવાદ પકડો — જે રેસ પરિસ્થિતિઓ ટાળે છે અને ઘણીવાર પૂર્વ-તપાસ કરતાં શુદ્ધ છે.

## અપવાદો ઊભો કરવા અને કસ્ટમ અપવાદો

```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
```

## તે શા માટે મહત્વપૂર્ણ છે

મજબૂત ભૂલ સંભાળ વિશ્વસનીય પ્રોગ્રામ્સ માટે આવશ્યક છે, અને Python નો અભિગમ અલગ idioم સાથે છે: `try/except/else/finally` માળખું, **EAFP** તત્વજ્ઞાન (પ્રયાસ-અને-સંભાળ બદલે તપાસો-પ્રથમ, જે વધુ Pythonic છે અને રેસ પરિસ્થિતિઓ ટાળે છે), *ચોક્કસ* અપવાદો પકડવા (શુદ્ધ `except` નહીં, જે બગ છુપાવે છે), અને સાફ કરવા માટે `finally`/context managers નો ઉપયોગ.

આ બાબતોને સમજવું અનુપચારિત ભૂલોમાંથી ક્રેશ કરવાને અટકાવે છે અને અતિશય-વ્યાપક અથવા મૌન અપવાદ સંભાળવાથી ઉદ્ભવતી સૂક્ષ્ମ, હાર્ડ-ટુ-ડીબગ સમસ્યાઓ — અવિશ્વસનીય કોડનો વારંવાર સ્ત્રોત.