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.

# defining a decorator 
def hello_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" 
    def inner1(): 
        print("Hello, this is before function execution") 
  
        # calling the actual function now 
        # inside the wrapper function. 
        func() 
  
        print("This is after function execution") 
          
    return inner1
# defining a function, to be called inside wrapper 
def function_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

---

Decorators with parameters in Python

Python functions are First Class citizens which means that functions can be treated similar to objects.
Function can be assigned to a variable i.e they can be referenced.
Function can be passed as an argument to another function.
Function can be returned from a function.
Decorators with parameters is similar to normal decorators.
Syntax for decorators with parameters –

@decorator(params)
def func_name():
    ''' Function implementation'''

As the execution starts from left to right decorator(params) is called which returns a function object fun_obj. Using the fun_obj the call fun_obj(fun_name) is made. Inside the inner function, required operations are performed and the actual function reference is returned which will be assigned to func_name. Now, func_name() can be used to call the function with decorator applied on it.
How Decorator with parameters is implemented

def decorators(*args, **kwargs): 
    def inner(func): 
        ''' 
           do operations with func 
        '''
        return func 
    return inner #this is the fun_obj mentioned in the above content 
  
@decorators(params) 
def func(): 
    """ 
         function implementation 
    """

Here params can also be empty.