5 Essential Use Cases for Python Decorator Pattern

Introduction to Python Decorators

Python decorators are a powerful feature that allows developers to modify or enhance functions and methods without directly changing their code. Essentially, decorators are a way to wrap another function to extend its behavior. This can lead to cleaner, more maintainable code that’s easier to read and understand.

What Are Decorators?

Decorators in Python are higher-order functions that take another function as an argument and extend its functionality by adding some wrapper code. Here’s a simple example to illustrate:

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

When say_hello() is called, the output will include the messages printed by the decorator:

Something is happening before the function is called.
Hello!
Something is happening after the function is called.

Use Case 1: Logging

One of the most straightforward applications for decorators is logging. Logging is critical in debugging and understanding the flow of your application:

def logger(func):
    def wrapper(*args, kwargs):
        print(f"Calling function {func.__name__}")
        result = func(*args, kwargs)
        print(f"Function {func.__name__} finished")
        return result
    return wrapper

@logger
def add(a, b):
    return a + b

result = add(10, 20)

📝 Note: Ensure that the decorator preserves the metadata of the original function, such as its name and docstring, by using `functools.wraps()`.

Use Case 2: Timing Functions

If you’re interested in how long certain functions take to execute, a timing decorator can be very useful:

import time

def timing(func):
    def wrapper(*args, kwargs):
        start = time.time()
        result = func(*args, kwargs)
        end = time.time()
        print(f"Function '{func.__name__}' took {end - start:.4f} seconds to execute")
        return result
    return wrapper

@timing
def slow_function():
    time.sleep(2)
    print("Function completed")

slow_function()

Use Case 3: Access Control

Decorators are particularly effective for implementing access control or authentication checks:

def requires_authentication(func):
    def wrapper(user):
        if user.role != "admin":
            raise PermissionError("You don't have permission to perform this action")
        return func(user)
    return wrapper

@requires_authentication
def delete_user(user):
    print(f"Deleting user: {user.name}")

class User:
    def __init__(self, name, role):
        self.name = name
        self.role = role

admin = User("admin", "admin")
customer = User("customer", "customer")

delete_user(admin)  # This will work
delete_user(customer)  # This will raise an exception

Use Case 4: Enhancing Input and Output

You can also use decorators to modify the input parameters or return values:

def strip_white_spaces(func):
    def wrapper(text):
        return func(text.strip())
    return wrapper

@strip_white_spaces
def shout(text):
    return text.upper() + "!"

print(shout("   hello    "))  # Output: HELLO!

Use Case 5: Memoization

Memoization is an optimization technique used primarily to speed up computer programs by storing the results of expensive function calls and reusing them when the same inputs occur again:

from functools import wraps

def memoize(func):
    cache = {}
    @wraps(func)
    def wrapper(*args, kwargs):
        key = str(args) + str(kwargs)
        if key not in cache:
            cache[key] = func(*args, kwargs)
        return cache[key]
    return wrapper

@memoize
def fib(n):
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)

print(fib(100))

In this way, the fib() function, which would normally be extremely slow due to redundant calculations, becomes significantly faster with memoization.

Summing Up

Decorators in Python offer a highly flexible way to modify function behavior without altering the original code. From logging, timing, access control, to memoization, decorators enhance functionality with minimal additional code:

• Logging: For tracking function calls and results.
• Timing: To measure performance of functions.
• Access Control: For implementing security and permissions.
• Input/Output Enhancement: To modify data at entry and exit points.
• Memoization: To optimize repeated function calls.

📝 Note: Decorators can stack; one function can have multiple decorators applied to it, each adding different functionality.