Python Decorators Usage Tutorial – Complete Guide

Welcome to our comprehensive tutorial on Python decorators! Python decorators are a critical concept and a powerful tool for any Python programmer, yet many coders find themselves intimidated by the very mention of the term. Not to worry! This tutorial will demystify Python decorators for you, using simple games and analogies to deliver an engaging and accessible learning experience.

What are Python Decorators?

Python decorators allow us to wrap another function in order to extend the behavior of the wrapped function, without permanently modifying it. In very simple terms, decorators in Python provide a way to modify the functionality of an existing function or class.

What Are They Used For?

Python decorators are used to extend and modify the behavior of a callable (functions, methods, or classes) without permanently modifying the callable itself.

They can be used for many different purposes such as:

  • Logging: Decorators can be used to log the activities of a function or methods.
  • Timing: They can also be used to time functions and get an understanding of how efficiently they run.
  • Enforcing access controls and authentication.

Why Should I Learn About Python Decorators?

Why should you invest your time in understanding decorators? Here are a few compelling reasons:

  • Code Reusability: Decorators allow you to write and maintain less code while accomplishing more, by avoiding code redundancy.
  • Functionality Extension: They provides a simple syntax for calling higher-order functions.
  • Real-world application: Decorators are extensively used in real-world Python projects and professional codebases.
  • Enhanced comprehension: Finally, understanding decorators deepens your overall comprehension of Python as a language and your ability to leverage its flexibility.

In the easy-to-follow coding parts of our tutorial which follow next, we aim to use fun examples for a beginner-friendly and enjoyable learning experience.

CTA Small Image




Fantastic! Now that we’ve covered the basics, let’s dive into some Python code to see these decorators in action.

Basic Structure of a Python Decorator

In Python, functions are first-class objects. This means that functions can be passed around, and used as arguments, just like any other object (string, int, float, list, etc). Let’s take a look at a simple decorator:

def simple_decorator(function):
    print("Doing decoration")
    return function

In the above example, simple_decorator is a function that takes another function and returns it without modifying it.

Using Python Decorators

Now let’s see an example of how to apply a decorator to a function:

def simple_decorator(function):
    print("Doing decoration")
    return function

def hello():
    print("Hello world!")

The @ symbol is Python’s decorator syntax. It is a way to apply a decorator to a function.

Modifying Function Behavior

Let’s modify our decorator function so that it changes the behavior of the decorated function:

def simple_decorator(function):
    def wrapper():
        print("Entering function")
        print("Exiting function")
    return wrapper

def hello():
    print("Hello world!")

Our simple_decorator now defines a new function (the wrapper function) that wraps the call to the original function with two print calls.

Decorators with Arguments

What if our function takes arguments? Let’s look at an example:

def simple_decorator(function):
    def wrapper(*args, **kwargs):
        print("Entering function")
        function(*args, **kwargs)
        print("Exiting function")
    return wrapper

def greet(name):
    print(f"Hello {name}!")

Here, the wrapper function takes all arguments and keyword arguments and forwards them to the function.

Python Decorators with Parameters

Now, let’s add a parameter to the decorator itself. How do we go about that? Here’s an example:

def repeat_decorator(num_times):
    def decorator_repeat(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                func(*args, **kwargs)
        return wrapper
    return decorator_repeat

def greet(name):
    print(f"Hello {name}!")

The above decorator function will repeat the decorated function the number of times we specify.

Using Multiple Decorators

A Python function can be decorated multiple times with different (or even the same) decorators. Here’s an example of using multiple decorators:

def decorator_1(function):
    def wrapper():
        print("Decoration 1")
    return wrapper

def decorator_2(function):
    def wrapper():
        print("Decoration 2")
    return wrapper

def hello():
    print("Hello world!")

The decoration order matters here- the bottom decorator is run first, then the next one up, and so forth.

Built-in Decorators

Python includes some built-in decorators. Two common ones are @staticmethod and @classmethod.

class MyClass:
    def method(self):
        return 'instance method', self

    def classmethod(cls):
        return 'class method', cls

    def staticmethod():
        return 'static method'

The @classmethod and @staticmethod decorators are used to define class methods and static methods in a class, while the @property decorator allows us to use a method as if it were an attribute.

Decorators in Flask

The Flask web framework uses decorators in a particularly interesting and valuable way- to bind functions to URLs. Here’s an example:

from flask import Flask
app = Flask(__name__)

def hello():
    return "Hello World!"

In this example, Flask uses the @app.route decorator to bind the hello function to the root URL (/). When http://localhost:5000/ is visited in a web browser, Flask triggers the hello function and returns its result to the browser.

Where to Go Next and Enhance Your Python Skills Further?

Now that you’re all acquainted with Python decorators, you’re well-equipped to further enhance your Python skills! If you’re keen to expand your understanding and become proficient in many other areas of Python, we strongly recommend checking out our comprehensive Python Mini-Degree.

The Python Mini-Degree offered by us at Zenva Academy is an exhaustive collection of Python courses that comprehensively teach various facets of Python programming. Python is renowned for its simplicity and flexibility, and our courses cover a plethora of topics, including:

  • Coding fundamentals
  • Advanced algorithms
  • Object-Oriented Programming (OOP)
  • Game development
  • App development

But don’t assume it’s all about theory – you’ll get plenty of hands-on experience! After immersing yourself in the courses, you’ll gradually build your own games, AI chatbots, and apps, helping you consolidate and apply what you’ve learned!

Python has extensive applications across various industries such as space exploration, data science, and robotics, to name a few. Hence, your newly acquired skills will be in high demand! The Python Mini-Degree is designed for both beginners and experienced programmers, providing flexible learning options and allowing learners to skip to relevant lessons as needed.

To affirm your learning and progress, we offer quizzes and coding challenges, allowing you to build proficiency and confidence. Additionally, once you successfully complete the courses, you’ll receive completion certificates.

At Zenva, we pride ourselves on our strong community of learners and developers. They have achieved incredible real-world results, including landing coveted jobs, starting up businesses, and even publishing games and websites!

But wait, there’s more! If you’re interested in exploring our broader selection of Python courses, you can do so by clicking here.

Be part of Zenva, go from beginner to professional, and start your journey to success!


Python decorators allow you to elegantly alter the functionality of your code without changing the code itself, making your code cleaner, more efficient, and more reusable. These powerful tools are versatile and widely used, adding another layer of sophistication to your Python programming.

Don’t stop your learning journey here; there’s so much more to explore and master! Our comprehensive Python Mini-Degree offers you the unique opportunity to dive into the vast ocean of Python, learning every complex element in an accessible, hands-on, and engaging manner. Enroll now, and take your Python skills to the next level! Remember, at Zenva, we guide you past your learning hurdles to reach your coding goals and dreams!


Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Unreal, Python, Godot and more.