In this Python Decorator tutorial, we will study what a decorator is in Python and why we use Python Nested Functions.<\/p>\n
Along with this, we will learn Python Decorators with Parameters and Python Pie Syntax. At last, we will study Chaining Decorators in the Python programming language.<\/p>\n
In Python, a function is a first-class object. This means that you can pass it around with absolute ease.<\/p>\n
You can return it, and even pass it as an argument to another. You can also nest a Python function inside another.<\/p>\n
So, let’s start the Python Decorator Tutorial.<\/p>\n
Python Decorator function is a function that adds functionality to another, but does not modify it. In other words, a Python Decorator wraps another function.<\/p>\n
Advantages of decorators in Python:<\/strong><\/p>\n In the rest of the lesson, we will see the Python syntax of a Python decorator in detail. This is useful in cases when you want to add functionality to a function, but don\u2019t want to modify it for the same.<\/p>\n Let\u2019s take a look.<\/p>\n Talking about Python decorators for the first time can be confusing. So we begin with a very simple example with no arguments.<\/p>\n Take this code.<\/p>\n Output<\/strong><\/p>\n $$$$$$$$$$$$$$$$$$$$$$<\/p>\n Hello<\/p>\n $$$$$$$$$$$$$$$$$$$$$$<\/p>\n<\/div>\n Now let\u2019s see each part of the syntax one by one.<\/p>\n First, we define a simple function sayhello() that prints out \u201cHello\u201d. Now, we\u2019ll define the decorator function in Python.<\/p>\n You can call this anything; it doesn\u2019t have to be \u2018decor\u2019. This is a higher order function. Note that the relative order of these functions does not matter.<\/p>\n You could define sayhello() before defining decor(), and it wouldn\u2019t make a difference. Let\u2019s discuss the decor function in detail.<\/p>\n def decor(func):<\/strong><\/p>\n The first thing to notice here is that it takes a function as an argument. This is the function that we want to decorate.<\/p>\n We want to call it func; you may want to call it something else. Inside this function, we nest a function, and we call it wrap().<\/p>\n Again, you can call it anything you want.<\/p>\n It is inside this function that we put our extra functionality, and also call the function to be decorated.<\/p>\n Here, we used some print statements. It could have been anything else too, like an if-block.<\/p>\n Finally, we make the decor() function return the wrap function.<\/p>\n return wrap<\/p>\n Why do we do this? We\u2019ll discuss this further in this lesson.<\/p>\n Finally, we assign this Python decorator to a variable\u00a0and pass the function to be decorated as an argument to the decorating function.<\/p>\n newfunc=decor(sayhello)<\/strong><\/p>\n Then, we call the function using parentheses after the variable to which we assign the decorators in Python.<\/p>\n newfunc()<\/strong><\/p>\n However, you can also assign this to the function to be decorated itself. This will reassign it. Let\u2019s see that as well.<\/p>\n Output<\/strong><\/p>\n $<\/p>\n Hello<\/p>\n $<\/p>\n<\/div>\n When I was attempting to understand Python decorators, this question totally confused me. Why do we use the wrap function, and then return it?<\/p>\n Couldn\u2019t we simply write the code inside the decor function? So I ended up on the interpreter, trying it out.<\/p>\n Here, we wrote the extra functionality right inside our decor() function. Now, let\u2019s try to assign it to a variable.<\/p>\n Output<\/strong><\/p>\n $<\/p>\n Hello<\/p>\n $<\/p>\n<\/div>\n Woah. Why did it print it out? This is because decor() calls a function (here, func) instead of returning a value.<\/p>\n When we use wrap (or whatever you\u2019d call it), and then return it, we can store it in a variable. Then, we can use that name to call the decorated function whenever we want.<\/p>\n Now let\u2019s call the newfunc() function.<\/p>\n Output<\/strong><\/p>\n Traceback (most recent call last):File “<pyshell#70>”, line 1, in <module><\/p>\n newfunc()<\/p>\n TypeError: ‘NoneType’ object is not callable<\/p>\n<\/div>\n As you can see, since decor did not return a value, the line of assignment did not assign the decorated function to newfunc. This is why it isn\u2019t callable.<\/p>\n So, it is impossible to access this Python decorator again except for the following method:<\/p>\n Output<\/strong><\/p>\n $<\/p>\n Hello<\/p>\n $<\/p>\n<\/div>\n Finally, let\u2019s try calling our original function sayhello().<\/p>\n Output<\/strong><\/p>\n Works perfectly. See, decor() did not modify sayhello().<\/p>\n We use the same example everywhere, so you can focus on what\u2019s being explained and not be invested in trying to understand the code.<\/p>\n So far, we\u2019ve only seen decorators in Python with regular print statements. Now, let\u2019s get into the real thing.<\/p>\n To see how decorators fare with parameters, we\u2019ll take the example of a function that divides two values. All that our function does is to return the division of two numbers.<\/p>\n But when we decorate it, we add functionality to deal with the situation where the denomination is 0. Watch how.<\/p>\n Like you can see, the Python decorator function takes one argument for the function to decorate. The wrapper here takes the same arguments as the function to decorate.<\/p>\n Finally, we return the function to be decorated instead of calling it. This is because we want to return a value here from the divide() to the wrapper() to the decorator().<\/p>\n When we call func, it remembers the value of func from the argument to the function decorator(). This is called closure in Python.<\/p>\n Here\u2019s another example to clear this up.<\/p>\n Output<\/strong><\/p>\n Also, note that if we called func(a,b) instead of returning it, we\u2019d get this:<\/p>\n Output<\/strong><\/p>\n Now, let\u2019s assign and call.<\/p>\n Output<\/strong><\/p>\n Output<\/strong><\/p>\n Problem Solved.<\/p>\n If you don\u2019t want to type in the whole list of arguments for the two statements, *args and **kwargs will do the trick for you.<\/p>\n Output<\/strong><\/p>\n See, it works. Actually, *args is a tuple of arguments, and **kwargs is a dictionary of keyword arguments.<\/p>\n Any Doubt yet in Python 3 Decorators? Please ask in comments.<\/p>\n If you feel the assignment and calling statements are unnecessary, we\u2019ve got the pie syntax for you.<\/p>\n It\u2019s simple; name the decorating function after the @ symbol, and put this before the function to decorate.<\/p>\n Here\u2019s an example.<\/p>\n Output<\/strong><\/p>\n $$<\/p>\n Hello<\/p>\n $$<\/p>\n<\/div>\n You don\u2019t have to settle with just one Python decorator. That\u2019s the beauty of the pie syntax. Let\u2019s see how.<\/p>\n Now, let\u2019s define the sayhello() function. We\u2019ll use decor1 and decor2 on this.<\/p>\n Output<\/strong><\/p>\n $$$$$$$$$$$$$$<\/p>\n Hello<\/p>\n $$$$$$$$$$$$$$<\/p>\n<\/div>\n Note how the octothorpes (#) are sandwiched by dollars ($)?<\/p>\n This lends us an important piece of information- the order of the decorators in python in the pie syntax matters. Since we used decor1 first, we get the dollars first.<\/p>\n This was all about the Python Decorator Tutorial.<\/p>\n 1. What is a decorator in Python? Explain with an example.<\/p>\n 2. How do you create a decorator in Python?<\/p>\n 3. How do you decorate a class in Python?<\/p>\n 4. Where are Python decorators used?<\/p>\n 5. What do decorators do in Python?<\/p>\n A decorator is a function that takes another function and returns a new callable that usually adds a small behavior change\u2014logging, timing, caching\u2014while leaving the original code untouched.<\/p>\n We also saw the pie syntax for the same. And now you know- anything that confuses you, you can conquer it by facing it, for you can\u2019t run forever.<\/p>\n Escape isn\u2019t real. See you again.<\/p>\n","protected":false},"excerpt":{"rendered":" In this Python Decorator tutorial, we will study what a decorator is in Python and why we use Python Nested Functions. Along with this, we will learn Python Decorators with Parameters and Python Pie...<\/p>\n","protected":false},"author":5,"featured_media":35976,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[46],"tags":[3644,3645,3647,10396,10453,10474],"class_list":["post-6007","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python","tag-decorator-arguments","tag-decorator-function-in-python","tag-decorators-in-python","tag-python-built-in-decorators","tag-python-custom-decorators","tag-python-decorators"],"yoast_head":"\n\n
A Simple Python Decorator<\/h3>\n
>>> def decor(func):\r\n\tdef wrap():\r\n\t\tprint(\"$$$$$$$$$$$$$$$$$$$$$$\")\r\n\t\tfunc()\r\n\t\tprint(\"$$$$$$$$$$$$$$$$$$$$$$\")\r\n\treturn wrap\r\n>>> def sayhello():\r\n print(\"Hello\")\r\n>>> newfunc=decor(sayhello)\r\n>>> newfunc()<\/pre>\n
1. Python Decorator Function<\/h4>\n
2. The nested wrap function<\/h4>\n
def wrap():\r\n print(\"$$$$$$$$$$$$$$$$$$$$$$\")\r\n func()\r\n print(\"$$$$$$$$$$$$$$$$$$$$$$\")<\/pre>\n
3. Assigning and Calling Python Decorator<\/h4>\n
>>> def sayhello():\r\n print(\"Hello\")\r\n>>> def decor(func):\r\n\tdef wrap():\r\n\t\tprint(\"$\")\r\n\t\tfunc()\r\n\t\tprint(\"$\")\r\n\treturn wrap\r\n>>> sayhello=decor(sayhello)\r\n>>> sayhello()<\/pre>\n
Why use a Python Nested Function?<\/h3>\n
>>> def decor(func):\r\n print(\"$\")\r\n func()\r\n print(\"$\")\r\n>>> def sayhello():\r\n print(\"Hello\")<\/pre>\n
>>> newfunc=decor(sayhello)<\/pre>\n
>>> newfunc()<\/pre>\n
>>> decor(sayhello)<\/pre>\n
>>> sayhello()<\/pre>\n
Python Decorator with Parameters<\/h3>\n
>>> def divide(a,b):\r\n return a\/b\r\n>>> def decorator(func):\r\n def wrapper(a,b):\r\n if b==0:\r\n print(\"Can't divide by 0!\")\r\n return\r\n return func(a,b)\r\n return wrapper<\/pre>\n
1. Python Closure<\/h4>\n
>>> msg=\"Hello\"\r\n>>> def func1(msg):\r\n def func2():\r\n print(msg)\r\n func2()\r\n\r\n>>> func1(msg)<\/pre>\n
>>> divide(2,3)\r\n>>> print(divide(2,3))<\/pre>\n
>>> divide=decorator(divide)\r\n>>> divide(2,3)<\/pre>\n
>>> divide(2,0)<\/pre>\n
2. *args and **kwargs in Python<\/h4>\n
>>> def divide(a,b):\r\n return a\/b\r\n>>> def decorate(func):\r\n def wrapper(*args,**kwargs):\r\n if args[1]==0:\r\n print(\"Can't divide by 0!\")\r\n return\r\n return func(*args,**kwargs)\r\n return wrapper\r\n\r\n>>> divide=decorate(divide)\r\n>>> divide(2,0)<\/pre>\n
Pie Syntax in Python<\/h3>\n
>>> @decor\r\ndef sayhello():\r\n print(\"Hello\")\r\n>>> sayhello()<\/pre>\n
Chaining Decorators in Python<\/h3>\n
>>> def decor1(func):\r\n def wrap():\r\n print(\"$$$$$$$$$$$$$$\")\r\n func()\r\n print(\"$$$$$$$$$$$$$$\")\r\n return wrap\r\n\r\n>>> def decor2(func):\r\n def wrap():\r\n print(\"##############\")\r\n func()\r\n print(\"##############\")\r\n return wrap<\/pre>\n
>>> @decor1\r\n@decor2\r\ndef sayhello():\r\n print(\"Hello\")\r\n\r\n>>> sayhello()<\/pre>\n
########<\/h6>\n
########<\/h6>\n
Python Interview Questions on Decorators<\/h3>\n
Conclusion<\/h3>\n