5 Inbuild Powerful Python Decorators

Python decorators are a powerful tool that can be used in almost any Python project, including data science projects. Decorators are functions that take another function as an input and modify its behavior. In this article, we’ll discuss 5 Python decorators that are commonly used in data science projects.

@staticmethod

The @staticmethod decorator is used to define a static method in a class. Static methods are methods that belong to a class rather than an instance of the class. They can be called without creating an instance of the class, and they don't have access to the instance's state. This decorator is useful for defining utility functions that don't depend on the state of the class.

class MyClass:
    @staticmethod
    def my_static_method(x, y):
        return x + y

result = MyClass.my_static_method(2, 3)

@classmethod

The @classmethod decorator is used to define a class method in a class. Class methods are methods that take the class itself as the first argument, rather than an instance of the class. This decorator is useful for defining methods that need to access class-level data or perform operations on the class itself.

class MyClass:
    ##defining class variable
    class_variable = 2

    @classmethod
    def my_class_method(cls, x):
        cls.class_variable += x+10
        return cls.class_variable

result = MyClass.my_class_method(2)
print(result)

#O/p:14

@property

The @property decorator is used to define a property in a class. Properties are attributes that are computed on the fly rather than stored in memory. This decorator is useful for creating calculated properties that depend on other attributes or methods of the class.

class MyClass:
    def __init__(self, x):
        self._x = x

    @property
    def x_squared(self):
        return self._x ** 2

my_instance = MyClass(3)
result = my_instance.x_squared

@lru_cache

The @lru_cache decorator is used to cache the results of a function to improve performance. It stores the results of the function in memory, so that if the function is called again with the same arguments, it can return the cached result rather than recomputing it. This decorator is useful for functions that are computationally expensive or that are called frequently with the same arguments.

from functools import lru_cache

@lru_cache(maxsize=None)
def my_expensive_function(x):
    # perform some expensive computation
    return result

result = my_expensive_function(3)

The @timed decorator is used to measure the time it takes for a function to run. It can be used to identify bottlenecks in the code or to compare the performance of different implementations. This decorator is useful for functions that are called frequently or that are critical to the performance of the program.

import time

def timed(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"Elapsed time: {end_time - start_time}")
        return result
    return wrapper

@timed
def my_function(x):
    # perform some computation
    return result

result = my_function(3)