🌱 [Python] 15 - Decorators — Cách hoạt động & ví dụ thực tế

byNguyễn Văn Nghĩa -
0

🌱 [Python] 15 - Decorators — Cách hoạt động & ví dụ thực tế

    Decorators trong Python là một trong những công cụ mạnh mẽ nhất của ngôn ngữ này. Chúng cho phép bạn mở rộng hoặc thay đổi hành vi của function/class mà không cần chỉnh sửa trực tiếp code gốc. Hiểu rõ về decorators sẽ là tiền đề giúp bạn nắm vững các framework như Flask, Django, hay pytest.

📚 Mục lục

1 - Decorator, cú pháp và cách hoạt động?

    Decorator là một hàm nhận vào một hàm khác như đối số và trả về một hàm mới với hành vi được mở rộng. Nó thường được sử dụng để thêm logic logging, kiểm tra quyền, đo thời gian thực thi, caching, v.v...

  1. def decorator_func(func):
  2.     def wrapper():
  3.         print("Before function call")
  4.         func()
  5.         print("After function call")
  6.     return wrapper

  8. @decorator_func
  9. def say_hello():
  10.     print("Hello!")

  12. say_hello()
  13. # Output:
  14. # Before function call
  15. # Hello!
  16. # After function call

Cú pháp và cách hoạt động

    Khi bạn viết @decorator_func trên một hàm, Python sẽ tự động thực hiện: say_hello = decorator_func(say_hello). Vì vậy decorator thực chất chỉ là cách viết ngắn gọn, giúp code dễ đọc hơn.

2 - Stacking & Multiple Decorators

    Bạn có thể chồng nhiều decorator lên cùng một hàm. Chúng được áp dụng (được "gắn") từ trên xuống dưới tại thời điểm định nghĩa hàm, nhưng khi gọi, các wrapper chạy theo thứ tự ngược lại (tức là từ dưới lên).

  1. def deco1(f):
  2.     def wrap():
  3.         print("deco1")
  4.         f()
  5.     return wrap

  7. def deco2(f):
  8.     def wrap():
  9.         print("deco2")
  10.         f()
  11.     return wrap

  13. @deco1
  14. @deco2
  15. def hello():
  16.     print("hello")

  18. hello()
  19. # Output:
  20. # deco1
  21. # deco2
  22. # hello

    ↪ Giải thích chi tiết:
  • Thời điểm "decoration" (khi Python đọc định nghĩa hàm):
    • Khi Python gặp @deco2 phía trên def hello, nó thực hiện hello = deco2(hello). Kết quả là hello trở thành hàm wrap trả về từ deco2.
    • Sau đó gặp @deco1, Python thực hiện hello = deco1(hello), tức hello giờ là hàm wrap trả về từ deco1, và bên trong nó giữ một tham chiếu tới hàm được trả về bởi deco2.
    • Nên thứ tự gắn là: hello = deco1(deco2(hello_original)).
  • Thời điểm gọi (call time):
    • Khi bạn gọi hello(), bạn đang gọi wrapper bên ngoài (do deco1 tạo). Bên ngoài in deco1, sau đó gọi hàm nội tại (chính là wrapper được tạo bởi deco2).
    • Wrapper của deco2 in deco2, rồi gọi hàm gốc hello (in hello).
    • Kết quả thực thi theo chuỗi: deco1 → deco2 → hello.
  • Vấn đề thường gặp:
    • Nếu wrapper không chấp nhận *args, **kwargs nhưng hàm gốc có tham số, sẽ xảy ra TypeError. Luôn viết wrapper dạng tổng quát nếu muốn áp dụng cho nhiều hàm khác nhau.
    • Nếu không dùng functools.wraps, metadata của hàm (như __name__, __doc__, signature) sẽ mất — làm khó debug và introspection.

Phiên bản cải tiến (an toàn hơn, general-purpose):

  1. from functools import wraps

  3. def deco1(f):
  4.     @wraps(f)
  5.     def wrap(*args, **kwargs):
  6.         print("deco1")
  7.         return f(*args, **kwargs)
  8.     return wrap

  10. def deco2(f):
  11.     @wraps(f)
  12.     def wrap(*args, **kwargs):
  13.         print("deco2")
  14.         return f(*args, **kwargs)
  15.     return wrap

  17. @deco1
  18. @deco2
  19. def hello():
  20.     print("hello")

  22. hello()
  23. # Output:
  24. # deco1
  25. # deco2
  26. # hello

    Với *args, **kwargs và @wraps, decorator an toàn hơn và giữ metadata.

3 - Decorator có tham số

    Khi bạn muốn truyền tham số cho decorator (ví dụ @repeat(3)), cần một "decorator factory": hàm ngoài nhận tham số và trả về một decorator thực sự.

  1. def repeat(n):
  2.     def decorator(func):
  3.         def wrapper(*args, **kwargs):
  4.             for _ in range(n):
  5.                 func(*args, **kwargs)
  6.         return wrapper
  7.     return decorator

  9. @repeat(3)
  10. def greet():
  11.     print("Hi!")

  13. greet()
  14. # Output: Hi! (in ra 3 lần)

Giải thích chi tiết:
  • Cấu trúc ba lớp:
    1. repeat(n) là hàm factory ➜ lúc này gọi repeat(3) và nhận về một decorator.
    2. decorator(func) là decorator thực sự ➜ nhận hàm cần bọc và trả về wrapper.
    3. wrapper(*args, **kwargs) là hàm wrapper khi gọi ➜ thực hiện logic lặp n lần rồi gọi hàm gốc.
  • Closure: giá trị n được "bắt" (captured) trong closure của wrapper, nên wrapper nhớ số lần lặp mà bạn cấu hình tại thời điểm sử dụng decorator.
  • Trả về giá trị:
    • Trong ví dụ trên, wrapper không trả về kết quả của hàm gốc (mặc định trả None), vì ta gọi hàm gốc nhiều lần và bỏ qua kết quả. Nếu hàm gốc có giá trị trả về quan trọng, bạn cần xác định hành vi mong muốn (ví dụ: trả về kết quả lần cuối, trả list các kết quả, hoặc gộp kết quả).
  • Phiên bản cải tiến (trả về kết quả lần cuối và bảo toàn metadata):
    1. from functools import wraps

    3. def repeat(n):
    4.     def decorator(func):
    5.         @wraps(func)
    6.         def wrapper(*args, **kwargs):
    7.             result = None
    8.             for _ in range(n):
    9.                 result = func(*args, **kwargs)
    10.             return result
    11.         return wrapper
    12.     return decorator

    14. @repeat(3)
    15. def greet():
    16.     print("Hi!")

    18. greet()
    19. # Output: Hi! (in ra 3 lần)

    Ở đây wrapper trả result từ lần gọi cuối cùng, phù hợp khi hàm có side-effect và bạn muốn kết quả cuối cùng.

  • Lưu ý:
    • Nếu hàm gốc có side-effect (ví dụ gửi request), lặp nhiều lần có thể không mong muốn → cần cân nhắc (exponential backoff, stop-on-success...).
    • Đối với các hàm IO/Network, thường kết hợp retry với delay/backoff và điều kiện dừng (stop-on-success hoặc chỉ retry với các exception cụ thể).

4 - Class Decorators

    Decorator cũng có thể được viết bằng class, rất hữu ích khi bạn muốn lưu trạng thái giữa các lần gọi (ví dụ đếm số lần gọi). Class decorator hoạt động vì class là callable (khi cài __call__).

  1. class Counter:
  2.     def __init__(self, func):
  3.         self.func = func
  4.         self.count = 0

  6.     def __call__(self, *args, **kwargs):
  7.         self.count += 1
  8.         print(f"Call {self.count}")
  9.         return self.func(*args, **kwargs)

  11. @Counter
  12. def hello():
  13.     print("Hi")

  15. hello()
  16. hello()
  17. # Output:
  18. # Call 1
  19. # Hi
  20. # Call 2
  21. # Hi

Giải thích chi tiết:
  • Khi áp dụng @Counter:
    • Python gọi Counter(hello) → tức là tạo một instance của class Counter và truyền hàm gốc vào __init__.
    • Instance trả về được gán thay cho tên hàm hello. Vì instance có phương thức __call__, nó trở thành một callable thay thế cho hàm ban đầu.
  • Trạng thái được lưu: Giá trị self.count nằm trên instance decorator, vì vậy nó tồn tại và được tăng dần qua nhiều lần gọi, đây là lợi ích chính của decorator dạng class so với hàm: dễ lưu state.
  • Gọi hàm: Khi bạn gọi hello(), thực tế Python gọi Counter_instance.__call__(). Trong __call__ ta tăng bộ đếm rồi gọi self.func(*args, **kwargs) để thực thi hàm gốc.
  • Preserve metadata / best practice:
    • Để giữ metadata (tên hàm, docstring), trong __init__ bạn nên gọi functools.update_wrapper(self, func) hoặc dùng wraps(func)(self). Nếu không, introspection (ví dụ help() hoặc inspect.signature()) sẽ thấy instance thay vì hàm gốc.
    from functools import update_wrapper

    class Counter:
        def __init__(self, func):
            self.func = func
            self.count = 0
            update_wrapper(self, func)   # copy __name__, __doc__...
        def __call__(self, *args, **kwargs):
            self.count += 1
            print(f"Call {self.count}")
            return self.func(*args, **kwargs)
  • Concurrency / Thread-safety:
    • Nếu ứng dụng đa luồng, self.count += 1 có thể race condition. Nếu cần chính xác, thêm khóa (lock) để bảo vệ state.
  • Ưu điểm của cách làm này là dễ lưu lại trạng thái, có thể chứa nhiều logic phức tạp, cấu trúc rõ ràng. Tuy nhiên, instance thay thế cho hàm nên đôi khi làm khó debug nếu không dùng update_wrapper; chi phí nhỏ hơn so với function decorator về readability trong một số trường hợp.
Tổng kết nhanh / checklist khi viết decorator:
  • Dùng *args, **kwargs trong wrapper để tương thích với mọi signature.
  • Dùng functools.wraps (hoặc functools.update_wrapper) để bảo toàn metadata.
  • Quan tâm đến thứ tự khi chồng decorator → thứ tự gắn ≠ thứ tự chạy.
  • Với decorator có tham số, nhớ pattern factory → decorator → wrapper.
  • Nếu cần lưu state, cân nhắc dùng class-based decorator và xử lý thread-safety nếu cần.
  • Luôn cân nhắc return value khi wrapper gọi hàm nhiều lần (ví dụ repeat/retry): phải rõ ràng trả cái gì.

5 - Xây dựng decorator retry hoàn chỉnh (với backoff & logging)

    Một use-case thực tế của decorator là xử lý retry cho các thao tác có thể thất bại tạm thời, như request HTTP hoặc truy cập database. Dưới đây là một ví dụ hoàn chỉnh có hỗ trợ retry count, delay tăng dần (exponential backoff), và logging.

  1. import time
  2. import logging

  4. logging.basicConfig(level=logging.INFO)

  6. def retry(max_attempts=3, backoff=1.0):
  7.     def decorator(func):
  8.         def wrapper(*args, **kwargs):
  9.             attempt = 1
  10.             delay = backoff
  11.             while attempt <= max_attempts:
  12.                 try:
  13.                     return func(*args, **kwargs)
  14.                 except Exception as e:
  15.                     logging.warning(f"Attempt {attempt} failed: {e}")
  16.                     if attempt == max_attempts:
  17.                         logging.error("Max retries exceeded")
  18.                         raise
  19.                     time.sleep(delay)
  20.                     delay *= 2  # exponential backoff
  21.                     attempt += 1
  22.         return wrapper
  23.     return decorator

  25. @retry(max_attempts=4, backoff=0.5)
  26. def unstable_func():
  27.     import random
  28.     if random.random() < 0.7:
  29.         raise ValueError("Random failure")
  30.     print("Success!")

  32. unstable_func()

    Trong ví dụ trên: – Hàm sẽ retry tối đa 4 lần, mỗi lần lỗi sẽ chờ lâu hơn gấp đôi trước khi thử lại. Tất cả kết quả được log ra console. Đây là một pattern rất phổ biến khi xử lý API, network hoặc sensor data.

Unit test mẫu:

  1. import unittest

  3. class TestRetryDecorator(unittest.TestCase):
  4.     def test_success(self):
  5.         calls = {"count": 0}
  6.         @retry(max_attempts=3)
  7.         def func():
  8.             calls["count"] += 1
  9.             if calls["count"] < 2:
  10.                 raise ValueError("fail")
  11.             return "ok"

  13.         result = func()
  14.         self.assertEqual(result, "ok")
  15.         self.assertEqual(calls["count"], 2)

  17. if __name__ == "__main__":
  18.     unittest.main()

6 - Kết luận

    Decorators là một phần quan trọng trong Python giúp code sạch, dễ mở rộng và có khả năng tái sử dụng cao. Khi hiểu cách chúng hoạt động, bạn có thể áp dụng để viết logging, retry, validation, hoặc các pattern phức tạp khác một cách hiệu quả.

>>>>>> Follow ngay <<<<<<<

Để nhận được những bài học miễn phí mới nhất nhé 😊
 Chúc các bạn học tập tốt 😊

Tags:
Nguyễn Văn Nghĩa

Mình là một người thích học hỏi và chia sẻ các kiến thức về Nhúng IOT.

Đăng nhận xét

Mới hơn Cũ hơn
//