This is your facilitator commander for this course decorators in Python. Earlier we discussed definition of decorators its syntax, and how simple decorators could be created and how it works. In this video, we'll be discussing a bit more complex example of decorator. Besides we'll be discussing how decorators work with parameters. We also discussed that in the third video, but we are going to discuss this with more details and focus. And in the upcoming video, we'll be discussing more on chaining decorators in Python and detail and, and with focus.

So let's begin. Here I imported the library time, it had some calculating or time and I even if we want to like record the time, we can do this with the help of this library. We can also make the function sleep with the help of the functions available in this library. What we are going to do Here our focus is on parameters within decorators decorator functions. Here you can see that I've passed arguments and key value arguments as parameters within the time function. So, it means that there could be variable number of arguments here and variable number of key value arguments here, that could be passed within the time to function.

Now the core and the most important thing is when we are creating a decorator function with parameters we have to make sure that that the arguments that are being passed within the internal function of the decorator has to match with the decorator function with the function to be decorated. It has to be same. Let's discuss this. Here, we are using the input function here. And within that input function again, we have the same parameters. That is our variable number of arguments and variable number of key value arguments.

This is the most important thing when we are working with parameters within the decorator functions. Let's discuss the functionality of this function. This is the time test function, we have created another internal time function and we are passing arguments in key value argument within the time function. We just note the start time that is time dot time, this is a function within the timeline library and then we are passing on the function to be decorated that is input underscore funk and it also has the same arguments. Now then after that passing, we are recording the and time that is timed time. And then we are printing method name.

Argument one, key value argument two and the execution time and how do we want this to be formatted? Here, within the format function, we identify that input funk, whatever funk whatever function that we have defined. Created dot constructor name, the name of that function, the arguments on the first place arguments or key value arguments on the second place and the end time minus start time, that is how much time it took to execute the function. We have already recorded the start time, but at the start of this internal function within the decorator function and and time after that function decorated function has been passed, then what we are doing we are returning the result that is the internal function the function that we decorated and we are going to terminate the program terminate the function, this resolve function, then we are going to terminate the function and then we are going to move forward towards the time function and returning the time function.

Now, let's create the function to be decorated. This is the function we defined It also has the key variable number of arguments and key value arguments, what we are doing we are making this function to sleep for 0.6 seconds, it could be like any number, but why we are doing this. So, that is the difference between or there is a clear difference between the start time of the function and end time of the function so that we can know that how long that actually it took to execute that function. Then we are printing inside function and printing the arguments in key value arguments within that function. So, just before moving forward, let's execute this. Okay, this is executed.

Next again, and we execute this. This is also executed. Now, I'm testing this function and the arguments variable number of arguments I've passed as list that has hello world and The key value arguments I pass two key value pairs that is start and end. Okay. So when I execute this function, it prints inside funk that we just asked it to print, and then they give arguments in key value arguments we printed that. Now I decorated this function with the time test function that we initially created.

And now let's see how it works. So, I just printed that. Now this function has been decorated with time test function. When I executed this function with these parameters, it just meant it inside funk that was this and then it printed the arguments and then it printed the actual method name That is the func the argument HelloWorld. key value arguments are start two and five, and the execution type of timeout 0.6. So it actually took the 0.6 was the sleep time.

And actually, the whole running of this function took point triple 011 seconds. Now, let's go back to the actual decorator function. That function was calculating the start time and time after this decorator function is being done, or executed, and then it's printing all these things like the method name, the argument one, the arguments, the key value arguments, and the execution time and then returning this result, then returning the function and there you can see method Name arguments key value arguments and execution time. Another example here we are using a smart divide function. And what it does, it just divides not only just divides, it actually tests if the division is possible or not. For example, if the parameter pass is zero, instead of any positive integer, it division cannot take place because zero gives an error.

So, first of all we are printing a and b and its value and then we are checking if b is equals to zero, then the condition becomes true and it prints whoops cannot divide and then return or actually terminates the function and at the end it just returns the inner function. This is always going to take place you already know about it. Let's execute this. Okay, now using the smart device With the divide function, we decorating this, and then let's try this non providing three by zero and let's check out if it works or not. Yes, I'm going to divide three and zero oops, cannot divide. And if I divide it by two, I'm going to do it three and two, and it's resulted in 1.5.

So, as a keen observer, you must have noticed that the parameters of the nested function inside the decorator is same as the parameters a function that decorates So, the inner function that is within the decorator function has the same query parameter as the function to be decorated. And this is the same thing that we earlier discussed that the signature of inner function in the decorator must match the function to decorate signature of inner function in the decorator must match the function to decorate I hope now you have a better understanding of parameters and how to use parameters in decorated functions. And you'd be able to use that also, may you have any queries feel free to contact and in the upcoming video we'll be discussing chaining that decorators. Thank you. And don't forget to if you're looking to get connected, you can connect me by subscribing or by Cisco subscribing to my channel, youtube channel, by on Twitter, and also on Udemy by getting the course you can also message me if you're looking for 100% Scott a sponsorship of the course.

Thank you