⭐ Python Developer · Chặng 5Bài 3/5Bài học~75 phút

Closure và decorator trong Python: wraps, lru_cache, retry

Hàm là đối tượng, closure giữ biến, cách viết decorator có tham số với functools.wraps, decorator đo thời gian, thử lại và lru_cache.

Closure và decorator trong Python: wraps, lru_cache, retry

Học xong bài này, bạn sẽ

  • Hiểu hàm là đối tượng và closure
  • Viết decorator có và không có tham số, dùng functools.wraps
  • Dùng decorator có sẵn: lru_cache, cache, property, staticmethod

Nên học trước: Iterator, generator và itertools

Nội dung bài viết
  1. 1. Hàm là đối tượng
  2. 2. Closure: hàm nhớ biến của nơi sinh ra nó
  3. 3. Decorator đầu tiên
  4. 4. Decorator có tham số
  5. 5. Decorator có sẵn nên biết
  6. Tóm tắt
  7. Bài tập

Bạn đã thấy @property, @dataclass, @abstractmethod. Ở chặng 9 bạn sẽ viết @app.get("/") trong FastAPI, ở chặng 6 là @pytest.fixture. Dấu @ đó là decorator: một hàm "bọc" hàm khác để thêm hành vi (đo thời gian, ghi log, thử lại, kiểm tra quyền) mà không sửa code bên trong. Để hiểu decorator, trước hết cần hiểu hàm là đối tượng và closure.

1. Hàm là đối tượng

def chao(ten):
    return f"Chào {ten}"


noi = chao                         # gán hàm cho biến khác (không có ngoặc: không gọi)
print(noi("An"), noi.__name__)


def ap_dung(ham, ds):              # hàm nhận hàm làm tham số
    return [ham(x) for x in ds]


print(ap_dung(str.upper, ["a", "b"]), ap_dung(len, ["xin", "chào"]))
Chào An chao
['A', 'B'] [3, 4]

Trong Python, hàm giống mọi giá trị khác: gán cho biến, truyền vào hàm, trả về từ hàm, đặt trong list hay dict. Bạn đã dùng điều này với sorted(key=...).

2. Closure: hàm nhớ biến của nơi sinh ra nó

def tao_bo_tinh_thue(ty_le):
    def tinh(gia):
        return round(gia * (1 + ty_le))     # dùng ty_le của hàm bên ngoài
    return tinh                             # trả về hàm bên trong


vat_8 = tao_bo_tinh_thue(0.08)
vat_10 = tao_bo_tinh_thue(0.10)
print(vat_8(100_000), vat_10(100_000))


def tao_bo_dem():
    dem = 0
    def tang():
        nonlocal dem                        # sửa biến của hàm bên ngoài
        dem += 1
        return dem
    return tang


dem_khach = tao_bo_dem()
dem_khach(); dem_khach()
print(dem_khach())
108000 110000
3

tao_bo_tinh_thue đã chạy xong, nhưng hàm tinh vẫn "nhớ" ty_le của lần gọi đã tạo ra nó. Hàm bên trong cùng các biến nó nhớ gọi là closure. Muốn gán lại biến bên ngoài, dùng nonlocal.

3. Decorator đầu tiên

import functools
import time


def do_thoi_gian(ham):
    @functools.wraps(ham)                      # giữ tên, docstring của hàm gốc
    def bao_boc(*args, **kwargs):
        bat_dau = time.perf_counter()
        ket_qua = ham(*args, **kwargs)         # gọi hàm gốc với đúng tham số
        tg = time.perf_counter() - bat_dau
        print(f"{ham.__name__} chạy {tg * 1000:.0f} ms")
        return ket_qua
    return bao_boc


@do_thoi_gian                                  # tương đương: tong_binh_phuong = do_thoi_gian(tong_binh_phuong)
def tong_binh_phuong(n):
    """Tổng bình phương 0..n-1."""
    return sum(i * i for i in range(n))


kq = tong_binh_phuong(2_000_000)               # kết quả thay đổi mỗi lần chạy
print(kq, tong_binh_phuong.__name__, tong_binh_phuong.__doc__)
tong_binh_phuong chạy 98 ms
2666664666667000000 tong_binh_phuong Tổng bình phương 0..n-1.

Decorator là hàm nhận một hàm và trả về một hàm (thường là closure bọc hàm gốc). Cú pháp @do_thoi_gian chỉ là cách viết gọn của phép gán lại tên. Ba điểm luôn phải có:

  • *args, **kwargs để bọc được hàm có bất kỳ tham số nào.
  • return ket_qua: quên dòng này thì mọi hàm được trang trí đều trả None.
  • @functools.wraps(ham): không có nó, tong_binh_phuong.__name__ thành "bao_boc", debugger, log và tài liệu đều hiện sai tên.

4. Decorator có tham số

Decorator thử lại khi gặp lỗi tạm thời (mạng chập chờn) rất hay dùng. Nó cần tham số: thử mấy lần, chờ bao lâu, với loại lỗi nào. Khi đó cần thêm một tầng hàm:

import functools
import time


def thu_lai(so_lan=3, cho=0.1, loi=(ConnectionError,)):
    def decorator(ham):
        @functools.wraps(ham)
        def bao_boc(*args, **kwargs):
            for lan in range(1, so_lan + 1):
                try:
                    return ham(*args, **kwargs)
                except loi as e:
                    if lan == so_lan:
                        raise                       # hết lượt: ném lại lỗi gốc
                    print(f"  lần {lan} lỗi: {e}; thử lại sau {cho}s")
                    time.sleep(cho)
        return bao_boc
    return decorator


so_lan_goi = 0

@thu_lai(so_lan=4, cho=0.01)
def lay_ty_gia():
    global so_lan_goi
    so_lan_goi += 1
    if so_lan_goi < 3:
        raise ConnectionError("máy chủ không phản hồi")
    return 25_350


print(lay_ty_gia())
  lần 1 lỗi: máy chủ không phản hồi; thử lại sau 0.01s
  lần 2 lỗi: máy chủ không phản hồi; thử lại sau 0.01s
25350

Đọc từ ngoài vào: thu_lai(so_lan=4, cho=0.01) chạy trước và trả về decorator; sau đó decorator(lay_ty_gia) trả về bao_boc. Ba tầng nghe phức tạp, nhưng đây là khuôn mẫu cố định, bạn chỉ thay phần thân của bao_boc. Ở chặng 7 bạn sẽ gắn decorator này vào hàm gọi Web API thật. (Biến global ở đây chỉ để giả lập lỗi; code thật không nên dùng.)

5. Decorator có sẵn nên biết

import functools


@functools.cache                     # ghi nhớ kết quả theo tham số (Python 3.9+)
def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)


print(fib(90))                       # không cache: hàng nghìn năm; có cache: tức thì
print(fib.cache_info().hits)


class NhietKe:
    def __init__(self, do_c):
        self.do_c = do_c

    @staticmethod                    # không cần self: hàm tiện ích đặt trong lớp
    def c_sang_f(c):
        return c * 9 / 5 + 32

    @classmethod                     # nhận lớp (cls) thay vì đối tượng: hàm tạo thay thế
    def tu_do_f(cls, f):
        return cls((f - 32) * 5 / 9)


print(NhietKe.c_sang_f(100), NhietKe.tu_do_f(212).do_c)
2880067194370816120
88
212.0 100.0

functools.cache (hoặc lru_cache(maxsize=128) để giới hạn bộ nhớ) chỉ dùng cho hàm thuần: cùng tham số luôn cho cùng kết quả, và tham số phải hash được. Đừng cache hàm đọc CSDL hay gọi API mà dữ liệu thay đổi.

Thứ tự nhiều decoratorViết @a rồi @b trên một hàm thì tương đương ham = a(b(ham)): decorator gần hàm nhất bọc trước. Khi kết hợp đo thời gian với thử lại, đặt @do_thoi_gian ở trên nếu muốn đo tổng thời gian kể cả các lần thử.

Tóm tắt

  • Hàm là đối tượng; closure là hàm bên trong nhớ biến của hàm bên ngoài; nonlocal để gán lại.
  • Decorator: hàm nhận hàm, trả hàm; @deco = ham = deco(ham).
  • Luôn có *args, **kwargs, return kết quả và @functools.wraps.
  • Decorator có tham số cần thêm một tầng; functools.cache, staticmethod, classmethod có sẵn.

Bài tập

Bài 1. Decorator ghi log lời gọi

Viết decorator ghi_log in tên hàm, tham số và kết quả của mỗi lần gọi, giữ nguyên tên và docstring.

Xem đáp án
import functools


def ghi_log(ham):
    @functools.wraps(ham)
    def bao_boc(*args, **kwargs):
        cac_ts = [repr(a) for a in args] + [f"{k}={v!r}" for k, v in kwargs.items()]
        ket_qua = ham(*args, **kwargs)
        print(f"{ham.__name__}({', '.join(cac_ts)}) → {ket_qua!r}")
        return ket_qua
    return bao_boc


@ghi_log
def chia_deu(tong, so_nguoi, lam_tron=1000):
    """Chia tiền đều, làm tròn lên đến lam_tron đồng."""
    return -(-tong // (so_nguoi * lam_tron)) * lam_tron


chia_deu(1_250_000, 3)
chia_deu(500_000, so_nguoi=4, lam_tron=500)
print(chia_deu.__name__, "|", chia_deu.__doc__)
chia_deu(1250000, 3) → 417000
chia_deu(500000, so_nguoi=4, lam_tron=500) → 125000
chia_deu | Chia tiền đều, làm tròn lên đến lam_tron đồng.

-(-a // b) là mẹo chia làm tròn lên bằng số nguyên, không cần math.ceil và không dính sai số số thực.

Bài 2. Thử lại có điều kiện

Dùng thu_lai ở mục 4 cho một hàm luôn ném ConnectionError, với so_lan=2. Xác nhận lỗi cuối cùng được ném ra ngoài, và một hàm ném ValueError thì không được thử lại.

Xem đáp án
import functools
import time


def thu_lai(so_lan=3, cho=0.1, loi=(ConnectionError,)):
    def decorator(ham):
        @functools.wraps(ham)
        def bao_boc(*args, **kwargs):
            for lan in range(1, so_lan + 1):
                try:
                    return ham(*args, **kwargs)
                except loi:
                    if lan == so_lan:
                        raise
                    time.sleep(cho)
        return bao_boc
    return decorator


dem = {"mang": 0, "du_lieu": 0}

@thu_lai(so_lan=2, cho=0)
def luon_mat_mang():
    dem["mang"] += 1
    raise ConnectionError("mất mạng")

@thu_lai(so_lan=5, cho=0)
def du_lieu_sai():
    dem["du_lieu"] += 1
    raise ValueError("dữ liệu sai")

for ham in (luon_mat_mang, du_lieu_sai):
    try:
        ham()
    except (ConnectionError, ValueError) as e:
        print(type(e).__name__, e)
print(dem)
ConnectionError mất mạng
ValueError dữ liệu sai
{'mang': 2, 'du_lieu': 1}

Chỉ thử lại lỗi tạm thời (mạng, máy chủ quá tải). Lỗi dữ liệu thử lại bao nhiêu lần cũng vẫn sai, nên phải ném ra ngay: đó là lý do tham số loi giới hạn loại ngoại lệ.

Nguồn tham khảo: Glossary: decorator; functools; PEP 318: Decorators for Functions and Methods.

Bài tập thực hành

  1. Viết decorator do_thoi_gian in thời gian chạy của hàm, giữ nguyên tên và docstring.
  2. Viết decorator thu_lai(so_lan, cho=0.5) gọi lại hàm khi gặp ngoại lệ chỉ định.

Làm xong bài tập mới chuyển sang bài tiếp theo: tự viết code là cách duy nhất để nhớ lâu.

Bài tiếp theo
Ban biên tập HocFree

Chúng tôi viết những bài hướng dẫn dễ hiểu, thực tế để ai cũng có thể tự học lập trình và AI, hoàn toàn miễn phí.