What is a decorator in Python and how to use it?

Question

Jayant Kumar · Accepted Answer

Table of Contants
Introduction:
In Python, a decorator is a powerful and flexible tool that allows you to modify or extend the behavior of functions or methods without changing their actual code. Decorators are often used to add functionality such as logging, access control, or instrumentation in a clean and reusable manner. By using decorators, you can enhance functions or methods dynamically, adhering to the DRY (Don't Repeat Yourself) principle.
What is a Decorator?
A decorator is a function that takes another function (or method) as an argument and returns a new function that typically extends or alters the behavior of the original function. Decorators are commonly used to:

Add pre-processing or post-processing logic.
Implement access control or authentication.
Measure performance or log function calls.

Syntax of Decorators
A decorator is applied to a function using the @ symbol followed by the decorator function's name, placed above the function definition.
Basic Syntax:
@decorator_function
def function_to_decorate():
    # Function body

@decorator_function is the decorator being applied to function_to_decorate.

Creating a Simple Decorator
Here’s a step-by-step guide to creating and using a basic decorator:
Step : Define the Decorator
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 is a decorator function that takes another function func as an argument.
wrapper is an inner function that adds additional behavior before and after calling func.

Step : Apply the Decorator
@my_decorator
def say_hello():
    print("Hello!")

say_hello()

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

The @my_decorator syntax applies the my_decorator to say_hello, enhancing its behavior with additional print statements.

Decorators with Arguments
Decorators can also accept arguments, making them more flexible. To do this, you need an additional level of nested functions.
Example: Decorator with Arguments
python
def repeat(num_times):
    def decorator_repeat(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                func(*args, **kwargs)
        return wrapper
    return decorator_repeat

repeat is a decorator factory that returns decorator_repeat, which in turn returns wrapper.

Applying the Decorator
@repeat(num_times=3)
def greet(name):
    print(f"Hello {name}")

greet("Alice")

Output:
Hello Alice
Hello Alice
Hello Alice

The repeat decorator causes the greet function to be executed three times.

Practical Use Cases for Decorators

Logging Function Calls:
You can use decorators to automatically log function calls and their results.
import logging

def log_function_call(func):
    def wrapper(*args, **kwargs):
        logging.info(f"Calling function {func.__name__} with arguments {args} and keyword arguments {kwargs}")
        result = func(*args, **kwargs)
        logging.info(f"Function {func.__name__} returned {result}")
        return result
    return wrapper

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

Access Control and Authentication:
Decorators can enforce access control, such as requiring users to be authenticated before executing a function.
def requires_authentication(func):
    def wrapper(*args, **kwargs):
        if not user_authenticated():
            raise PermissionError("User must be authenticated")
        return func(*args, **kwargs)
    return wrapper

Caching Results:
Decorators can cache the results of expensive function calls to improve performance.
from functools import lru_cache

@lru_cache(maxsize=None)
def expensive_function(x):
    # Expensive computation
    return x * x

Conclusion:
Decorators in Python provide a flexible way to modify or extend the behavior of functions or methods without altering their code. By understanding how to create and apply decorators, you can enhance functionality, enforce rules, and improve code maintainability. Whether you are logging, managing access control, or caching results, decorators are a powerful tool for writing cleaner and more modular Python code.

What is a decorator in Python and how to use it?

Similar Questions