Python में exception handling कैसे काम करता है?

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`** — विशिष्ट प्रकारों को पकड़ें (केवल catch-all से बेहतर)।
- **`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** को पसंद करता है — ऑपरेशन को आजमाएं और अपवाद को पकड़ें — जो race conditions से बचता है और अक्सर पूर्व-जांच से ज्यादा स्वच्छ होता है।

## अपवादों को बढ़ाना और कस्टम अपवाद

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

## यह क्यों मायने रखता है

मजबूत error handling विश्वसनीय प्रोग्राम्स के लिए आवश्यक है, और Python का दृष्टिकोण विशिष्ट idioms के साथ आता है: `try/except/else/finally` संरचना, **EAFP** दर्शन (जांच-पहले की बजाय try-and-handle, जो अधिक Pythonic है और race conditions से बचता है), *विशिष्ट* अपवादों को पकड़ना (bare `except` नहीं, जो bugs को छुपाता है), और सफाई के लिए `finally`/context managers का उपयोग करना।

इन बातों को समझना असंभाले त्रुटियों से crashes को रोकता है और over-broad या silent exception handling से आने वाली सूक्ष्म, मुश्किल-से-debug समस्याओं — अविश्वसनीय code का एक लगातार स्रोत।

बुनियादी संरचना

EAFP vs LBYL — Pythonic शैली

अपवादों को बढ़ाना और कस्टम अपवाद

सर्वोत्तम प्रथाएं

यह क्यों मायने रखता है

संबंधित प्रश्न