Introduction
Python decorators are a strong characteristic that permits you to modify the habits of capabilities or courses dynamically. Decorators present a approach so as to add performance to current code with out modifying the unique supply. This weblog publish will delve into the idea of decorators in Python, ranging from the fundamentals and progressively progressing to extra superior strategies.
Understanding Decorators
Perform Decorators
Perform decorators are a approach to modify the habits of a operate by wrapping it inside one other operate. The decorator operate takes the unique operate as an argument, provides some performance, and returns a modified operate. This lets you improve or prolong the habits of capabilities with out modifying their supply code.
def uppercase_decorator(func):
def wrapper():
outcome = func()
return outcome.higher()
return wrapper
@uppercase_decorator
def say_hello():
return "Hi there, World!"
print(say_hello()) # Output: HELLO, WORLD!
Within the instance above, the uppercase_decorator operate is outlined to wrap the say_hello operate. It modifies the habits by changing the returned string to uppercase. The @uppercase_decorator syntax is used to use the decorator to the say_hello operate.
Class Decorators
Class decorators are much like operate decorators however function on courses as a substitute of capabilities. They help you modify the habits or add performance to a category. The decorator operate takes the unique class as an argument, creates a derived class with added performance, and returns the modified class.
def add_method_decorator(cls):
def new_method(self):
return "New technique added!"
cls.new_method = new_method
return cls
@add_method_decorator
class MyClass:
def existing_method(self):
return "Present technique referred to as!"
obj = MyClass()
print(obj.existing_method()) # Output: Present technique referred to as!
print(obj.new_method()) # Output: New technique added!
Within the instance above, the add_method_decorator operate wraps the MyClass class and provides a brand new technique referred to as new_method. The @add_method_decorator syntax is used to use the decorator to the MyClass class.
Decorator Syntax and Execution
When utilizing decorators, it’s essential to grasp the order of execution. Decorators are utilized from the underside up, that means the decorator outlined on the high is executed final. This order is essential when a number of decorators are utilized to the identical operate or class.
def decorator1(func):
print("Decorator 1 executed")
return func
def decorator2(func):
print("Decorator 2 executed")
return func
@decorator1
@decorator2
def my_function():
print("Inside my_function")
my_function()
Output:
Decorator 2 executed
Decorator 1 executed
Inside my_function
Within the instance above, the decorator2 decorator is executed first, adopted by the decorator1 decorator. The my_function is then referred to as, and the output displays the order of execution.
