Python मध्ये exception handling कसे काम करते?

Question

Accepted Answer

Python **`try`/`except`** blocks वापरून errors हाताळते, तसेच वैकल्पिक `else` आणि `finally`. Python **EAFP** तत्त्वाला मान्यता देते — "परवानगी मागणे सोपे आहे परवानगी विचारण्यापेक्षा" — प्रथम शर्तांची तपासणी करण्याऐवजी 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`** — विशिष्ट प्रकार पकडा (bare catch-all पेक्षा प्राधान्यसूची).
- **`else`** — फक्त तेव्हा चालवा जर कोणता exception उपस्थित न असेल.
- **`finally`** — नेहमी चालवा (सफाई, संसाधने मुक्त करणे), जरी exception पसरत असेल.

## 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 idiomatically **EAFP** ला समर्थन देते — operation वाढवण्याचा प्रयत्न करा आणि exception पकडा — ज्यामुळे रेस 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
```

## हे का महत्वाचे आहे

मजबूत error handling विश्वासार्ह कार्यक्रमांसाठी आवश्यक आहे, आणि Python च्या पद्धतीचे विशिष्ट idioms आहेत जे जाणून घेतले पाहिजेत: `try/except/else/finally` संरचना, **EAFP** तत्त्वज्ञान (प्रथम तपासण्याऐवजी प्रयत्न-आणि-हाताळा, जे अधिक Pythonic आहे आणि रेस conditions टाळते), विशिष्ट exceptions पकडा (*bare `except` नाही, जे bugs लपवते), आणि सफाईसाठी `finally`/context managers वापरा.

हे समजणे अनुपचारित errors पासून crash होणे आणि over-broad किंवा silent exception handling मुळे होणारी सूक्ष्म, hard-to-debug समस्या दोन्ही प्रतिबंधित करते — अविश्वसनीय code चा वारंवार स्रोत.