Xử lý ngoại lệ trong Python hoạt động như thế nào?

Question

Accepted Answer

Python xử lý lỗi bằng các khối **`try`/`except`**, cộng với `else` và `finally` tùy chọn. Python áp dụng nguyên tắc **EAFP** — "Easier to Ask Forgiveness than Permission" (Dễ xin tha thứ hơn xin phép) — ưa chuộng việc thử một thao tác và xử lý ngoại lệ thay vì kiểm tra điều kiện trước.

## Cấu trúc cơ bản

```python
try:
    result = risky_operation()
except ValueError as e:           # bắt một kiểu ngoại lệ CỤ THỂ
    print(f"bad value: {e}")
except (KeyError, IndexError):    # bắt nhiều kiểu
    print("lookup failed")
except Exception as e:            # bắt tất cả (dùng dè dặt, đặt cuối)
    print(f"unexpected: {e}")
else:
    print("ran only if NO exception occurred")
finally:
    cleanup()                     # LUÔN chạy (dù thành công hay thất bại)
```

- **`except SpecificError`** — bắt các kiểu cụ thể (ưu tiên hơn bắt tất cả trống).
- **`else`** — chạy chỉ khi không có ngoại lệ nào được ném ra.
- **`finally`** — luôn chạy (dọn dẹp, giải phóng tài nguyên), ngay cả khi một ngoại lệ lan truyền.

## EAFP vs LBYL — phong cách Pythonic

```python
# LBYL ("Look Before You Leap") — kiểm tra trước
if key in my_dict:
    value = my_dict[key]

# EAFP ("Easier to Ask Forgiveness") — thử nó, xử lý thất bại — Pythonic hơn
try:
    value = my_dict[key]
except KeyError:
    value = default
```

Python theo phong cách ưa chuộng **EAFP** — thực hiện thao tác và bắt ngoại lệ — điều này tránh được race condition và thường gọn gàng hơn việc kiểm tra trước.

## Ném và ngoại lệ tùy chỉnh

```python
if amount < 0:
    raise ValueError("amount must be positive")    # ném một ngoại lệ dựng sẵn

class InsufficientFundsError(Exception):           # kiểu ngoại lệ tùy chỉnh
    pass
raise InsufficientFundsError("balance too low")
```

## Các thực hành tốt nhất

```python
# ❌ except trống che giấu lỗi (bắt MỌI THỨ, kể cả lỗi gõ/KeyboardInterrupt)
try: ...
except: pass

# ✅ bắt các ngoại lệ cụ thể; ném lại những gì bạn không thể xử lý
try: ...
except ValueError as e:
    logger.error(e)
    raise                  # ném lại để lan truyền
```

```text
✓ Bắt các ngoại lệ CỤ THỂ, không dùng except trống
✓ Đừng âm thầm nuốt lỗi (except: pass) — log hoặc xử lý chúng
✓ Dùng finally / context manager (with) để dọn dẹp
✓ Ném các kiểu ngoại lệ có ý nghĩa, cụ thể
```

## Tại sao điều này quan trọng

Xử lý lỗi vững chắc là thiết yếu cho các chương trình đáng tin cậy, và cách tiếp cận của Python có những thành ngữ riêng đáng biết: cấu trúc `try/except/else/finally`, triết lý **EAFP** (thử-và-xử-lý thay vì kiểm-tra-trước, vốn Pythonic hơn và tránh race condition), bắt các ngoại lệ *cụ thể* (không dùng `except` trống vốn che giấu lỗi), và dùng `finally`/context manager để dọn dẹp.

Hiểu những điều này ngăn được cả việc crash do lỗi không được xử lý lẫn các vấn đề tinh vi, khó gỡ lỗi gây ra bởi việc xử lý ngoại lệ quá rộng hoặc âm thầm — một nguồn thường gặp của code không đáng tin cậy.