Python中的异常处理是如何工作的？

Question

Python中的异常处理是如何工作的？

Accepted Answer

Python 使用 **`try`/`except`** 块处理错误，加上可选的 `else` 和 `finally`。Python 遵循 **EAFP** 原则 — "易求原谅，不求许可" — 倾向于尝试执行操作并处理异常，而不是预先检查条件。

## 基本结构

```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`** — 仅在未抛出异常时运行。
- **`finally`** — 总是运行（清理、释放资源），即使异常继续传播。

## EAFP vs LBYL — Python风格

```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** — 尝试执行操作并捕获异常 — 这避免了竞态条件，通常比预先检查更清晰。

## 抛出和自定义异常

```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 的方法有独特的习惯用法值得了解：`try/except/else/finally` 结构、**EAFP** 哲学（尝试并处理而非预先检查，这更符合 Python 风格并避免竞态条件）、捕获 *特定* 异常（不要用裸 `except`，这会隐藏 bug），以及使用 `finally`/上下文管理器进行清理。

理解这些原则可以防止两类问题：未处理异常导致的崩溃，以及由过度宽泛或静默异常处理引起的微妙、难以调试的问题 — 这是不可靠代码的常见根源。