Decorators

Contents

Decorators#

It’s a sugar that allows to modify behaviour of the functions or classes.

Syntax#

Decorator actually is just a function that takes fucntion and return other function.

The following cell defines a decorator, which is a function that takes another function as an argument and returns a modified version of that function. During the creation of the new function, it prints Functionality during function modification. Additionally, it prints Functionality to be added. each time the modified function is called.

def wrapper_function(modified_function):
    print("Functionality during function modification.")
    def inner_function():
        print("Functionality to be added.")
        modified_function()
    return inner_function

Now the most straighfoward way to use it. Here defined earlier wrapper_function is used for getting decorated_function which is modification of the function_to_decoration.

def function_to_decoration():
    print("Original functionality")

decorated_function = wrapper_function(function_to_decoration)

Functionality during function modification.

So during modification we got executed print("Functionality during function modification.").

decorated_function()

Functionality to be added.
Original functionality

Each call executes the functionality defined by inner_function, followed by the original function in function_to_decorate.

This may seem like playful experimentation with functions, but you can achieve the same result using the following syntax:

@wrapper_function
def function_to_decoration():
    print("Original functionality")

Functionality during function modification.

The code in the previous cell is equivalent to function_to_decorate = wrapper_function(function_to_decorate). As a result, the output behaves the same way as it did without using any special syntax.

function_to_decoration()

Functionality to be added.
Original functionality

Parameters#

Sometimes you may encounter constructions where arguments are passed to decorators — let’s explore how this can be implemented.

The following cell defines a decorator called multiply, which extends a function that takes two floats by multiplying the result by a specified value.

def multiply(multiplier: float):
    def wrapper(func):
        def modifier(a: float, b: float):
            return func(a, b)*multiplier
        return modifier
    return wrapper

Technically, it’s a function with a multiplier parameter that returns another function, which in turn returns a final function that performs the multiplication.

The most straightforward way to apply it to a function is demonstrated in the following cell.

@multiply(3)
def summation(a: float, b: float):
    return a + b

Let’s try just created function.

summation(2, 3)

15

  • 2+3=5 functional of the function.

  • 5*3=15 function of the decorator.

Contents