Hoe werkt exception handling in Python?

Question

IT Interview Practice · Accepted Answer

Python handelt fouten af met **`try`/`except`** blokken, plus optionele `else` en `finally`. Python volgt het **EAFP** principe — "Easier to Ask Forgiveness than Permission" — waarbij het verkiest een operatie uit te voeren en uitzonderingen af te handelen boven het eerst controleren van voorwaarden.

## Basisstructuur

```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`** — vang specifieke typen op (voorkeur boven een blinde catch-all).
- **`else`** — wordt alleen uitgevoerd als geen uitzondering werd gegenereerd.
- **`finally`** — wordt altijd uitgevoerd (opschoning, bronnen vrijgeven), zelfs als een uitzondering zich verspreidt.

## EAFP vs LBYL — de Pythonische stijl

```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 geeft idiomatisch de voorkeur aan **EAFP** — probeer de operatie en vang de uitzondering — wat racecondities vermijdt en vaak schoner is dan vooraf controleren.

## Uitzonderingen gooien en aangepaste uitzonderingen

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

## Waarom het belangrijk is

Robuste foutafhandeling is essentieel voor betrouwbare programma's, en Python's aanpak heeft duidelijke idiomen die het waard zijn om te kennen: de `try/except/else/finally` structuur, de **EAFP** filosofie (proberen-en-afhandelen in plaats van eerst-controleren, wat meer Pythonisch is en racecondities vermijdt), specifieke uitzonderingen opvangen (niet blinde `except`, die bugs verbergt), en `finally`/context managers gebruiken voor opschoning.

Dit begrijpen voorkomt zowel crashes van onverwerkte fouten als subtiele, moeilijk debugbare problemen veroorzaakt door overmatige of stille afhandeling van uitzonderingen — een veelvoorkomende bron van onbetrouwbare code.

Basisstructuur

EAFP vs LBYL — de Pythonische stijl

Uitzonderingen gooien en aangepaste uitzonderingen

Best practices

Waarom het belangrijk is

Gerelateerde vragen