How to Use Python Decorators with Practical Examples

If you are learning Python and want to write cleaner, more reusable code, understanding decorators is a great step forward. Decorators are a powerful tool that allows you to modify the behavior of a function or method without changing its actual code. This beginner-friendly tutorial will explain what decorators are, how they work, and provide practical code examples that you can try yourself.

In Python, a decorator is essentially a function that takes another function as an argument and extends or alters its behavior. You often see decorators used for logging, access control, or performance timing. This concept is related to higher-order functions and closures in Python, which allow functions to be passed around as objects and capture local state. Understanding decorators can also help when working with classes, methods, and advanced features like metaprogramming.

def simple_decorator(func):
    def wrapper():
        print('Before the function runs')
        func()
        print('After the function runs')
    return wrapper

@simple_decorator
def say_hello():
    print('Hello!')

say_hello()

# Output:
# Before the function runs
# Hello!
# After the function runs

To use decorators properly, define a function (the decorator) that receives the original function and returns a new function (often called a wrapper). Inside the wrapper, you can run code before and after calling the original function. To apply the decorator, place @decorator_name above the function definition you want to modify. This technique keeps your code DRY (Don't Repeat Yourself) and is especially useful to add features like logging, authentication, or caching without cluttering your main logic. When dealing with functions that accept arguments, use *args and **kwargs in your wrapper to handle them flexibly.

One common mistake beginners make with decorators is forgetting to use the functools.wraps helper. If you don't import and apply functools.wraps to your wrapper function, the metadata of the decorated function (like its name and docstring) will be lost, which can cause confusion during debugging or when generating documentation. Another pitfall is not handling arguments in the wrapper, which leads to errors if the decorated function requires parameters. Also, avoid complex logic inside decorators — keep them focused on a single responsibility for easier maintenance.

In summary, Python decorators are a clean and effective way to extend the behavior of functions and methods. By learning to write and apply decorators correctly, you can improve your code organization and reuse. Remember to handle function arguments properly, use functools.wraps to keep function metadata intact, and keep your decorator logic simple. With practice, decorators will become a natural part of your Python programming toolkit, enhancing your work with functions, classes, and other advanced concepts.