Understanding Python Decorators: A Powerful Tool for Clean and Reusable Code

Python decorators are one of the language’s most powerful and expressive features. They allow you to extend and modify the behavior of functions or classes without changing their actual code. This article will cover everything you need to know to understand, write, and use decorators effectively.

What Is a Decorator?

In Python, decorators are a powerful and flexible way to modify or extend the behavior of functions or methods, without changing their actual code. A decorator is essentially a function that takes another function as an argument and returns a new function with enhanced functionality.

The Basics: Functions Are First-Class Citizens

Python treats functions as first-class objects, meaning:

• They can be passed as arguments to other functions.
• They can be returned from other functions.
• They can be assigned to variables.

This enables decorators to work.

A Simple Example

def greet(name):
    return f"Hello, {name}!"


say_hello = greet # Assigning function to a variable:
print(say_hello("Alice"))  # Hello, Alice!

Writing Your First Decorator

Here’s a simple decorator that prints something before and after a function runs:

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Before the function call")
        result = func(*args, **kwargs)
        print("After the function call")
        return result
    return wrapper

Using the decorator manually:

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

decorated = my_decorator(say_hello)
decorated()

Using the @ syntax (Pythonic way):

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

say_hello()


'''
Output
Before the function call
Hello!
After the function call
'''

Working

• when you call say_hello(), You’re really calling wrapper().
• And inside wrapper, the original func (which is the original say_hello) is called via:

result = func(*args, **kwargs)

• The return value of the original function is stored in result, which is then returned by wrapper.

Flow:

• You (the caller) call the function → Python calls wrapper.
• wrapper calls the original function.
• The return value goes from the original function → to wrapper → back to you.

Multiple decorators

@decorator_one
@decorator_two
def my_function():
    print("Hello!")

This is equivalent to:

my_function = decorator_one(decorator_two(my_function))

So the decorator closest to the function is applied first, and then wrapped by the next one, and so on — like layers of an onion.

def decorator_one(func):
    def wrapper(*args, **kwargs):
        print("Decorator One - Before")
        result = func(*args, **kwargs)
        print("Decorator One - After")
        return result
    return wrapper

def decorator_two(func):
    def wrapper(*args, **kwargs):
        print("Decorator Two - Before")
        result = func(*args, **kwargs)
        print("Decorator Two - After")
        return result
    return wrapper

@decorator_one
@decorator_two
def say_hello():
    print("Hello!")

say_hello()

Output

Decorator One - Before
Decorator Two - Before
Hello!
Decorator Two - After
Decorator One - After

Execution Flow:

• say_hello() is first passed to decorator_two, which returns a new function (let’s call it wrapped_two)
• Then wrapped_two is passed to decorator_one, returning wrapped_one
• So calling say_hello() is really calling wrapped_one(), which calls wrapped_two(), which finally calls the original function.

Use Cases of Decorators

Decorators are great for many tasks:

• Logging
• Authentication / Authorization
• Memoization / Caching (@lru_cache from functools)
• Performance timing
• Validation and sanitization

Example : Logging

def log(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with {args} {kwargs}")
        return func(*args, **kwargs)
    return wrapper

Built-in Decorators

Python comes with several built-in decorators:

• @staticmethod
• @classmethod
• @property
• @functools.lru_cache
• @functools.wraps (used for preserving metadata when writing custom decorators)

Preserving Function Metadata with functools.wraps

When you write a decorator, the metadata (like name and docstring) of the original function gets lost. You can fix this with functools.wraps.

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("Calling function...")
        return func(*args, **kwargs)
    return wrapper

Decorators with Arguments

What if your decorator needs arguments?

def repeat(n):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("Hello!")

say_hello()

Why need of one more function repeat?

• When you want your decorator to accept arguments (like @repeat(3)), you need an extra layer of function wrapping — a decorator factory.
• Python interprets @decorator_name as calling a function that takes just one argument — the function itself, so we need one more function

Function args inside a decorator

def capitalize_name(func):
    def wrapper(name, *args, **kwargs):
        name = name.capitalize()  # Change name to capitalized
        return func(name, *args, **kwargs)
    return wrapper

@capitalize_name
def say_hi(name):
    print(f"Hi {name}!")

say_hi("bob")


'''
Output
Hi Bob!
'''

Key Note

• you can change the function arguments inside the decorator, and those changes will be seen inside the function, because the decorator intercepts the call before the function runs. Refer above example(name)
• The decorator is a gatekeeper. It can inspect, log, modify, block, or replace arguments. Then it passes the (possibly modified) arguments into the original function.

Any change to args or kwargs inside the decorator will reflect in function as well.

Why pass name variable in wrapper function, can’t be use args or kwrgs?

You don’t have to write name separately. It’s done only when you want to explicitly access a known positional argument directly, for readability or manipulation.

Example

def capitalize_name(func):
    def wrapper(*args, **kwargs):
        args = (args[0].capitalize(),) + args[1:]  # capitalizing first arg
        return func(*args, **kwargs)
    return wrapper

Class-Based Decorators

Decorators can also be implemented as classes by defining the __call__ method.

class MyDecorator:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print("Before")
        result = self.func(*args, **kwargs)
        print("After")
        return result

@MyDecorator
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")

Conclusion

Decorators are a powerful feature of Python, allowing you to enhance your functions or methods with minimal and readable syntax. Once you’re comfortable with higher-order functions and closures, decorators become a natural extension of your coding toolkit.

Resource

• Python Interview Question