Using Python Class Decorators Effectively

Python is the only language with idioms. This enhances its readability and, perhaps, its beauty. Decorators follow the Zen of Python, aka the ‘Pythonic’ way.

"There should be one-- and preferably only one --obvious way to do it.

Although that way may not be obvious at first unless you’re Dutch."

Here the Cleaner class is defined which can be used to perform pre-processing and post-processing to the simple_function. In this example we are simply adding Excellency to the string name and after printing the name we thanks for gracing the occasion. This simple example demonstrates that we can use class decorators to easily perform pre-processing and post-processing on the function arguments. These pre-processing tasks could be any of the below not limited to these.

Adding timing information
connecting to databases
closing connections
memoizing storage

Using callable classes as decorators#

While your example uses a class decorator implemented as a wrapper of a function, a powerful pattern is implementing the decorator itself as a class that accepts arguments, stores state, and defines __call__. Here's the template:

from functools import wraps
class MyDecorator:
    def __init__(self, func=None, *, param1=None):
        self.func = func
        self.param1 = param1
    def __call__(self, *args, **kwargs):
        if self.func is None:
            # used as @MyDecorator(param1=...), return a new instance wrapping the function
            func = args[0]
            return type(self)(func, param1=self.param1)
        # actual call wrapper
        @wraps(self.func)
        def wrapper(*a, **kw):
            # pre-processing, can use self.param1
            print("Before call:", self.param1)
            result = self.func(*a, **kw)
            # post-processing
            print("After call:", self.param1)
            return result
        return wrapper(*args, **kwargs)

This pattern gives you rich flexibility: storing internal state, configurable behavior, and clean callable logic.

You should explain that class decorators implemented this way can elegantly support both parameterized and non-parameterized invocation, maintaining function metadata via wraps.

Some Built-in Class Decorators#

Here are some of the built-in class decorators.

cache/ memoize #

Please note that its only available in Python >= 3.9. This allows caching previous values and reusing them instead of recalculating.

def decorate_all_methods(decorator_fn):
    def class_decorator(cls):
        for name, attr in cls.__dict__.items():
            if callable(attr) and not name.startswith("__"):
                setattr(cls, name, decorator_fn(attr))
        return cls
    return class_decorator
# Example decorator function
def log_calls(fn):
    @wraps(fn)
    def wrapped(*args, **kwargs):
        print(f"Calling {fn.__name__} with", args, kwargs)
        return fn(*args, **kwargs)
    return wrapped
@decorate_all_methods(log_calls)
class MyClass:
    def method1(self, x):
        return x * 2
    def method2(self, y):
        return y + 10

Caveats to discuss:

Special methods and dunder methods often should be skipped (you shouldn’t wrap __init__, __repr__ lightly).
This approach doesn’t catch dynamically added methods.
It may conflict with decorators already applied on some methods.
You might also combine this with metaclasses or use the descriptor protocol for full control.
In complex cases, a metaclass (or mix of decorator + metaclass) may be better.

Introducing this section helps bridge the gap between simple examples and real operational use.

Key limitations, pitfalls, and inheritance behavior#

Decorators are powerful, but class decorators come with trade-offs you should know:

Applied after class creation: Class decorators wrap the already built class object. They do not intervene in class creation itself (unlike metaclasses). PEP 3129 establishes this semantics.
Non-inheritance: If you decorate a base class, subclasses won’t automatically get that decoration. That is, class decorators do not propagate through class inheritance, unlike metaclasses.
Effect on introspection: Improper wrapping can obscure __name__, __doc__, __qualname__. Always use functools.wraps when wrapping methods inside the decorator.
Interaction with metaclasses: If a class already has a metaclass, combining with decorators must be done carefully. Decorators should respect the metaclass contract.
Order sensitivity: If multiple class decorators are stacked like @decA @decB class C, the application order is bottom up, same as function decorators.
Performance overhead: Wrapping many methods or heavy logic in __call__ may add runtime overhead and increase complexity.
State and concurrency: If your decorator stores mutable per-class state, be careful with thread safety or shared state across subclassing.

A balanced discussion helps developers avoid subtle bugs when applying class decorators in real systems.

Conclusions#

Decorators are very convenient and elegant tools, However they are also very prone to errors. So they should be used with a lot of care.

Interactively Learn Advanced Python Concepts

Python 201 - Interactively Learn Advanced Concepts in Python 3

This course will help you take the next level in your programming journey. It will demonstrate the ways you can use Python in your day-to-day work. We will cover intermediate and some advanced-level material in this course. Python 201 is split into four parts; Part one covers intermediate modules. Part two covers topics such as Unicode, generators, and iterators. Part three covers web-related tasks with Python. Part four covers testing code.

11hrs

Intermediate

250 Playgrounds

22 Quizzes

Using Python Class Decorators Effectively

Decorators#

Python Class Decorators #

Using callable classes as decorators#

Some Built-in Class Decorators#

cache/ memoize #

property#

cached_property#

Automatically decorating all methods of a class#

Key limitations, pitfalls, and inheritance behavior#

Conclusions#