There is a very interesting feature in python known as Decorators, that is used to add additional functionality to the existing code.<\/p>\n
Because this feature tries to modify the existing code functionality, this is known as metaprogramming.<\/p>\n
One must be completely familiar with the concept of python, that everything in python is an object. These objects can be recognized using names that we give to objects. Functions are also objects with attributes. One can give many diff names to the same function object. So in the above example, both functions one<\/strong> and two <\/strong>give the same result because both names refer to the same function object.<\/p>\n After that things are getting a bit more complicated. Because a function can be passed to another function as an argument. call functions<\/strong> also, a function can return another function<\/strong> In the above example, return_fun returns the call_fun when called.<\/p>\n The objects which allow the __call__() method are called callable. So, a decorator is a callable object that returns a callable. In general, one can say, a decorator takes a function and adds some functionality, and returns it.<\/p>\n Now let\u2019s consider an e.g that shows us how to decorate a function<\/strong> Here, in the above example deco()<\/strong> is a decorator. The function initial()<\/strong> is decorated by function deco(). Here as one can see how deco() changes or we can say add some new functionality to the initial function. It\u2019s similar to wrapping a thing, so one can refer to a decorator as a wrapper within which some new or changed functionalities can be wrapped.<\/p>\n Note:<\/em><\/strong> the function carried out by the decorator will never gonna alter.<\/p>\n That\u2019s why one can use @ symbol followed by the decorator function name and write it just above the function that one wants to decorate.<\/p>\n Just like <\/strong>
\ne.g.<\/strong>
\ndef one(a):
\nprint(a)
\none(\u2018asd\u2019)
\ntwo=one
\ntwo(\u2018asd\u2019)0
\no\/p:<\/strong>
\nasd
\nasd
\n<\/code><\/p>\n
\nFor example, we use reduce <\/strong>and filter <\/strong>functions in python.
\nFunctions like these can take other functions as arguments are known as higher-order<\/strong> functions.
\ne.g.
\nmake functions<\/strong>
\ndef increment(z):
\nreturn z + 1
\ndef decrement(z):
\nreturn z - 1
\ndef main(func, z):
\nresult = func(z)
\nreturn result<\/code><\/p>\n
\nmain(increment,1)
\nmain(decrement,1)
\no\/p
\n2
\n0<\/p>\n
\ndef call_fun():
\ndef return_fun():
\nprint(\"yo\")
\nreturn return_fun
\nwer = call_fun()
\nwer()
\no\/p
\nYo<\/code><\/p>\n
\ndef deco(func):
\ndef inner():
\nprint(\"decorated\")
\nfunc()
\nreturn inner
\ndef initial():
\nprint(\"initial\")
\nOn run this will provide o\/p like this:
\n>> initial()
\ninitial
\n# on decorating initial function
\n>> decorate = deco(initial)
\n>> decorate()
\ndecorated
\ninitial<\/code><\/p>\n
\n@deco
\ndef initial():
\nprint(\"initial\")<\/code><\/p>\n