Come funziona la gestione delle eccezioni in Python?

Question

Accepted Answer

Python gestisce gli errori con blocchi **`try`/`except`**, più `else` e `finally` opzionali. Python abbraccia il principio **EAFP** — "Easier to Ask Forgiveness than Permission" — preferendo tentare un'operazione e gestire le eccezioni piuttosto che controllare le condizioni per primo.

## Struttura di base

```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`** — cattura tipi specifici (meglio di un catch-all generico).
- **`else`** — eseguito solo se non è stata sollevata nessuna eccezione.
- **`finally`** — eseguito sempre (pulizia, rilascio risorse), anche se un'eccezione si propaga.

## EAFP vs LBYL — lo stile 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 favorisce idiomaticamente **EAFP** — tentare l'operazione e catturare l'eccezione — che evita le condizioni di gara ed è spesso più pulito del controllo preventivo.

## Sollevare e eccezioni personalizzate

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

## Buone pratiche

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

## Perché è importante

La gestione robusta degli errori è essenziale per programmi affidabili, e l'approccio di Python ha idiomi distinti da conoscere: la struttura `try/except/else/finally`, la filosofia **EAFP** (prova-e-gestisci piuttosto che controlla-per-primo, che è più Pythonic ed evita condizioni di gara), catturare eccezioni *specifiche* (non un semplice `except`, che nasconde i bug), e usare `finally`/context manager per la pulizia.

Comprendere questi punti previene gli arresti anomali da errori non gestiti e i problemi sottili e difficili da debuggare causati dalla gestione eccessivamente ampia o silenziosa delle eccezioni — una fonte frequente di codice inaffidabile.