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.
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
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.
@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,returnkết quả và@functools.wraps. - Decorator có tham số cần thêm một tầng;
functools.cache,staticmethod,classmethodcó 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
- Viết decorator do_thoi_gian in thời gian chạy của hàm, giữ nguyên tên và docstring.
- 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.


