Decorators let you add extra behavior to a function, without changing the function's code.
A decorator is a function that takes another function as input and returns a new function.
Basic Decorator
Define the decorator first, then apply it with @decorator_name above the function.
Example
def changecase(func):
def myinner():
return func().upper()
return myinner
@changecase
def myfunction():
return "Hello Sally"
print(myfunction())
By placing @changecase directly above the function definition, the function myfunction is being "decorated" with the changecase function.
The function changecase is the decorator.
The function myfunction is the function that gets decorated.
Multiple Decorator Calls
A decorator can be called multiple times. Just place the decorator above the function you want to decorate.
Example
def changecase(func):
def myinner():
return func().upper()
return myinner
@changecase
def myfunction():
return "Hello Sally"
@changecase
def otherfunction():
return "I am speed!"
print(myfunction())
print(otherfunction())
Arguments in the Decorated Function
Functions that require arguments can also be decorated, just make sure you pass the arguments to the wrapper function:
Example
def changecase(func):
def myinner(x):
return func(x).upper()
return myinner
@changecase
def myfunction(nam):
return "Hello " + nam
print(myfunction("John"))
*args and **kwargs
Note: Sometimes the decorator function has no control over the arguments passed from decorated function, to solve this problem, add
(*args, **kwargs)to the wrapper function, this way the wrapper function can accept any number, and any type of arguments, and pass them to the decorated function.
Example
def changecase(func):
def myinner(*args, **kwargs):
return func(*args, **kwargs).upper()
return myinner
@changecase
def myfunction(nam):
return "Hello " + nam
print(myfunction("John"))
Decorator With Arguments
Decorators can accept their own arguments by adding another wrapper level.
Example
def changecase(n):
def changecase(func):
def myinner():
if n == 1:
a = func().lower()
else:
a = func().upper()
return a
return myinner
return changecase
@changecase(1)
def myfunction():
return "Hello Linus"
print(myfunction())
Multiple Decorators
You can use multiple decorators on one function.
This is done by placing the decorator calls on top of each other.
Decorators are called in the reverse order, starting with the one closest to the function.
Example
def changecase(func):
def myinner():
return func().upper()
return myinner
def addgreeting(func):
def myinner():
return "Hello " + func() + " Have a good day!"
return myinner
@changecase
@addgreeting
def myfunction():
return "Tobias"
print(myfunction())
Preserving Function Metadata
Functions in Python has metadata that can be accessed using the __name__ and __doc__ attributes.
Example
def myfunction():
return "Have a great day!"
print(myfunction.__name__)
But, when a function is decorated, the metadata of the original function is lost.
Example
def changecase(func):
def myinner():
return func().upper()
return myinner
@changecase
def myfunction():
return "Have a great day!"
print(myfunction.__name__)
To fix this, Python has a built-in function called functools.wraps that can be used to preserve the original function's name and docstring.
Example
import functools
def changecase(func):
@functools.wraps(func)
def myinner():
return func().upper()
return myinner
@changecase
def myfunction():
return "Have a great day!"
print(myfunction.__name__)
