Decorators in Python are the design pattern that allows the users to add new functionalities to an existing object without the need to modify its structure. Decorators are generally called before defining a function the user wants to decorate.
Example:
# 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() |
Hello, this is before function execution This is inside the function !! This is after function execution
Note: For more information, refer to Decorators in Python
Decorator to print Function call details
Let’s consider a scenario where you have written a very lengthy code and want to know the function call details. So what you can do is scroll through your code each and every time for different functions to know their details or you can work smartly. You can create a decorator that can print the details of any function you want.
To do this the functions in Python certain attributes. One such attribute is __code__ that returns the called function bytecode. The __code__ attributes also have certain attributes that will help us in performing our tasks. We will be using the co_varnames attribute that returns the tuple of names of arguments and local variables and co_argcount that returns the number of arguments (not including keyword-only arguments, * or ** args). Let’s see the below implementation of such decorator using these discussed attributes.
Example:
# Decorator to print function call # details def function_details(func): # Getting the argument names of the # called function argnames = func.__code__.co_varnames[:func.__code__.co_argcount] # Getting the Function name of the # called function fname = func.__name__ def inner_func(*args, **kwargs): print(fname, "(", end = "") # printing the function arguments print(', '.join( '% s = % r' % entry for entry in zip(argnames, args[:len(argnames)])), end = ", ") # Printing the variable length Arguments print("args =", list(args[len(argnames):]), end = ", ") # Printing the variable length keyword # arguments print("kwargs =", kwargs, end = "") print(")") return inner_func # Driver Code @function_detailsdef GFG(a, b = 1, *args, **kwargs): pass GFG(1, 2, 3, 4, 5, d = 6, g = 12.9) GFG(1, 2, 3) GFG(1, 2, d = 'Geeks') |
GFG (a = 1, b = 2, args = [3, 4, 5], kwargs = {'d': 6, 'g': 12.9})
GFG (a = 1, b = 2, args = [3], kwargs = {})
GFG (a = 1, b = 2, args = [], kwargs = {'d': 'Geeks'})
