Python - Decorators

A Decorator is a function which can take a function as an argument, extend its functionality, and return a modified function with the extended functionality.

The main objective of decorator functions is to extend the functionality of existing functions without modifying those functions.

Consider the following function:

No output captured.

This function always prints the same output for any name:

No output captured.

Now we want to modify this function so that it provides a different message when the name is Sunny.

We can do this without touching the wish() function by using a decorator.

• decor is a decorator function. It takes func as an argument and returns inner.
• inner() checks whether the name is Sunny. If it is, it prints a different message; otherwise it calls the original func(name).
• @decor above wish tells Python to pass wish through decor. Whenever wish() is called, the extended version executes automatically.

Notice the structure of a typical decorator:

No output captured.

The decorator decor takes the original function func as input, defines an inner function that adds the extra behaviour, and returns inner.

From that point onwards, calling the original function name executes the inner function instead.

If we do not use the @decor syntax, the decorator is not applied automatically.

In that case we can manually pass the function to the decorator to obtain the extended version.

Hello Durga Good Morning
Hello Sunny Good Morning
Hello Durga Good Morning
Hello Sunny Bad Morning

• wish("Durga") and wish("Sunny") call the original function directly, so the decorator is not executed.
• decorfunction = decor(wish) manually creates the extended version.
• decorfunction("Durga") and decorfunction("Sunny") call the extended version, so the decorator is executed.

This decorator prevents a ZeroDivisionError when dividing by zero.

We are dividing 20 with 2
10.0
We are dividing 20 with 0
OOPS...cannot divide
None

Without the decorator, division(20, 0) would raise a ZeroDivisionError.

With the @smart_division decorator, the inner() function checks whether b is 0 before calling the original division(), so the program never crashes.

We can define multiple decorators for the same function. All these decorators together form Decorator Chaining.

No output captured.

When multiple decorators are applied, the decorator closest to the function works first, and then the outer decorator works on its result.

In the example above, decor is applied first, then decor1 is applied to the result.

The decor decorator runs first: it calls num(), gets 10, and returns 2 * 10 = 20.

Then decor1 runs on that result: it calls the already-decorated function, gets 20, and returns 20 * 20 = 400.

Therefore, the final output is 400.

The output confirms the order of chaining:

1. decor1 (the outer decorator) starts first.
2. It calls the decor-wrapped function, which prints the first message.
3. Finally the original wish() body executes.