Python is a language that’s loved by many for its simplicity and readability. Yet, there are certain aspects of Python that may seem a bit mystifying to beginners, and decorators are one such feature. Today, we will demystify the magic of Python decorators.

Python Decorators

What are Python Decorators? Link to heading

In the simplest term, a decorator in Python is a function that takes another function as input and extends the behavior of the latter function without explicitly modifying it. They are a powerful feature that allows you to wrap a function or method in order to extend or change its behavior.

def my_decorator(func):
    def wrapper():
        print("Before function call")
        print("After function call")
    return wrapper

def say_hello():


When you run this code, you’ll see that the say_hello function now has some behavior before and after it thanks to the decorator.

How Do Python Decorators Work? Link to heading

The magic of decorators lies in the concept of functions as first-class objects in Python. This means that functions in Python can be passed around and used as arguments, just like any other object (strings, integers, modules, etc.).

def greet(func):

def say_hello():


Running this code will result in the output “Hello!”. The say_hello function, as you see, is passed as an argument to the greet function.

Decorators use this feature to “decorate” or “wrap” another function. The decorator function takes a function as an argument, defines a nested function inside (which can access the outer function’s input), and returns this nested function.

Practical Applications of Decorators Link to heading

Decorators shine in cases where you want to extend the functionality of functions or methods. For instance, they can be used for logging, enforcing access control and authentication, rate limiting, caching, and much more.

Let’s look at a simple logging example.

import time

def time_it(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"Time taken by {func.__name__} function: {end - start} seconds")
        return result
    return wrapper

def calculate_sum(n):
    return sum(range(n))


This decorator time_it will log the time taken by the calculate_sum function to execute.

Wrapping Up Link to heading

Decorators in Python are indeed magical, but they are not something to be afraid of. They are a powerful tool in a Pythonista’s toolkit that allows for cleaner and more efficient code.

By mastering decorators, you’re well on your way to becoming a more effective and proficient Python programmer. So, keep practicing and keep learning. The magic of Python is in your hands!


  1. Python Decorators.
  2. Primer on Python Decorators. Real Python