Python ਵਿੱਚ ਅਪਵਾਦ ਹੈਂਡਲਿੰਗ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ?

Question

IT Interview Practice · 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 — ਪਾਈਥਾਨਿਕ ਸ਼ੈਲੀ

```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 ਆਮ ਤੌਰ 'ਤੇ **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 ਦਾ ਤਰੀਕਾ ਵਿਲੱਖਣ ਰੂਪ ਹੈ: `try/except/else/finally` ਢਾਂਚਾ, **EAFP** ਦਰਸ਼ਨ (ਕੋਸ਼ਿਸ਼-ਅਤੇ-ਸੰਭਾਲੋ, ਜੋ ਵਧੇਰੇ ਪਾਈਥਾਨਿਕ ਹੈ), *ਖਾਸ* ਅਪਵਾਦਾਂ ਨੂੰ ਫੜਨਾ (ਉਦਾਹਰਨ ਲਈ `except`, ਬਗ ਨੂੰ ਲੁਕਾ ਦਿੰਦਾ ਹੈ), ਅਤੇ ਸਫਾਈ ਲਈ `finally`/context managers ਦੀ ਵਰਤੋਂ।

ਇਹ ਸਮਝਣਾ ਅਨੰਚਲੀ ਗਲਤੀਆਂ ਤੋਂ ਕਰੈਸ਼ ਅਤੇ ਸੂਖਮ, ਸਖ਼ਤ-ਡੀਬਗ ਸਮੱਸਿਆਵਾਂ ਦੋਨੋਂ ਨੂੰ ਰੋਕਦਾ ਹੈ — ਗੈਰ-ਭਰੋਸੇਮੰਦ ਕੋਡ ਦਾ ਇੱਕ ਘਣ ਸਰੋਤ।

ਮੂਲ ਢਾਂਚਾ

EAFP vs LBYL — ਪਾਈਥਾਨਿਕ ਸ਼ੈਲੀ

ਅਪਵਾਦਾਂ ਨੂੰ ਵਧਾਉਣਾ ਅਤੇ ਕਸਟਮ ਅਪਵਾਦ

ਸਵੋਤਮ ਅਭਿਆਸ

ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰਖਦਾ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ