Python Decorators

Today, I would like to share about Python decorators which simplify the code with powerful function enhancements. Python decorators are a powerful feature that allows developers to modify or enhance the behavior of functions or classes without directly modifying their source code. Decorators provide a clean and concise way to add functionality to existing code, making it easier to manage and reuse.

What are Decorators?

Decorators are functions that take another function as input and extend its functionality. They wrap the original function with additional code, allowing for actions like logging, authentication, and more, to be applied to multiple functions in a consistent and reusable manner.

Example 1: Logging Decorator

Let’s consider a simple example of a logging decorator. The decorator adds logging statements before and after the execution of a function:

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

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

# Using the decorated function
result = add(3, 5)
print(result)  # Output: 8

In this example, the `logger` function is a decorator that takes the function `add` as input. It defines an inner function `wrapper`, which performs the logging operations and calls the original function. The decorator then returns the `wrapper` function, which replaces the original `add` function.

Example 2: Authorization Decorator

Decorators can also be used for implementing authorization checks. Let’s see an example:

def authenticate(func):
    def wrapper(*args, **kwargs):
        if check_authentication():
            return func(*args, **kwargs)
        else:
            raise Exception("Unauthorized access!")
    return wrapper

@authenticate
def sensitive_operation():
    # Perform sensitive operation here
    pass

# Using the decorated function
sensitive_operation()

In this example, the `authenticate` decorator checks if the user is authenticated before executing the `sensitive_operation` function. If the user is authenticated, the function is executed; otherwise, an exception is raised.

Conclusion

Python decorators provide a powerful and flexible way to modify the behavior of functions or classes without modifying their original code. They enable code reuse, separation of concerns, and cleaner code organization. By using decorators, developers can enhance their programs with additional features, such as logging, authentication, caching, and more, with minimal effort and maximum efficiency.

This is all for now. Hope you enjoy that.

By Asahi