Introduction

Python class decorators are a powerful feature that allows you to modify the behavior of classes or their methods at the time of their definition. They are similar to function decorators, but instead of modifying functions, they operate on classes.

To create a class decorator, you use a regular Python function that takes a class as its input and returns a new modified class. The decorator function can add, modify, or remove attributes and methods of the class, effectively altering its behavior.

Here's a simple example of a class decorator:

def my_decorator(cls):
    class NewClass(cls):
        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)
            self.new_attribute = 42

        def new_method(self):
            return "This is a new method."

    return NewClass

In this example, the my_decorator function takes a class cls as input and creates a new class NewClass that inherits from the original class. The NewClass adds a new attribute new_attribute and a new method new_method.

To use the decorator, you simply apply it to a class by adding @my_decorator before the class definition:

@my_decorator
class MyClass:
    def __init__(self, value):
        self.value = value

    def original_method(self):
        return "This is the original method."

obj = MyClass(10)
print(obj.value)  # Output: 10
print(obj.new_attribute)  # Output: 42
print(obj.new_method())  # Output: "This is a new method."

The class decorator modified the original MyClass by adding the new_attribute and new_method to it.

Class decorators are commonly used for various purposes, such as implementing mixins, logging, or enforcing certain behaviors on classes. They can also be used for metaclass behavior modification.

When creating more complex class decorators, you might encounter cases where you need to preserve the original class's signature and docstring. In such cases, you can use the functools.wraps decorator from the Python standard library. It ensures that the decorated class retains its original identity:

from functools import wraps

def my_decorator(cls):
    @wraps(cls)
    class NewClass(cls):
        # ... (class modifications here)
        pass

    return NewClass

This ensures that the decorated class will still have the same name, docstring, and other attributes that were set on the original class.

In conclusion, Python class decorators provide a flexible way to modify the behavior of classes at the time of their definition. By creating a function that takes a class as input and returns a new modified class, you can add new methods, attributes, or even modify existing ones. Remember to use functools.wraps if you need to preserve the original class identity. Class decorators offer a powerful tool for extending and enhancing your Python classes, making them a valuable addition to your programming toolkit.

Basics

In Python, you can wrap a static or object class for various purposes, such as:

Profiling: You can wrap a class with a profiler to measure the execution time and performance of its methods. Profilers help identify bottlenecks and optimize code.
Logging: Wrapping a class allows you to add logging functionality, capturing method calls, inputs, and outputs, helping with debugging and understanding the flow of execution.
Caching: By wrapping a class, you can implement caching mechanisms to store the results of method calls and avoid redundant computations.
Access Control: Wrapping a class enables you to implement access control mechanisms, restricting access to specific methods or properties.