DECORATORS

Decorators in Python

In Python, functions are the first class objects, which means that –

·         Functions are objects; they can be referenced to, passed to a variable and returned from other functions as well.

·         Functions can be defined inside another function and can also be passed as argument to another function.

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 wrapped function, without permanently modifying it.

In Decorators, functions are taken as the argument into another function and then called inside the wrapper function.

Syntax for Decorator:

@gfg_decorator defhello_decorator():     print("Gfg")    '''Above code is equivalent to -    defhello_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:

 

# defining a decorator defhello_decorator(func):        # inner1 is a Wrapper function in      # which the argument is called            # inner function can access the outer local     # functions like in this case "func"     definner1():         print("Hello, this is before function execution")            # calling the actual function now         # inside the wrapper function.         func()            print("This is after function execution")                returninner1       # defining a function, to be called inside wrapper deffunction_to_be_used():     print("This is inside the function !!") # passing 'function_to_be_used' inside the # decorator to control its behavior function_to_be_used =hello_decorator(function_to_be_used)       # calling the function function_to_be_used()

 

Output:

Hello, this is before function execution

This is inside the function !!

This is after function execution

Let’s jump to another example where we can easily find out the execution time of a function using a decorator.

# importing libraries importtime importmath    # decorator to calculate duration # taken by any function. defcalculate_time(func):            # added arguments inside the inner1,     # if function takes any arguments,     # can be added like this.     definner1(*args, **kwargs):            # storing time before function execution         begin =time.time()                    func(*args, **kwargs)            # storing time after function execution         end =time.time()         print("Total time taken in : ", func.__name__, end -begin)        returninner1      # this can be added to any function present, # in this case to calculate a factorial @calculate_time deffactorial(num):        # sleep 2 seconds because it takes very less time     # so that you can see the actual difference     time.sleep(2)     print(math.factorial(num))    # calling the function. factorial(10)

 

Output:

3628800

Total time taken in :  factorial 2.0061802864074707

 

What if a function returns something –

In all the above examples the functions didn’t return anything so there wasn’t any issue, but one may need the returned value.

defhello_decorator(func):     definner1(*args, **kwargs):                    print("before Execution")                    # getting the returned value         returned_value =func(*args, **kwargs)         print("after Execution")                    # returning the value to the original frame         returnreturned_value                returninner1    # adding decorator to the function @hello_decorator defsum_two_numbers(a, b):     print("Inside the function")     returna +b    a, b =1, 2    # getting the value through return of the function print("Sum =", sum_two_numbers(a, b))

 

Output:

 

before Execution

Inside the function

after Execution

Sum = 3