Python లో exception handling ఎలా పని చేస్తుంది?

Question

Accepted Answer

Python **`try`/`except`** blocks ఉపయోగించి errors ను నిర్వహిస్తుంది, అలాగే optional `else` మరియు `finally` లను కూడా ఉపయోగిస్తుంది. Python **EAFP** సూత్రాన్ని అనుసరిస్తుంది — "Easier to Ask Forgiveness than Permission" — ఒక operation ను ప్రయత్నించి exceptions ను నిర్వహించడానికి condition లను ముందుగా చెక్ చేయడం కంటే ఇది ఇష్టపడుతుంది.

## Basic structure

```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`** — నిర్దిష్ట types ను catch చేయండి (bare catch-all కంటే ఇష్టపడుతారు).
- **`else`** — exception raise కాకపోతే మాత్రమే runs అవుతుంది.
- **`finally`** — ఎల్లప్పుడు runs అవుతుంది (cleanup, resources release చేయడం), exception propagate అయినా కూడా.

## EAFP vs LBYL — the Pythonic style

```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 ను catch చేయండి — ఇది race conditions ను avoid చేస్తుంది మరియు ప్రায়శः pre-checking కంటే cleaner ఉంటుంది.

## Raising and 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")
```

## Best practices

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

## ఇది ఎందుకు ముఖ్యమైనది

Robust error handling నిర్ভরమైన programs కోసం అవసరమైనది, మరియు Python యొక్క approach కి విభిన్న idioms ఉన్నాయి: `try/except/else/finally` structure, **EAFP** philosophy (try-and-handle rather than check-first, ఇది మరింత Pythonic మరియు race conditions ను avoid చేస్తుంది), *specific* exceptions ను catch చేయడం (bare `except` కాదు, ఇది bugs ను hide చేస్తుంది), మరియు cleanup కోసం `finally`/context managers ఉపయోగించడం.

ఈ విషయాలను అర్థం చేసుకోవడం unhandled errors నుండి crashes ను మరియు over-broad లేదా silent exception handling వల్ల సంభవించే subtle, hard-to-debug problems ను — ఇది unreliable code యొక్క ఫ్రీక్వెంట్ సోర్స్ — రెండింటినీ prevent చేస్తుంది.