Decorators (Hàm trang trí)

Decorator là một pattern thiết kế cho phép thêm chức năng mới vào một hàm hoặc class mà không cần thay đổi code gốc của chúng. Decorator trong Python sử dụng ký hiệu @ đặt trước hàm hoặc class.

1. Giới thiệu về Decorators

Vấn đề cần giải quyết


# Không dùng decorator - Code lặp lại
def say_hello():
    print("--- Start ---")
    print("Hello!")
    print("--- End ---")
 
def say_goodbye():
    print("--- Start ---")
    print("Goodbye!")
    print("--- End ---")
 
# Code "--- Start ---" và "--- End ---" bị lặp lại!

Giải pháp với Decorator


# Decorator tự động thêm "--- Start ---" và "--- End ---"
def add_border(func):
    def wrapper():
        print("--- Start ---")
        func()
        print("--- End ---")
    return wrapper
 
@add_border
def say_hello():
    print("Hello!")
 
@add_border
def say_goodbye():
    print("Goodbye!")
 
say_hello()
# --- Start ---
# Hello!
# --- End ---
 
say_goodbye()
# --- Start ---
# Goodbye!
# --- End ---

Cách hoạt động


# Khi viết:
@add_border
def say_hello():
    print("Hello!")
 
# Tương đương với:
def say_hello():
    print("Hello!")
say_hello = add_border(say_hello)

2. Decorator cơ bản

Decorator đơn giản


def my_decorator(func):
    def wrapper():
        print("Something before the function")
        func()
        print("Something after the function")
    return wrapper
 
@my_decorator
def greet():
    print("Hello, World!")
 
greet()
# Something before the function
# Hello, World!
# Something after the function

Decorator với tham số


def my_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with args: {args}, kwargs: {kwargs}")
        result = func(*args, **kwargs)
        print(f"Result: {result}")
        return result
    return wrapper
 
@my_decorator
def add(a, b):
    return a + b
 
@my_decorator
def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"
 
add(5, 3)
# Calling add with args: (5, 3), kwargs: {}
# Result: 8
 
greet("Alice", greeting="Hi")
# Calling greet with args: ('Alice',), kwargs: {'greeting': 'Hi'}
# Result: Hi, Alice!

3. Decorator thực tế

Decorator đo thời gian thực thi


import time
 
def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} took {end_time - start_time:.4f} seconds")
        return result
    return wrapper
 
@timer
def slow_function():
    time.sleep(2)
    return "Done!"
 
@timer
def calculate_sum(n):
    total = sum(range(n))
    return total
 
result = slow_function()  # slow_function took 2.0012 seconds
print(result)             # Done!
 
total = calculate_sum(1000000)  # calculate_sum took 0.0234 seconds
print(total)                     # 499999500000

Decorator logging


def log(func):
    def wrapper(*args, **kwargs):
        print(f"[LOG] Calling function: {func.__name__}")
        print(f"[LOG] Arguments: args={args}, kwargs={kwargs}")
        result = func(*args, **kwargs)
        print(f"[LOG] Return value: {result}")
        return result
    return wrapper
 
@log
def divide(a, b):
    return a / b
 
result = divide(10, 2)
# [LOG] Calling function: divide
# [LOG] Arguments: args=(10, 2), kwargs={}
# [LOG] Return value: 5.0

Decorator kiểm tra quyền truy cập


def require_permission(permission):
    def decorator(func):
        def wrapper(user, *args, **kwargs):
            if user.get("permission") == permission:
                return func(user, *args, **kwargs)
            else:
                return f"Permission denied. Required: {permission}"
        return wrapper
    return decorator
 
@require_permission("admin")
def delete_user(user, user_id):
    return f"User {user_id} deleted by {user['name']}"
 
@require_permission("editor")
def edit_post(user, post_id):
    return f"Post {post_id} edited by {user['name']}"
 
# Test
admin = {"name": "Alice", "permission": "admin"}
editor = {"name": "Bob", "permission": "editor"}
viewer = {"name": "Charlie", "permission": "viewer"}
 
print(delete_user(admin, 123))    # User 123 deleted by Alice
print(delete_user(editor, 123))   # Permission denied. Required: admin
print(edit_post(editor, 456))     # Post 456 edited by Bob
print(edit_post(viewer, 456))     # Permission denied. Required: editor

Decorator cache/memoization


def memoize(func):
    cache = {}
 
    def wrapper(*args):
        if args in cache:
            print(f"Returning cached result for {args}")
            return cache[args]
 
        print(f"Calculating result for {args}")
        result = func(*args)
        cache[args] = result
        return result
 
    return wrapper
 
@memoize
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)
 
print(fibonacci(5))
# Calculating result for (5,)
# Calculating result for (4,)
# Calculating result for (3,)
# Calculating result for (2,)
# Calculating result for (1,)
# Calculating result for (0,)
# Returning cached result for (1,)
# Returning cached result for (2,)
# 5
 
print(fibonacci(5))  # Returning cached result for (5,)

4. Decorator với tham số

Decorator factory


def repeat(times):
    """Decorator nhận tham số: số lần lặp lại"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator
 
@repeat(times=3)
def greet(name):
    print(f"Hello, {name}!")
 
greet("Alice")
# Hello, Alice!
# Hello, Alice!
# Hello, Alice!
 
@repeat(times=5)
def say_hi():
    print("Hi!")
 
say_hi()
# Hi!
# Hi!
# Hi!
# Hi!
# Hi!

Decorator với prefix


def prefix_decorator(prefix):
    def decorator(func):
        def wrapper(*args, **kwargs):
            result = func(*args, **kwargs)
            return f"{prefix}: {result}"
        return wrapper
    return decorator
 
@prefix_decorator("INFO")
def get_status():
    return "System running"
 
@prefix_decorator("ERROR")
def get_error():
    return "Something went wrong"
 
print(get_status())  # INFO: System running
print(get_error())   # ERROR: Something went wrong

Decorator validate input


def validate_positive(func):
    def wrapper(x):
        if x < 0:
            raise ValueError("Input must be positive")
        return func(x)
    return wrapper
 
def validate_range(min_val, max_val):
    def decorator(func):
        def wrapper(x):
            if not (min_val <= x <= max_val):
                raise ValueError(f"Input must be between {min_val} and {max_val}")
            return func(x)
        return wrapper
    return decorator
 
@validate_positive
def square_root(x):
    return x ** 0.5
 
@validate_range(0, 100)
def percentage_to_grade(score):
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    else:
        return "F"
 
print(square_root(16))  # 4.0
# print(square_root(-4))  # ValueError: Input must be positive
 
print(percentage_to_grade(85))  # B
# print(percentage_to_grade(150))  # ValueError: Input must be between 0 and 100

5. Nhiều Decorators (Stacking)

Áp dụng nhiều decorators


def bold(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return f"<b>{result}</b>"
    return wrapper
 
def italic(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return f"<i>{result}</i>"
    return wrapper
 
def underline(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return f"<u>{result}</u>"
    return wrapper
 
# Decorators được áp dụng từ dưới lên trên
@bold
@italic
@underline
def greet(name):
    return f"Hello, {name}!"
 
print(greet("Alice"))
# <b><i><u>Hello, Alice!</u></i></b>
 
# Tương đương với:
# greet = bold(italic(underline(greet)))

Thứ tự thực thi


def decorator_1(func):
    print("Decorator 1 applied")
    def wrapper(*args, **kwargs):
        print("Decorator 1: Before")
        result = func(*args, **kwargs)
        print("Decorator 1: After")
        return result
    return wrapper
 
def decorator_2(func):
    print("Decorator 2 applied")
    def wrapper(*args, **kwargs):
        print("Decorator 2: Before")
        result = func(*args, **kwargs)
        print("Decorator 2: After")
        return result
    return wrapper
 
@decorator_1
@decorator_2
def say_hello():
    print("Hello!")
 
# Khi định nghĩa:
# Decorator 2 applied
# Decorator 1 applied
 
print("--- Calling function ---")
say_hello()
# --- Calling function ---
# Decorator 1: Before
# Decorator 2: Before
# Hello!
# Decorator 2: After
# Decorator 1: After

6. functools.wraps

Vấn đề với metadata


def my_decorator(func):
    def wrapper(*args, **kwargs):
        """This is the wrapper function"""
        return func(*args, **kwargs)
    return wrapper
 
@my_decorator
def greet(name):
    """This function greets someone"""
    return f"Hello, {name}!"
 
# Metadata bị mất
print(greet.__name__)  # wrapper (KHÔNG phải greet!)
print(greet.__doc__)   # This is the wrapper function (SAI!)

Giải pháp với functools.wraps


from functools import wraps
 
def my_decorator(func):
    @wraps(func)  # Giữ lại metadata của func
    def wrapper(*args, **kwargs):
        """This is the wrapper function"""
        return func(*args, **kwargs)
    return wrapper
 
@my_decorator
def greet(name):
    """This function greets someone"""
    return f"Hello, {name}!"
 
# Metadata được giữ lại
print(greet.__name__)  # greet (ĐÚNG!)
print(greet.__doc__)   # This function greets someone (ĐÚNG!)

Best Practice: Luôn dùng @wraps


from functools import wraps
 
def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        import time
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end - start:.4f} seconds")
        return result
    return wrapper
 
@timer
def calculate_sum(n):
    """Calculate sum of numbers from 0 to n"""
    return sum(range(n))
 
# Metadata đúng
print(calculate_sum.__name__)  # calculate_sum
print(calculate_sum.__doc__)   # Calculate sum of numbers from 0 to n

7. Class-based Decorators

Decorator dạng class


class CountCalls:
    def __init__(self, func):
        self.func = func
        self.count = 0
 
    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"{self.func.__name__} has been called {self.count} time(s)")
        return self.func(*args, **kwargs)
 
@CountCalls
def say_hello():
    print("Hello!")
 
say_hello()  # say_hello has been called 1 time(s) / Hello!
say_hello()  # say_hello has been called 2 time(s) / Hello!
say_hello()  # say_hello has been called 3 time(s) / Hello!
 
print(f"Total calls: {say_hello.count}")  # Total calls: 3

Class decorator với tham số


class Repeat:
    def __init__(self, times):
        self.times = times
 
    def __call__(self, func):
        def wrapper(*args, **kwargs):
            for _ in range(self.times):
                result = func(*args, **kwargs)
            return result
        return wrapper
 
@Repeat(times=3)
def greet(name):
    print(f"Hello, {name}!")
 
greet("Bob")
# Hello, Bob!
# Hello, Bob!
# Hello, Bob!

8. Decorator cho Class

Decorator cho class


def add_str_method(cls):
    """Add __str__ method to class"""
    def __str__(self):
        return f"{self.__class__.__name__}({', '.join(f'{k}={v}' for k, v in self.__dict__.items())})"
    cls.__str__ = __str__
    return cls
 
@add_str_method
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
person = Person("Alice", 30)
print(person)  # Person(name=Alice, age=30)

Singleton pattern với decorator


def singleton(cls):
    instances = {}
 
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
 
    return get_instance
 
@singleton
class Database:
    def __init__(self):
        print("Creating database connection...")
        self.connection = "Connected"
 
# Chỉ tạo 1 instance duy nhất
db1 = Database()  # Creating database connection...
db2 = Database()  # Không in gì (dùng instance cũ)
db3 = Database()  # Không in gì (dùng instance cũ)
 
print(db1 is db2)  # True
print(db2 is db3)  # True

9. Built-in Decorators

@property


class Circle:
    def __init__(self, radius):
        self._radius = radius
 
    @property
    def radius(self):
        """Get radius"""
        return self._radius
 
    @radius.setter
    def radius(self, value):
        """Set radius with validation"""
        if value < 0:
            raise ValueError("Radius must be positive")
        self._radius = value
 
    @property
    def area(self):
        """Calculate area (read-only)"""
        import math
        return math.pi * self._radius ** 2
 
circle = Circle(5)
print(circle.radius)  # 5
print(circle.area)    # 78.53981633974483
 
circle.radius = 10
print(circle.area)    # 314.1592653589793
 
# circle.radius = -5  # ValueError: Radius must be positive
# circle.area = 100   # AttributeError: can't set attribute

@staticmethod và @classmethod


class MathOperations:
    pi = 3.14159
 
    @staticmethod
    def add(a, b):
        """Static method - không cần instance hay class"""
        return a + b
 
    @classmethod
    def get_pi(cls):
        """Class method - nhận class làm tham số đầu tiên"""
        return cls.pi
 
    @classmethod
    def create_from_string(cls, text):
        """Alternative constructor"""
        return cls()
 
# Gọi static method
print(MathOperations.add(5, 3))  # 8
 
# Gọi class method
print(MathOperations.get_pi())  # 3.14159
 
# Alternative constructor
obj = MathOperations.create_from_string("something")

@dataclass (Python 3.7+)


from dataclasses import dataclass
 
@dataclass
class Person:
    name: str
    age: int
    city: str = "Unknown"
 
    def greet(self):
        return f"Hi, I'm {self.name}, {self.age} years old"
 
# Tự động tạo __init__, __repr__, __eq__
person1 = Person("Alice", 30, "NYC")
person2 = Person("Bob", 25)
 
print(person1)  # Person(name='Alice', age=30, city='NYC')
print(person2)  # Person(name='Bob', age=25, city='Unknown')
print(person1 == person2)  # False
print(person1.greet())  # Hi, I'm Alice, 30 years old

10. Ví dụ thực tế

Rate Limiter


import time
from functools import wraps
 
def rate_limit(max_calls, period):
    """Giới hạn số lần gọi hàm trong khoảng thời gian"""
    calls = []
 
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            now = time.time()
            # Xóa các lần gọi cũ ngoài period
            calls[:] = [call_time for call_time in calls if now - call_time < period]
 
            if len(calls) >= max_calls:
                raise Exception(f"Rate limit exceeded: max {max_calls} calls per {period} seconds")
 
            calls.append(now)
            return func(*args, **kwargs)
        return wrapper
    return decorator
 
@rate_limit(max_calls=3, period=10)
def api_call(endpoint):
    print(f"Calling API: {endpoint}")
    return {"status": "success"}
 
# Gọi 3 lần: OK
api_call("/users")  # OK
api_call("/posts")  # OK
api_call("/comments")  # OK
 
# Lần thứ 4: Lỗi
# api_call("/likes")  # Exception: Rate limit exceeded

Retry decorator


import time
from functools import wraps
 
def retry(max_attempts=3, delay=1):
    """Thử lại hàm nếu bị lỗi"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            attempts = 0
            while attempts < max_attempts:
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    attempts += 1
                    if attempts >= max_attempts:
                        print(f"Failed after {max_attempts} attempts")
                        raise
                    print(f"Attempt {attempts} failed: {e}. Retrying in {delay}s...")
                    time.sleep(delay)
        return wrapper
    return decorator
 
@retry(max_attempts=3, delay=2)
def unstable_api_call():
    import random
    if random.random() < 0.7:  # 70% fail rate
        raise ConnectionError("API unavailable")
    return "Success!"
 
result = unstable_api_call()
print(result)

Tổng kết

Decorator: Pattern thêm chức năng cho hàm/class mà không thay đổi code gốc
Cú pháp: @decorator_name đặt trước hàm/class
Decorator function: Nhận function làm tham số, trả về wrapper function
Decorator với tham số: Cần 3 cấp hàm lồng nhau (decorator factory)
Stacking decorators: Có thể áp dụng nhiều decorators, thực thi từ dưới lên
functools.wraps: Giữ lại metadata của hàm gốc (LUÔN SỬ DỤNG)
Class decorator: Dùng class với __call__ làm decorator
Built-in decorators: @property, @staticmethod, @classmethod, @dataclass
Ứng dụng thực tế: Logging, timing, caching, authentication, validation, rate limiting, retry logic