Decorators are very powerful and useful tool in Python since it allows programmers to modify the behavior of function or class. Decorators allow us to wrap another function in order to extend the behavior of the wrapped function, without permanently modifying it. But before diving deep into decorators let us understand some concepts that will come in handy in learning the decorators.
First Class Objects
In Python, functions are first class objects that means that functions in Python can be used or passed as arguments.
Properties of first class functions:
- A function is an instance of the Object type.
- You can store the function in a variable.
- You can pass the function as a parameter to another function.
- You can return the function from a function.
- You can store them in data structures such as hash tables, lists, …
Consider the below examples for better understanding.
Example 1: Treating the functions as objects.
In the above example, we have assigned the function shout to a variable. This will not call the function instead it takes the function object referenced by shout and creates a second name pointing to it, yell.
Example 2: Passing the function as argument
HI, I AM CREATED BY A FUNCTION PASSED AS AN ARGUMENT. hi, i am created by a function passed as an argument.
In the above example, the greet function takes another function as a parameter (shout and whisper in this case). The function passed as argument is then called inside the function greet.
Example 3: Returning functions from another functions.
In the above example, we have created a function inside of another function and then have returned the function created inside.
The above three examples depict the important concepts that are needed to understand decorators. After going through them let us now dive deep into decorators.
As stated above the decorators are used to modify the behavior of function or class. In Decorators, functions are taken as the argument into another function and then called inside the wrapper function.
Syntax for Decorator:
@gfg_decorator def hello_decorator(): print("Gfg") '''Above code is equivalent to - def hello_decorator(): print("Gfg") hello_decorator = gfg_decorator(hello_decorator)'''
In the above code,
gfg_decorator is a callable function, will add some code on the top of some another callable function,
hello_decorator function and return the wrapper function.
Decorator can modify the behavior:
Hello, this is before function execution This is inside the function !! This is after function execution
Let’s see the behavior of the above code how it runs step by step when the “function_to_be_used” is called.
Let’s jump to another example where we can easily find out the execution time of a function using a decorator.
3628800 Total time taken in : factorial 2.0061802864074707
What if a function returns something or an argument is passed to the function?
In all the above examples the functions didn’t return anything so there wasn’t any issue, but one may need the returned value.
before Execution Inside the function after Execution Sum = 3
In the above example, you may notice a keen difference in the parameters of the inner function. The inner function takes the argument as *args and **kwargs which means that a tuple of positional arguments or a dictionary of keyword arguments can be passed of any length. This makes it a general decorator that can decorate a function having any number of arguments.
In simpler terms chaining decorators means decorating a function with multiple decorators.
The above example is similar to calling the function as –
Attention geek! Strengthen your foundations with the Python Programming Foundation Course and learn the basics.
To begin with, your interview preparations Enhance your Data Structures concepts with the Python DS Course. And to begin with your Machine Learning Journey, join the Machine Learning – Basic Level Course