Understanding Python Decorators, with Examples

Share this article

Understanding Python Decorators, with Examples

This article will help you understand the concept of decorators in Python programming and how best to use them. We’ll cover what Python decorators are, what their syntax looks like, how to identify them in a script or framework, and how to apply them yourself.

A function decorator in Python is just a function that takes in another function as an argument, extending the decorated function’s functionality without changing its structure. A decorator wraps another function, amplifies its behavior, and returns it.

The concept of decorators in Python help keeps your code DRY. A function decorator avoids unnecessary repetition across your codebase, because some repeated bits of code can be pulled together to become function decorators. As you advance in using Python for development, decorators can help with analytics and logging. They’re also vital for setting up validation and runtime checks.

As we proceed, I’ll assume you have a basic understanding of Python functions and programming and you have at least Python 3.8 installed on your device.

Things to Understand before Delving into Python Decorators

In Python, functions are first-class objects, meaning they can receive arguments or be passed as arguments. To fully grasps the concept of decorators, there are a few things you need to understand.

A function is an object, which means it can be assigned to another variable

def greet():
    print("Hello John")
greet_john = greet
Hello John

Always remember that everything is an object in Python. In the same way you assign values to a variable, a function can also be assigned to a variable where necessary. This is important as you learn about decorators.

A function can be returned from another function

def greet():
    def greeting_at_dawn():
        print("Good morning")
    return greeting_at_dawn

salute = greet()
Good morning

An inner function in Python can be returned from the outer function. This is part of the functional programming concepts you’ll come across.

A function can be passed as an argument of another function

def greet_some(func):
    print("Good morning", end=' ')

def say_name():

Good morning John

A function that receives a function argument is known as a higher order function.

The above-listed points are important to keep in mind when learning to implement decorators and use them effectively in a Python program.

How Python Decorators Work

A simple decorator function starts with a function definition, the decorator function, and then a nested function within the outer wrapper function.

Always keep these two main points in mind when defining decorators:

  1. To implement decorators, define an outer function that takes a function argument.
  2. Nest a wrapper function within the outer decorator function, which also wraps the decorated function.

This is what the most basic decorator function looks like in the code snippet below:

def increase_number(func):
    def increase_by_one():
        print("incrementing number by 1 ...")
        number_plus_one = func()  + 1
        return number_plus_one
    return increase_by_one 
def get_number():
    return 5
get_new_number = increase_number(get_number)
incrementing number by 1 ...

Looking at the code above, the outer function increase_number — also known as the decorator — receives a function argument func. increase_by_one is the wrapper function where the decorated get_number function is found. The decorator is assigned to another variable. This is what a decorator syntax looks like when using Python decorators. However, there’s a much easier way to represent decorators.

A simple decorator function is easily identified when it begins with the @ prefix, coupled with the decorated function underneath. The previous example can be refactored to look like this:

def increase_number(func):
    def increase_by_one():
        print("incrementing number by 1 ...")
        number_plus_one = func()  + 1
        return number_plus_one
    return increase_by_one 
def get_number():
    return 5

incrementing number by 1 ...

The examples show that a decorator extends the functionality of its function argument.

Decorator Functions with Parameters

There are cases where you may need to pass parameters to a decorator. The way around this is to pass parameters to the wrapper function, which are then passed down to the decorated function. See the following example:

 def multiply_numbers(func):
    def multiply_two_numbers(num1, num2):
        print("we're multiplying two number {} and {}".format(num1, num2))
        return func(num1, num2)
    return multiply_two_numbers

def multiply_two_given_numbers(num1, num2):
    return f'{num1} * {num2} = {num1 * num2}'
print(multiply_two_given_numbers(3, 4))
we're multiplying two number 3 and 4
3 * 4 = 12

Having parameters passed to the inner function or nested function makes it even more powerful and robust, as it gives more flexibility for manipulating the decorated function. Any number of arguments (*args) or keyword arguments (**kwargs) can be passed unto the decorated function. *args allows the collection of all positional arguments, while the **kwargs is for all keyword arguments needed during the function call. Let’s look at another simple example:

def decorator_func(decorated_func):
    def wrapper_func(*args, **kwargs):
        print(f'there are {len(args)} positional arguments and {len(kwargs)} keyword arguments')
        return decorated_func(*args, **kwargs)
    return wrapper_func

def names_and_age(age1, age2, name1='Ben', name2='Harry'):
    return f'{name1} is {age1} yrs old and {name2} is {age2} yrs old'
print(names_and_age(12, 15, name1="Lily", name2="Ola"))
There are 2 positional arguments and 2 keyword arguments
Lily is 12 yrs old and Ola is 15 yrs old

From the above example, *args forms an iterable of positional arguments as a tuple, while the **kwargs forms a dictionary of keyword arguments.

Multiple Decorators or Decorator Chaining in Python

There are several options to explore when using function decorators in your Python project. Another use case would be chaining decorators (two or more) to a function. A function can be decorated with more than one decorator (multiple decorators), and this is achieved by stacking one decorator on top of the other in no particular order. You’ll have the same output no matter the order in which the multiple decorators are placed on top of each other, as seen in the following example:

def increase_decorator(func):
    def increase_by_two():
        print('Increasing number by 2')
        new_number = func()
        return new_number + 2
    return increase_by_two

def decrease_decorator(func):
    def decrease_by_one():
        print('Decreasing number by 1')
        new_number = func()
        return new_number - 1
    return decrease_by_one
def get_number():
    return 5
Increasing number by 2
Decreasing number by 1

Real-life Use Cases of Python Decorators

A very popular way of using decorators in Python is as a time logger. This helps a programmer know the amount of time a function takes to execute as a way of measuring efficiency.

Memoization is another cool way to use decorators in Python. Results from function calls that are repeated without any change can be easily remembered when performing calculations later. You can simply memoize a function with decorators.

Built-in Python decorators like @classmethod (class method), @staticmethod (static method), and @property are very popular in Python’s OOP decorator pattern.


Python decorators enforce the DRY principle of software engineering because they serve as reusable code. Think of the many Python functions you could refactor to decorators. In this article, we’ve explored different forms of decorators. There are also class decorators, although we haven’t touched on those here.

Decorators make it easier to add additional functionality to a simple function, method or class without having to alter its source code while keeping your code DRY. Try decorating functions on your own to better understand the decorator pattern.

FAQs About JavaScript Decorators

What is a JavaScript decorator?

A JavaScript decorator is a design pattern and a feature introduced in ECMAScript 2016 (ES6) and later versions of JavaScript. It allows you to modify or enhance the behavior of functions, methods, or classes in a clean and reusable way by applying annotations or metadata to them. Decorators are commonly used in various JavaScript libraries and frameworks, such as Angular and MobX.
Decorators are typically implemented as functions that wrap or “decorate” the target function or class. They are used to add functionality or alter the behavior of the target without changing its core code. Decorators can be applied to functions, methods, or classes, and they are indicated using the @ symbol followed by the decorator’s name.

Why do we need decorators in JavaScript?

Decorators in JavaScript are a valuable addition to the language for several compelling reasons. They facilitate modularity and code reusability by allowing developers to separate cross-cutting concerns from the core logic of functions and methods. This promotes a cleaner codebase by reducing clutter and enhancing readability, making the code more maintainable and comprehensible. Decorators play a significant role in adhering to the principle of separation of concerns, as they allow you to keep aspects such as security, logging, and configuration separate from your core application logic.
Decorators bring consistency to your codebase by ensuring that specific behaviors or policies are consistently applied to functions and methods. They offer a flexible way to configure and customize the behavior of your functions, making it easy to change or extend functionality without modifying the core code. By supporting aspect-oriented programming (AOP), decorators help address cross-cutting concerns systematically, resulting in cleaner and more organized code. Decorators are also increasingly adopted by third-party libraries and frameworks, making them an essential skill for working with modern JavaScript tools effectively. In summary, decorators improve code organization, readability, maintainability, and extensibility, making them a valuable asset for JavaScript developers.

What is the difference between Python decorators and JavaScript decorators?

Python and JavaScript decorators share the concept of modifying function or method behavior but differ in syntax and usage. Python uses the @decorator_function syntax and can be applied to functions and classes for various purposes. JavaScript decorators use the @decorator syntax and are primarily applied to classes, methods, and properties. Python decorators are more versatile, while JavaScript decorators are class-centric and introduced as part of ECMAScript 2016.

Ini ArthurIni Arthur
View Author

Ini is a startup enthusiast, software engineer and technical writer. Flutter and Django are his favorite tools at the moment for building software solutions. He loves Afrobeats music.

Share this article
Read Next
Get the freshest news and resources for developers, designers and digital creators in your inbox each week