Top 10 Python Decorators to Optimize Your Functions

Python is easy, especially because of its structure and operability! However, sometimes it can get a bit challenging to work with its functions, i.e. by modifying or extending them without altering their actual behaviour. This is where Python Decorators come into the picture! Today, we will tell you 10 Python Decorators to enhance and optimize your snippet functions.

But first, a primer of what they are.

What are Python Decorators?

A Python decorator is a convenient way to modify the behaviour of a function. They are often used to add functionality to an existing code in a modular and reusable way, without altering the function or method definition.

Decorators are applied with the @decorator_name syntax.

Let’s take a look at an example:

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

Output:
Something is happening before the function is called.
Hello!
Something is happening after the function is called.

In this example, my_decorator modifies the say_hello function to print messages before and after calling it.

10 Useful Python Decorators

Here are 10 Python Decorators that you can try out with your code functions. Understanding and using these common decorators can help you write more robust and maintainable code. So let’s take a look at them right away and understand them in detail:

1. @dataclass

The @dataclass decorator in Python simplifies the creation of data classes. Data classes are classes that primarily store data and provide a concise syntax to define them. Introduced in Python 3.7 as part of the dataclasses module, the @dataclass decorator automates the creation of methods like __init__, __repr__, __eq__, and others.

It provides a decorator and functions for automatically adding special methods to user-defined classes.

How the @dataclass decorator works:

• Automatic __init__ Method Generation: The @dataclass decorator automatically generates an __init__ method based on the class’s type annotations.
• Readable __repr__ Method: It provides a default __repr__ implementation that includes the class name and all its fields, making instances easier to print and debug.
• Comparison Methods: By default, @dataclass generates __eq__ and other comparison methods, making it easier to compare instances.
• Mutability and Immutability: Data classes can be mutable or immutable. By default, they are mutable, but you can make them immutable by setting frozen=True.
• Default Values: You can assign default values to fields or use field() to provide default factory functions for more complex defaults.
• Field Ordering: The order of fields is preserved in the generated methods.

Examples:

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

p = Point(1, 2)
print(p)  # Output: Point(x=1, y=2)

Here’s an advanced example demonstrating default values, default factories, and custom methods:

from dataclasses import dataclass, field

@dataclass
class Book:
    title: str
    author: str
    pages: int = 0
    genres: list = field(default_factory=list)

    def add_genre(self, genre: str):
        self.genres.append(genre)

book = Book("The Great Gatsby", "F. Scott Fitzgerald")
book.add_genre("Classic")
print(book)  # Output: Book(title='The Great Gatsby', author='F. Scott Fitzgerald', pages=0, genres=['Classic'])

The @dataclass decorator simplifies the creation and management of classes intended to store data by automating common tasks. This leads to cleaner, more readable code and reduces boilerplate, especially in scenarios where classes are used mainly for data storage and representation.

2. @singleton

The @singleton decorator in Python is used to restrict a class to a single instance. This pattern ensures that only one object of the class exists throughout the application, providing a global point of access to that instance.

It is particularly useful in cases where having multiple instances would lead to inconsistent state or behaviour, such as in logging, database connections, or configuration management.

A @singleton decorator typically works by:

• Storing the Single Instance: Keeping track of the instance in a private dictionary or variable.
• Returning the Stored Instance: When the class is instantiated again, return the stored instance instead of creating a new one.

Here’s a simple implementation of the @singleton decorator:

def singleton(cls):
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

This decorator checks if an instance of the class already exists. If not, it creates one; otherwise, it returns the existing instance.

In a more complex scenario, you might want to handle thread safety or ensure that the singleton class can be inherited correctly.

import threading

def singleton(cls):
    instances = {}
    lock = threading.Lock()

    def get_instance(*args, **kwargs):
        with lock:
            if cls not in instances:
                instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class ThreadSafeSingleton:
    def __init__(self, value):
        self.value = value

obj1 = ThreadSafeSingleton(10)
obj2 = ThreadSafeSingleton(20)

print(obj1 is obj2)  # Output: True
print(obj1.value)    # Output: 10
print(obj2.value)    # Output: 10

The @singleton decorator is useful for managing shared resources, configurations, or connections in an application. By encapsulating the instance creation and access logic in a decorator, you simplify the usage of the singleton pattern and ensure a consistent approach across different classes and modules.

3. @timeout

The @timeout decorator in Python is used to limit the execution time of a function. If the function does not complete within a specified time limit, it raises a TimeoutError. This is particularly useful when you want to prevent long-running operations from blocking your program.

The @timeout decorator typically works by:

1. Setting an Alarm: Using the signal module to set an alarm that triggers after a specified duration.
2. Handling the Alarm: Defining a signal handler that raises a TimeoutError when the alarm goes off.
3. Wrapping the Function: Wrapping the target function so that the alarm is set when the function starts and cancelled when it finishes or if the function raises a TimeoutError.

Here’s a simple implementation of the @timeout decorator:

import signal
import time

class TimeoutError(Exception):
    pass

def timeout(seconds):
    def decorator(func):
        def handler(signum, frame):
            raise TimeoutError(f"Function {func.__name__} timed out after {seconds} seconds.")

        def wrapper(*args, **kwargs):
            signal.signal(signal.SIGALRM, handler)
            signal.alarm(seconds)
            try:
                result = func(*args, **kwargs)
            finally:
                signal.alarm(0)
            return result
        return wrapper
    return decorator

# Example usage
@timeout(5)
def long_running_function():
    time.sleep(10)  # Simulating a long-running process
    return "Completed"

try:
    print(long_running_function())
except TimeoutError as e:
    print(e)

Let’s see what’s happening in the above code:

Signal Setup (signal.signal and signal.alarm):

• signal.signal(signal.SIGALRM, handler) sets up a handler function for the SIGALRM signal. This handler will raise a TimeoutError.
• signal.alarm(seconds) schedules the alarm to go off after the specified number of seconds.

Handler Function (handler):

• This function is called when the alarm signal (SIGALRM) is received. It raises a TimeoutError with a message indicating the function’s timeout.

Wrapper Function (wrapper):

• Sets the alarm: signal.alarm(seconds) starts the countdown when the function begins execution.
• Tries to execute the function: The target function is executed within a try block.
• Cancels the alarm: signal.alarm(0) cancels the alarm when the function completes or if an exception is raised, to prevent it from affecting other parts of the program.

Decorator Function (decorator):

• It returns the wrapper function, which is the actual decorated function that handles timeout behaviour.

4. @retry

The @retry decorator in Python is designed to automatically retry a function if it raises a specific exception or fails. This is especially useful in situations where transient errors occur, such as network requests, file operations, or other interactions with external resources.

The @retry decorator generally works by:

1. Catching Exceptions: Catching specified exceptions when they occur during function execution.
2. Retrying the Function: Retrying the function a set number of times if an exception is caught.
3. Applying a Delay: Optionally applying a delay between retries to allow transient issues to be resolved.

Here’s a simple implementation of the @retry decorator:

import time
from functools import wraps

def retry(max_retries=3, delay=1, exceptions=(Exception,)):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except exceptions as e:
                    print(f"Attempt {attempt + 1} failed: {e}")
                    if attempt < max_retries - 1:
                        time.sleep(delay)
            raise Exception(f"Function {func.__name__} failed after {max_retries} retries.")
        return wrapper
    return decorator

# Example usage
@retry(max_retries=3, delay=2, exceptions=(ValueError,))
def unstable_function():
    import random
    if random.choice([True, False]):
        raise ValueError("Random failure!")
    return "Success!"

try:
    print(unstable_function())
except Exception as e:
    print(e)

Detailed Explanation of the code:

• Decorator Parameters:
  • max_retries: The maximum number of retries allowed.
  • delay: The time delay (in seconds) between retries.
  • exceptions: A tuple of exception types to catch and retry.
• Inner Decorator Function (decorator):
  • This function takes the target function (func) as its parameter and returns the wrapper function.
• Wrapper Function (wrapper):
  • Loop Over Retries: Loops up to max_retries, trying to execute the function.
  • Catch Exceptions: Catches specified exceptions and retries if an exception is caught.
  • Delay Between Retries: Sleeps for delay seconds before the next retry.
  • Raise Exception: Raises a final exception if all retries fail.
• Function Metadata (wraps):
  • The @wraps(func) decorator preserves the metadata of the original function (func), such as its name and docstring.

Logging and Reporting:

For production scenarios, integrating logging or other reporting mechanisms can help monitor retry behaviour.

import logging
import time

logging.basicConfig(level=logging.INFO)

def retry(max_retries=3, delay=1, exceptions=(Exception,)):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except exceptions as e:
                    logging.warning(f"Attempt {attempt + 1} failed: {e}")
                    if attempt < max_retries - 1:
                        time.sleep(delay)
            logging.error(f"Function {func.__name__} failed after {max_retries} retries.")
            raise Exception(f"Function {func.__name__} failed after {max_retries} retries.")
        return wrapper
    return decorator

@retry(max_retries=3, delay=2, exceptions=(ValueError,))
def unstable_function():
    import random
    if random.choice([True, False]):
        raise ValueError("Random failure!")
    return "Success!"

try:
    print(unstable_function())
except Exception as e:
    print(e)

The @retry decorator provides a simple yet powerful mechanism for handling transient failures by retrying the function execution. This can significantly improve the robustness and resilience of applications that interact with unreliable external systems.

5. @staticmethod

The @staticmethod decorator in Python defines a method that belongs to the class itself rather than any instance of the class. Static methods can be called on the class without creating an instance and do not require access to instance (self) or class (cls) variables. They are useful for utility or helper functions that operate independently of instance or class state.

How the @staticmethod Decorator Works:

1. No Access to self or cls: Static methods do not receive the self or cls parameters as they do not need to modify the object or class state.
2. Callable on Class or Instance: Static methods can be called on both the class itself and its instances.
3. Utility Functions: They are typically used for utility or helper functions that logically belong to the class but do not need to interact with instance-specific data.

Here’s a simple example of using the @staticmethod decorator:

class MathOperations:
    @staticmethod
    def add(x, y):
        return x + y

# Using static method
result = MathOperations.add(5, 7)
print(result)  # Output: 12

# It can also be called on an instance
math_ops = MathOperations()
result = math_ops.add(5, 7)
print(result)  # Output: 12

Here’s some Detailed Explanation of the code:

Static Method Declaration:

• Syntax: @staticmethod is placed above the method definition.
• Function Definition: The static method is defined like a regular function within the class but with the @staticmethod decorator.

Calling Static Methods:

• On the Class: MathOperations.add(5, 7)
• On an Instance: math_ops.add(5, 7)

No self or cls:

• Static methods do not take self or cls as their first parameter since they do not access or modify the class or instance attributes.

Static methods can be more complex, but they still don’t interact with instance or class-specific data.

class TemperatureConverter:
    @staticmethod
    def celsius_to_fahrenheit(celsius):
        return (celsius * 9/5) + 32

    @staticmethod
    def fahrenheit_to_celsius(fahrenheit):
        return (fahrenheit - 32) * 5/9

# Usage
print(TemperatureConverter.celsius_to_fahrenheit(0))    # Output: 32.0
print(TemperatureConverter.fahrenheit_to_celsius(32))   # Output: 0.0

The @staticmethod decorator in Python is useful for defining methods that belong to a class but do not need access to the class or its instances. They provide a way to logically group functions within a class, helping to organize code better. Static methods are ideal for utility functions and scenarios where instance or class data is not needed.

6. @property

The @property decorator in Python is used to define methods in a class that behave like attributes, allowing controlled access to instance variables. This decorator transforms a method into a “getter” for a property, allowing you to access it like an attribute while still providing the option to define additional logic, validation, or calculations.

How the @property Decorator Works:

1. Getter: The @property decorator turns a method into a getter, allowing it to be accessed as an attribute.
2. Setter (Optional): The @property method can be extended with a setter method to allow setting the value of the property with validation or other logic.
3. Deleter (Optional): It can also be extended with a deleter method to control the deletion of the property.

Here’s a basic example using the @property decorator:

class Circle:
    def __init__(self, radius):
        self._radius = radius
    
    @property
    def radius(self):
        return self._radius
    
    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("Radius cannot be negative")
        self._radius = value

    @property
    def area(self):
        return 3.14159 * self._radius ** 2

# Usage
c = Circle(5)
print(c.radius)  # Output: 5
c.radius = 10
print(c.area)    # Output: 314.159

Here’s what’s happening in the code above:

Private Variable (self._radius):

• Initialization: The constructor (__init__) initializes a private instance variable _radius.

Getter (@property):

• Method Definition: The radius method is decorated with @property, making it accessible as an attribute.
• Usage: c.radius calls the getter method, which returns the value of _radius.

Setter (@radius.setter):

• Validation Logic: The setter method is defined using @radius.setter, allowing assignment to radius (c.radius = 10).
• Assignment with Validation: If the value is negative, it raises a ValueError.

Read-Only Property (area):

• No Setter: The area property is defined without a setter, making it read-only.
• Dynamic Calculation: The area is calculated dynamically based on the radius.

Properties can be used to implement more complex logic, including interdependent properties and read-only attributes.

Read-Only Property:

If you need a property to be read-only, simply omit the setter:

class Rectangle:
    def __init__(self, width, height):
        self._width = width
        self._height = height
    
    @property
    def width(self):
        return self._width

    @property
    def height(self):
        return self._height

    @property
    def area(self):
        return self._width * self._height

# Usage
rect = Rectangle(4, 5)
print(rect.area)  # Output: 20
# rect.area = 30  # Raises AttributeError

Dependent Properties:

Properties can depend on other properties, allowing complex interdependent attributes.

class Square:
    def __init__(self, side):
        self._side = side
    
    @property
    def side(self):
        return self._side
    
    @side.setter
    def side(self, value):
        if value < 0:
            raise ValueError("Side length cannot be negative")
        self._side = value
    
    @property
    def perimeter(self):
        return 4 * self._side

    @property
    def area(self):
        return self._side ** 2

# Usage
s = Square(3)
print(s.perimeter)  # Output: 12
print(s.area)       # Output: 9
s.side = 4
print(s.area)       # Output: 16

The @property decorator in Python is a powerful tool for creating attributes with controlled access and additional logic. It helps in creating clean, readable, and maintainable code by encapsulating internal state and exposing properties that can include validation, computation, or lazy loading.

7. @functools.wraps

The @functools.wraps decorator in Python is used to help write decorators that correctly preserve the metadata of the function they are wrapping. This is important for debugging, documentation, and maintaining function signatures.

When you create a decorator, the decorated function typically loses its original name, docstring, and other attributes, @functools.wraps helps retain these attributes by copying them from the original function to the wrapper function.

How the @functools.wraps Decorator Works:

@functools.wraps is a decorator for the wrapper function within your custom decorator. It uses functools.update_wrapper internally to update the wrapper function to look more like the wrapped function by copying attributes such as:

• __name__
• __doc__
• __module__
• __annotations__
• __dict__ (updates, not replaces)

Here’s a simple example to demonstrate the problem and solution with @functools.wraps.

Without @functools.wraps

def my_decorator(func):
    def wrapper(*args, **kwargs):
        """Wrapper function docstring"""
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def example_function():
    """Example function docstring"""
    print("Example function")

print(example_function.__name__)  # Output: wrapper
print(example_function.__doc__)   # Output: Wrapper function docstring

In this case, example_function loses its original name and docstring.

With @functools.wraps

import functools

def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def example_function():
    """Example function docstring"""
    print("Example function")

print(example_function.__name__)  # Output: example_function
print(example_function.__doc__)   # Output: Example function docstring

Using @functools.wraps, the example_function retains its original name and docstring.

Here’s a more detailed example to illustrate how @functools.wraps is typically used in decorators:

import functools

def log_calls(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Function {func.__name__} called with args {args} and kwargs {kwargs}")
        result = func(*args, **kwargs)
        print(f"Function {func.__name__} returned {result}")
        return result
    return wrapper

@log_calls
def add(a, b):
    """Adds two numbers."""
    return a + b

# Usage
print(add(3, 4))  # Output: 7
print(add.__name__)  # Output: add
print(add.__doc__)   # Output: Adds two numbers.

The @functools.wraps decorator is essential for writing decorators that respect the original function’s metadata. It ensures that the decorated function retains its original name, docstring, annotations, and other attributes, which is critical for debugging, introspection, and documentation.

8. @lru_cache

The @lru_cache decorator in Python, provided by the functools module, is used to cache the results of function calls, improving performance by avoiding redundant calculations. “LRU” stands for Least Recently Used, meaning the cache discards the least recently used items first when it reaches its size limit.

How the @lru_cache Decorator Works:

• Memoization: It stores the results of expensive or frequently called functions to speed up future calls with the same arguments.
• LRU Cache: It uses the least recently used caching strategy to manage the cache size.
• Configurable Size: You can set the maximum size of the cache, after which the least recently used entries are evicted.

Here’s a simple example to demonstrate @lru_cache:

import functools

@functools.lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# Usage
print(fibonacci(10))  # Output: 55
print(fibonacci.cache_info())  # CacheInfo(hits=8, misses=11, maxsize=128, currsize=11)

In this example, fibonacci uses @lru_cache to avoid recalculating results for previously computed values, significantly improving performance for recursive functions.

Detailed Explanation of the Code:

Decorator Syntax:

• Syntax: @functools.lru_cache(maxsize=None, typed=False)
• Parameters:
  • maxsize: Defines the maximum size of the cache. If set to None, the cache can grow without bound.
  • typed: If set to True, it caches different types of arguments separately (e.g., 1 and 1.0 are different).

Caching Logic:

• The first time a function is called with a specific set of arguments, the result is computed and stored in the cache.
• Subsequent calls with the same arguments return the cached result, avoiding redundant computation.

Cache Management:

• Eviction Policy: The least recently used entries are evicted when the cache exceeds maxsize.
• Cache Information: You can access cache statistics using cache_info() and clear the cache with cache_clear().

Let’s look at a more complex example using @lru_cache:

import functools

@functools.lru_cache(maxsize=5)
def factorial(n):
    """Calculate the factorial of n (n!)."""
    if n < 2:
        return 1
    return n * factorial(n - 1)

# Usage
print(factorial(5))  # Output: 120
print(factorial(6))  # Output: 720
print(factorial.cache_info())  # CacheInfo(hits=4, misses=6, maxsize=5, currsize=5)
factorial.cache_clear()
print(factorial.cache_info())  # CacheInfo(hits=0, misses=0, maxsize=5, currsize=0)

Cache Information:

• hits: Number of times the cached result was used.
• misses: Number of times a result was computed because it was not in the cache.
• maxsize: The maximum number of items the cache can hold.
• currsize: The current number of items in the cache.

The @lru_cache decorator is a powerful and easy-to-use tool for optimizing performance by caching the results of function calls. It is especially useful for functions with expensive calculations or recursion. By managing the cache size and using an LRU eviction policy, it ensures efficient memory usage while speeding up repeated function calls with the same arguments.

9. @contextmanager

The @contextmanager decorator in Python, provided by the contextlib module, simplifies the creation of context managers. Context managers are used to set up and clean up resources around a block of code, typically using the with statement.

The @contextmanager decorator allows you to create context managers using generator functions instead of writing a full class that implements the __enter__ and __exit__ methods.

How the @contextmanager Decorator Works:

The @contextmanager decorator provides a convenient way to write context managers that perform setup and cleanup actions around a block of code. It is often used for managing resources such as files, network connections, locks, and more. It can be useful for a variety of use cases:

Resource Management:

• Manage the acquisition and release of resources like files, network connections, locks, etc.

Code Timing:

• Measure the execution time of code blocks.

Temporary Changes:

• Make temporary changes to the environment or configuration that need to be reverted after use.

Here’s a simple example of using @contextmanager to create a context manager for opening and closing a file:

from contextlib import contextmanager

@contextmanager
def open_file(file_name, mode):
    file = open(file_name, mode)
    try:
        yield file
    finally:
        file.close()

# Usage
with open_file('sample.txt', 'w') as f:
    f.write('Hello, world!')

# The file is automatically closed after the block.

Detailed Explanation of the Code:

1. Decorator Syntax:
   • Syntax: @contextmanager
   • Function Definition: Define a generator function that performs setup, yields control, and then performs cleanup.
2. Setup and Yield:
   • Setup: Perform any setup or resource acquisition before the yield.
   • Yield: Yield the resource that needs to be managed to the with block.
   • Cleanup: After the yield, perform cleanup or resource release, usually within a finally block to ensure it always executes.
3. Usage with with:
   • The context manager is used with the with statement, which ensures that the cleanup code runs even if an exception occurs within the block.

Let’s consider a more advanced example, such as timing the execution of a block of code:

from contextlib import contextmanager
import time

@contextmanager
def timer():
    start_time = time.time()
    try:
        yield
    finally:
        end_time = time.time()
        print(f"Elapsed time: {end_time - start_time} seconds")

# Usage
with timer():
    time.sleep(1)  # Simulating a long-running operation

In this example:

• Setup: Records the start time.
• Yield: Control is given to the with block.
• Cleanup: Calculates and prints the elapsed time.

The @contextmanager decorator in Python is a powerful tool for creating context managers using a generator-based approach. It simplifies the management of resources by combining setup, yield, and cleanup logic in a single function. This decorator enhances readability and reduces boilerplate code, making it easier to implement context management for various use cases.

10. @classmethod

The @classmethod decorator in Python is used to define a method that is bound to the class and not the instance of the class. This means that the method can be called on the class itself, rather than on instances of the class.

How the @classmethod decorator works:

Class methods are used when you need to access or modify the class state that applies across all instances of the class, rather than the state of a particular instance. They are often used for factory methods, which are methods that return an instance of the class.

• Access Class Variables: Class methods can access and modify class-level variables.
• Factory Methods: Class methods are commonly used as factory methods to create new instances of the class.
• Call on Class: Class methods are called on the class itself, not on an instance. For example, MyClass.method() rather than my_instance.method().

Here’s a basic implementation of the @classmethod decorator:

class MyClass:
    class_variable = 0
    
    def __init__(self, value):
        self.instance_variable = value
    
    @classmethod
    def increment_class_variable(cls):
        cls.class_variable += 1
    
    @classmethod
    def create_with_default_value(cls):
        return cls(10)

# Using the class method to increment class_variable
MyClass.increment_class_variable()
print(MyClass.class_variable)  # Output: 1

# Creating an instance using a class method
obj = MyClass.create_with_default_value()
print(obj.instance_variable)  # Output: 10

Here’s an advanced example demonstrating the use of @classmethod in a more complex scenario. We’ll create a Vehicle class with subclasses for different types of vehicles, and use class methods to manage a fleet of vehicles.

class Vehicle:
    fleet = []
    
    def __init__(self, make, model):
        self.make = make
        self.model = model
        self.add_to_fleet()
    
    def add_to_fleet(self):
        self.__class__.fleet.append(self)
    
    @classmethod
    def fleet_count(cls):
        return len(cls.fleet)
    
    @classmethod
    def create_vehicle(cls, make, model):
        return cls(make, model)
    
    @classmethod
    def display_fleet(cls):
        for vehicle in cls.fleet:
            print(f"{vehicle.__class__.__name__}: {vehicle.make} {vehicle.model}")

class Car(Vehicle):
    def __init__(self, make, model, doors):
        super().__init__(make, model)
        self.doors = doors

class Truck(Vehicle):
    def __init__(self, make, model, payload_capacity):
        super().__init__(make, model)
        self.payload_capacity = payload_capacity

# Create vehicles using class methods
car1 = Car.create_vehicle("Toyota", "Camry")
car2 = Car.create_vehicle("Honda", "Civic")
truck1 = Truck.create_vehicle("Ford", "F-150")

# Add additional attributes specific to subclasses
car1.doors = 4
car2.doors = 2
truck1.payload_capacity = 1000

# Display fleet information
Vehicle.display_fleet()

# Output fleet count
print(f"Total vehicles in fleet: {Vehicle.fleet_count()}")

Detailed Explanation of the Code:

Base Class Vehicle:

• Maintains a class variable fleet to store all vehicle instances.
• Initializes vehicles with make and model.
• Adds each new vehicle to the fleet list using add_to_fleet.
• Provides class methods to get the fleet count (fleet_count), create a vehicle (create_vehicle), and display the fleet (display_fleet).

Subclasses Car and Truck:

• Inherit from Vehicle.
• Add additional attributes specific to cars (doors) and trucks (payload_capacity).

Using Class Methods:

• Vehicles are created using the create_vehicle class method, which ensures they are added to the fleet.
• The display_fleet class method is used to print details of all vehicles in the fleet.
• The fleet_count class method provides the total number of vehicles in the fleet.

In summary, @classmethod is a powerful tool in Python for defining methods that operate on the class itself rather than on instances, making it useful for tasks that involve class-level data and behaviours.

Conclusion

These 10 Decorators can significantly enhance the functionality of your Python code by promoting code reuse and separation of concerns. Go include them in your code today and experience unmatched optimal experience and improved code function modification.