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`** — विशिष्ट प्रकारहरु पकड गर्नुहोस् (खाली 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 भाषाविदतापूर्वक **EAFP** लाई समर्थन गर्छ — operation को प्रयास गर र exception पकड गर्नुहोस् — जो race conditions बेवास्ता गर्छ र प्राय: पूर्व-जाँच भन्दा सफा हुन्छ।

## उठाउन र अनुकूल 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
```

## यो किन महत्त्वपूर्ण छ

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

यो बुझ्नु ले सम्भालिएको त्रुटिहरूबाट क्र्यास र गहिरो, कठिन-डिबग समस्याहरू दुवै रोक्छ जो अत्यधिक विस्तृत वा मौन exception सम्भालनले गर्दा हुन्छ — अविश्वसनीय कोडको बारम्बार स्रोत।