5 Practical Use Cases of Python Decorators You Should Know

So, before using the Python Decorators, you should be aware of the basic concept behind it, right? What are Decorators? The name itself suggests that it decorates something and that something is a Python function.

What are Decorators?

Simply put, Python decorators let you enhance and change how a function or method behaves, even for classes. The best part? You can do this without making permanent modifications to the original function or method.

But in day-to-day life, generally you don’t remember that something like this exists or sometimes you don’t even know the situation in which it can actually benefit you! Let me give you a perfect example to understand its beauty.

Now, let’s imagine you have a critical function in your application that interacts with an external API and pulls data from there, and occasionally, this API might experience temporary outages. But you are a smart developer, and you know it’s the perfect opportunity to use Decorators.
You will just smile and implement a generic retry mechanism by writing a @retry_decorator and will quickly paste it in front of all the methods. This will save you from spending a lot of time in modifying the functions.

And this is the time where I will tell you 5 practical use cases which you might face in your work life, so let’s get into it-

Logging

Logging is one of the most needed and important part of any application. You can easily use decorators to enhance your code transparency by implementing a logging decorator. With a simple @log_here decorator above your function, you can track input arguments, execution details, and output. It can also be used to debug code and understanding the code flow easily.

def log_here(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with {args} and {kwargs}.")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result}.")
        return result
    return wrapper

@log_here
def multiply(a, b):
    return a * b

Caching

You can easily improve performance of your application with a caching decorator. By storing previously computed results and quickly retrieving them upon receiving identical input, caching decorators significantly reduce redundant computations in data-heavy processes and web applications. This not only accelerates response times but also minimizes resource utilization, contributing to a more responsive system.

def get_cache(func):
    cache_dict = {}

    def wrapper(a1):
        if a1 not in cache_dict:
            cache_dict[a1] = func(a1)
        return cache_dict[a1]

    return wrapper

@get_cache
def factorial(a1):
    if a1 == 0 or a1 == 1:
        return 1
    return a1 * factorial(a1-1)

result = factorial(5)
print(f"The factorial of 5 is: {result}")

Validation of Input Data

There can be various times when you have to make sure that the input data to the application is valid and quality data. You can ensure data integrity in your application by implementing a validation decorator. With @validate_it, you can add input requirements and enhance the robustness of functions dealing with specific data types.

def validate_it(func):
    def wrapper(*args, **kwargs):
        if all(isinstance(a1, int) for a1 in args):
            return func(*args, **kwargs)
        else:
            print("Invalid input. Please provide integers.")
    return wrapper

@validate_it
def multiply(a, b):
    return a * b

Retry Mechanism

This use case I already explained to you earlier with an example. You can improve your application resilience in case of intermittent failures using a retry decorator. Retry logic can be very easily integrated with @retry_here() to automatically attempt operations multiple times, introducing delay between retries.

import time

def retry_here(max_retries=3, delay=1):
    def decorator(func):
        def wrapper(*args, **kwargs):
            attempts = 0
            while attempts < max_retries:
                try:
                    result = func(*args, **kwargs)
                    return result
                except Exception as e:
                    print(f"Attempt {attempts + 1} failed. Retrying in {delay} seconds.")
                    time.sleep(delay)
                    attempts += 1
            raise RuntimeError("Max retries reached. Operation failed.")
        return wrapper
    return decorator

@retry_here()
def your_application_method():
    if random.random() < 0.3:
        raise Exception("Oops!Operation failed.")
    return "Operation successful."

# Call the decorated function with retry mechanism
result = your_application_method()

Authorization

You can safeguard your sensitive operations with an authorization decorator. Apply @is_admin(required_role="admin") decorator to functions which will allow simple role-based access control and preventing unauthorized users from executing critical operations.

def is_admin(required_role):
    def decorator(func):
        def wrapper(user_role):
            if user_role == required_role:
                return func(user_role)
            else:
                print("Unauthorized. Insufficient privileges.")
        return wrapper
    return decorator

@is_admin(required_role="admin")
def admin_operation(user_role):
    print(f"Performing admin operation as {user_role}.")

# Call the decorated function with authorization check
admin_operation("admin")

Conclusion

These were some common use cases in which you can try using Python Decorators and see the results yourself. Play around with the logic and you might also find some great use cases.
Let me know in the comments how you have used Decorators in your workplace.
Happy Learning!