Python Decorators Tutorial – Complete Guide

Welcome to an incredible journey into the world of Python and its intriguing feature – Python decorators. Whether you’re fresh off the beginner’s boat or if you’re a seasoned coder, this tutorial is aptly suited for you. We’ll not only unlock the mystery shrouding Python decorators but also make understanding them fun by relating it to the world of gaming.

What are Python Decorators?

Python decorators are a powerful feature in Python that allows us to wrap another function in order to extend the behavior of the wrapped function, without permanently modifying it.

Decorators express some form of metaprogramming, as they modify how methods or functions behave. In the context of game development, you can think of decorators as power-ups in a game. Without changing the fundamental characteristics of the character, power-ups enhance their abilities, similar to how decorators extend the behavior of functions.

Why Should You Learn Python Decorators?

It’s simple! Understanding decorators means you are up in your game of Python, equipped to deal with complex tasks more proficiently. From enhancing existing functions to better organizing your code, the utility of Python decorators is infinite.

With chances high that you’re intrigued now, let’s put on our gaming gears and dive into the exciting world of Python decorators in the next section.

CTA Small Image

Understanding Python Decorators: Basic Syntax

Let’s first understand the basic syntax of Python decorators. In its simplest form, a Python decorator is a function that takes another function as input and returns another function as output.

def my_decorator(func):
  def wrapper():
    print("Something is happening before the function is called.")
    print("Something is happening after the function is called.")
  return wrapper

def say_hello():

decorated_function = my_decorator(say_hello)

Let’s unpack what happened here. We first define the decorator function called my_decorator which accepts a function as an argument. Inside the decorator, we define the wrapper function, which wraps around the behavior of the original function. This wrapper function, when called, will first print a message, then call the original function, and finally print another message.

Using At Symbol for Decorators

Fortunately, Python provides a simplified syntax to apply a decorator to a function by using the at symbol (@).

def say_hello():

In Python, ‘@my_decorator’ is just an easier way of saying ‘say_hello = my_decorator(say_hello)’. The code will now output the same as the previous example.

Decorators with Arguments

What if your function accepts arguments? Let’s modify our decorator to cope with this situation.

def my_decorator(func):
  def wrapper(*args, **kwargs):
    print("Something is happening before the function is called.")
    func(*args, **kwargs)
    print("Something is happening after the function is called.")
  return wrapper

def say_hello_to(name):
  print("Hello, " + name + "!")


As shown, by using ‘*’ and ‘**’, we can pass any number of arguments to our function.

Pedagogic Python Decorators

Now imagine a game where a character can collect power-ups that modify its abilities temporarily. Each power-up could be modeled as a Python decorator.

def speed_boost(func):
  def wrapper_speed_boost(*args, **kwargs):
    print("Speed Boost Activated")
    func(*args, **kwargs)
    print("Speed Boost Deactivated")
  return wrapper_speed_boost

def race():
  print("Running Fast!")


Once the race starts, the speed boost power-up is activated, the character runs fast, then the speed boost deactivates. All this without permanently altering the character’s default speed.

We’ll delve deeper into writing decorators using classes in the next part of this tutorial. Stay tuned!

Can We Stack Decorators?

Absolutely! Just like a character can equip multiple power-ups at the same time, you can apply multiple decorators to the same Python function.

def stealth_mode(func):
  def wrapper_stealth_mode(*args, **kwargs):
    print("Stealth Mode Activated")
    func(*args, **kwargs)
    print("Stealth Mode Deactivated")
  return wrapper_stealth_mode

def stealthy_race():
  print("Running Stealthily and Fast!")


So, in this case, the character will start the race with a stealth mode and a speed boost mode activated and these power-ups will deactivate once the race completes.

Decorators in Classes

Decorators can also be defined and used inside classes, giving your code a cleaner structure.

class PowerUp:

  def speed_boost(func):
    def wrapper_speed_boost(*args, **kwargs):
      print("Speed Boost Activated")
      func(*args, **kwargs)
      print("Speed Boost Deactivated")
    return wrapper_speed_boost

def class_race():
  print("Running Fast!")


In this case, `speed_boost` decorator is defined as a static method inside a class called `PowerUp`.

Decorators with Parameters

There will often be cases where you want to parameterize your decorators. You will first need a function that takes those parameters and returns a decorator.

def powerup(name):
  def decorator(func):
    def wrapper(*args, **kwargs):
      print(name + " Activated")
      func(*args, **kwargs)
      print(name + " Deactivated")
    return wrapper
  return decorator

@powerup('Stealth Mode')
def victorious_race():
  print("Running Stealthily and Winning the Race!")


At first, this might look complicated because we have nested functions but just remember that `powerup` returns a decorator, which is applied to the function.

Using Python’s @property decorator

Finally, let’s close with a Python built-in decorator, `@property`.What does this decorator do? It makes the method behave like an attribute meaning we can get the result of a method without parentheses.

class Character:
    def __init__(self, name, strength):
        self._name = name
        self._strength = strength

    def strength(self):
        return self._strength

char = Character('John Doe', 120)
print(char.strength)  # Prints: 120

Python decorators are indeed a powerful tool, making your functionality more amusing, compact, and easier to read. The possibilities are endless, so we encourage you to explore, experiment, and have fun!

Where to Go Next: Python Journey Continues!

Now that you’ve battled your way through the world of Python decorators, it’s time to level up! The road to mastering Python is paved with exciting challenges and rewarding accomplishments.

Here at Zenva, we are committed to helping you advance on this coding quest. Our Python Mini-Degree is precisely the next power-up you need.

The Python Mini-Degree is a comprehensive online course that leaves no stone unturned when it comes to Python programming. Through this degree, you’ll traverse various lands of learning. You’ll begin with the basics of coding, venture into the realm of algorithms and explore the territories of object-oriented programming. Not just that, it goes a step further, drawing you into the thrilling world of game development and app development, with Python as your magic wand.

By diving into our Python Mini-Degree, you can:

  • Build your own games, next-gen algorithms, and real-world apps.
  • Learn at your own pace and skip lessons you’re already proficient in.
  • Reinforce your learning through quick challenges and in-course quizzes.
  • Access video lessons, course printouts, interactive lessons and downloadable source code.
  • Earn course completion certificates.

No matter if you’re a coding novice or a seasoned programmer, our Python Mini-Degree is just right for you.

For those thirsting for more intermediate-level Python adventures, there’s great news. We have an entire section dedicated to Python programming in our course library. It’s filled to the brim with enriching content that will surely satisfy your learning thirst.


So, here we are at the end of this exciting journey through the Python decorators landscape. We’ve seen from basics to some fancy uses, and we hope this tutorial has transformed your understanding. Decorators, as we saw, are nothing but another exciting power in the hands of Python programmers.

As we bid you goodbye, we invite you to keep exploring, lucubrating, and creating with Zenva’s Python courses. Let’s take this fascinating programming journey forward together! Until next time, keep coding and remember, every power-up counts!

Did you come across any errors in this tutorial? Please let us know by completing this form and we’ll look into it!

Python Blog Image

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