Python Core | VoidX Academy

28. Python Decorators

Advanced

Python Decorators

A decorator is a design pattern in Python that allows a user to add new functionality to an existing object without modifying its structure. Decorators are usually called before the definition of a function you want to decorate.

Functions in Python are first-class citizens. This means they can be passed as arguments to other functions, returned from other functions, and assigned to variables. Decorators leverage this deeply.

Functions as Arguments

Before understanding decorators, you must understand that you can pass a function into another function as a variable.

def say_hello(name):
    return f"Hello {name}"

def greet_bob(greeter_func):
    return greeter_func("Bob")

# Passing the say_hello function itself, not executing it (no parentheses)
print(greet_bob(say_hello))

OutputHello Bob

Creating a Basic Decorator

A decorator is simply a function that takes another function as an argument, adds some kind of wrapper logic around it, and returns the newly wrapped function.

def my_decorator(func):
    def wrapper():
        print("Something is happening BEFORE the function is called.")
        func() # Execute the original function
        print("Something is happening AFTER the function is called.")
    return wrapper

def say_whee():
    print("Whee!")

# Manually decorating the function
say_whee = my_decorator(say_whee)
say_whee()

OutputSomething is happening BEFORE the function is called. Whee! Something is happening AFTER the function is called.

Syntactic Sugar: The @ Symbol

Python provides a much cleaner way to apply decorators using the @ symbol. You just place it directly above the function you want to decorate. It does exactly the same thing as the manual wrapping shown above.

def my_decorator(func):
    def wrapper():
        print("--- Initialization ---")
        func()
        print("--- Teardown ---")
    return wrapper

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

# We just call the function normally now
say_hello()

Output--- Initialization --- Hello World! --- Teardown ---

Decorating Functions with Arguments

If the function you are decorating takes arguments, the inner wrapper function must also accept those arguments. The best way to handle this is by using *args and **kwargs to accept any number of arguments.

def do_twice(func):
    def wrapper_do_twice(*args, **kwargs):
        func(*args, **kwargs)
        return func(*args, **kwargs)
    return wrapper_do_twice

@do_twice
def greet(name):
    print(f"Hello {name}")

greet("Alice")

OutputHello Alice Hello Alice

💡Use Cases: Decorators are heavily used in frameworks. In Django or Flask, decorators like @login_required are used to instantly protect routes. They are perfect for logging, timing functions, or handling authentication logic without cluttering your core business logic.

Knowledge Check

Ready to test your understanding of 28. Python Decorators?

27. Python Polymorphism