Python - Decorators - Zone of Development

In this post, we’ll see what Decorators are, look at some built-in decorators, and see how to create our own custom decorator.
But first of all, what is a Decorator?
“A decorator is a design pattern in Python that allows us to add new functionality to our existing object without modifying its structure. Decorators are implemented as functions that take another function as an argument, extend its behavior, and return a new function with the extended behavior.“
In a nutshell, a decorator wraps another function and allows us to execute code before and after the wrapped function runs, without modifying the function itself.

Python comes with several built-in decorators that are commonly used in object-oriented programming and some of them are:
@staticmethod – It turns a method into a static method, which means it doesn’t receive the implicit self argument.

[MATHOPERATION.PY]

class MathOperation:
    @staticmethod
    def sum(a, b):
        return a+b
 
    def multiplication(self, a, b):
        return a*b

[MAIN.PY]

from MathOperation import MathOperation
 
objMath = MathOperation()
 
print(f"The result of 5*5 is {objMath.multiplication(5,5)}")
 
print(f"The result of 5+5 is {MathOperation.sum(5,5)}")

@classmethod – It is used to define a method that’s bound to the class and not the instance of the class.
One of the most common uses, is to create instance of a class using different types of data.

[PERSON.PY]

import datetime
 
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    @classmethod
    def from_birth_year(cls, name, birth_year):
        current_year = datetime.datetime.now().year
        age = current_year - birth_year
        return cls(name, age)

[MAIN.PY]

from Person import Person
 
objPerson = Person("Damiano1", 33)
objPerson2 = Person.from_birth_year("Damiano2", 1991)
 
print(objPerson.age)
print(objPerson2.age)

@property – It allows us to define methods in a class that can be accessed like attributes.
Moreover, it allows us to add logic when accessing or setting an attribute without changing the external interface of our class.

[RECTANGLE.PY]

class Rectangle:
    def __init__(self, width, height):
        self.width = width  # Calls the width setter
        self.height = height  # Calls the height setter
 
    @property
    def width(self):
        return self._width
 
    @width.setter
    def width(self, value):
        if value <= 0:
            raise ValueError("Width must be positive.")
        self._width = value
 
    @property
    def height(self):
        return self._height
 
    @height.setter
    def height(self, value):
        if value <= 0:
            raise ValueError("Height must be positive.")
        self._height = value
 
    @property
    def area(self):
        return self.width * self.height

[MAIN.PY]

from Rectangle import Rectangle
 
objRect = Rectangle(5, 10)
print(
    f"The area of the Rectangle ({objRect.width} - {objRect.height}) is :{objRect.area}")
 
objRect.width = 7
print(
    f"The area of the Rectangle ({objRect.width} - {objRect.height}) is :{objRect.area}")
 
 
objRect.width = -7
print(
    f"The area of the Rectangle ({objRect.width} - {objRect.height}) is :{objRect.area}")

@abstractmethod – This decorator from the “abc” module indicates that a method must be overridden in a subclass, effectively making the class abstract.

[VEHICLE.PY]

from abc import ABC, abstractmethod
 
 
class Vehicle(ABC):
    @abstractmethod
    def start_engine(self):
        pass

[CARFERRARI.PY]

from Vehicle import Vehicle
 
 
class CarFerrari(Vehicle):
    def start_engine(self):
        print("Start from Ferrari engine")

[CARFORD.PY]

from Vehicle import Vehicle
 
 
class CarFord(Vehicle):
    def start_engine(self):
        print("Start from Ford engine")

[MAIN.PY]

from CarFerrari import CarFerrari
from CarFord import CarFord
 
carFerrari = CarFerrari()
carFord = CarFord()
 
carFerrari.start_engine()
carFord.start_engine()

@dataclass – It automatically adds special methods like __init()__ to the class.

[EMPLOYEE.PY]

from dataclasses import dataclass
 
 
@dataclass
class Employee:
    name: str
    position: str
    salary: float
 
    def print_info(self):
        print(
            f"Employee info: name='{self.name}', position='{self.position}', salary={self.salary}")

[MAIN.PY]

from Employee import Employee
 
objEmp = Employee('Damiano', 'Director', 120000)
 
objEmp.print_info()

CUSTOM DECORATOR – Finally, we will see how to create a custom Decorator called @timer, to calculate and display the time a function takes to execute.

[TIMER.PY]

import time  # Import the time module to work with time-related functions
 
 
def timer(func):
    """Decorator that measures the execution time of a function."""
    def wrapper(*args, **kwargs):
        # Record the start time before the function execution
        start_time = time.time()
        # Call the original function with all its arguments
        result = func(*args, **kwargs)
        # Record the end time after the function execution
        end_time = time.time()
        # Calculate the elapsed time and print it
        print(f"{func.__name__} took {end_time - start_time:.6f} seconds to execute.")
        # Return the result obtained from the original function
        return result
    # Return the wrapper function to replace the original function
    return wrapper

[MAIN.PY]

from timer import timer  # Import the 'timer' decorator from the 'timer' module
 
 
@timer  # Apply the 'timer' decorator to the 'compute_sum' function
def compute_sum(n):
    """Compute the sum of numbers from 0 to n-1."""
    total = sum(range(n))  # Calculate the sum of numbers from 0 to n-1
    return total  # Return the computed total
 
 
# Usage
result = compute_sum(1000000)  # Call 'compute_sum' with n=1,000,000
 
print(result)  # Print the result to the console

Python – Decorators

Leave a Reply Cancel reply