ALWAYSINFOTECH LEARNING CENTRE
TOPIC : Python Decorators
TRE
In Python, a decorator is a design pattern
that allows you to modify the functionality
CEN
of a function by wrapping it in another
function.
NG
The outer function is called the decorator,
RN I
which takes the original function as an
argument and returns a modified version of
L EA
it.
CH
Before we learn about decorators, we need to
O TE
understand a few important concepts related
IN F
to Python functions. Also, remember that
everything in Python is an object, even
A YS
functions are objects.
Nested Function
ALW
We can include one function inside another,
known as a nested function. For example,
def outer(x):
def inner(y):
return x + y
return inner
add_five = outer(5)
TRE
result = add_five(6)
CEN
print(result) # prints 11
NG
# Output: 11
RN I
Here, we have created the inner() function
L EA
inside the outer() function.
CH
Pass Function as Argument
O TE
We can pass a function as an argument to
IN F
another function in Python. For Example,
A YS
ALW
def add(x, y):
return x + y
def calculate(func, x, y):
return func(x, y)
result = calculate(add, 4, 6)
print(result) # prints 10
TRE
CEN
In the above example, the calculate() function
NG
takes a function as its argument. While
RN I
calling calculate(), we are passing the add()
function as the argument.
L EA
CH
In the calculate() function, arguments: func,
O TE
x, y become add, 4, and 6 respectively.
IN F
And hence, func(x, y) becomes add(4, 6) which
A YS
returns 10.
ALW
Return a Function as a Value
In Python, we can also return a function as
a return value. For example,
def greeting(name):
def hello():
return "Hello, " + name + "!"
return hello
greet = greeting("MANPREET")
TRE
print(greet()) # prints "Hello, MANPREET!"
CEN
# Output: Hello, MANPREET!
NG
RN I
In the above example, the return hello
L EA
statement returns the inner hello() function.
This function is now assigned to the greet
CH
O TE
variable.
IN F
That's why, when we call greet() as a
A YS
function, we get the output.
ALW
Python Decorators
As mentioned earlier, A Python decorator is
a function that takes in a function and
returns it by adding some functionality.
In fact, any object which implements the
TRE
special __call__() method is termed callable.
CEN
So, in the most basic sense, a decorator is
NG
a callable that returns a callable.
RN I
Basically, a decorator takes in a function,
L EA
adds some functionality and returns it.
CH
O TE
def make_pretty(func):
def inner():
IN F
print("I got decorated")
A YS
func()
return inner
ALW
def ordinary():
print("I am ordinary")
# Output: I am ordinary
Here, we have created two functions:
that prints "I am ordinary"
TRE
● ordinary()
that takes a function as its
CEN
● make_pretty()
argument and has a nested function named
NG
inner(), and returns the inner function.
RN I
L EA
We are calling the ordinary() function
CH
normally, so we get the output "I am ordinary".
O TE
Now, let's call it using the decorator
IN F
function.
A YS
def make_pretty(func):
ALW
# define the inner function
def inner():
# add some additional behavior to
decorated function
print("I got decorated")
# call original function
func()
# return the inner function
return inner
TRE
# define ordinary function
CEN
def ordinary():
print("I am ordinary")
NG
RN I
# decorate the ordinary function
decorated_func = make_pretty(ordinary)
L EA
# call the decorated function
CH
decorated_func()
O TE
IN F
Output:
I got decorated
A YS
I am ordinary
ALW
In the example shown above, make_pretty() is a
decorator. Notice the code,
decorated_func = make_pretty(ordinary)
● We are now passing the ordinary() function
as the argument to the make_pretty().
● The make_pretty() function returns the
TRE
inner function, and it is now assigned to
CEN
the decorated_func variable.
NG
decorated_func()
RN I
Here, we are actually calling the inner()
L EA
function, where we are printing
CH
O TE
@ Symbol With Decorator
IN F
Instead of assigning the function call to a
A YS
variable, Python provides a much more
ALW
elegant way to achieve this functionality
using the @ symbol. For example,
def make_pretty(func):
def inner():
print("I got decorated")
TRE
func()
CEN
return inner
NG
RN I
L EA
@make_pretty
CH
def ordinary():
O TE
print("I am ordinary")
IN F
A YS
ALW
ordinary()
Output:
I got decorated
I am ordinary
Here, the ordinary() function is decorated
with the make_pretty() decorator using the
@make_pretty syntax, which is equivalent to
calling ordinary = make_pretty(ordinary).
TRE
CEN
NG
RN I
L EA
CH
O TE
IN F
A YS
ALW
