Python Class Decorators

Summary: in this tutorial, you’ll learn about Python class decorators. After the tutorial, you’ll know how to define classes as decorators.

Introduction to the Python class decorators

So far you have learned how to use functions to define decorators.

For example, the following star function prints out a number of * characters before and after calling the decorated function:

def star(n):
    def decorate(fn):
        def wrapper(*args, **kwargs):
            print(n*'*')
            result = fn(*args, **kwargs)
            print(result)
            print(n*'*')
            return result
        return wrapper
    return decorateCode language: Python (python)

The star is a decorator factory that returns a decorator. It accepts an argument that specifies the number of * characters to display.

The following illustrates how to use the star decorator factory:

@star(5)
def add(a, b):
    return a + b


add(10, 20)Code language: Python (python)

Output:

*****
30
*****

The star() decorator factory takes an argument and returns a callable. The callable takes an argument (fn) which is a function that will be decorated. Also, the callable can access the argument (n) passed to the decorator factory.

A class instance can be a callable when it implements the __call__ method. Therefore, you can make the __call__ method as a decorator.

The following example rewrites the star decorator factory using a class instead:

class Star:
    def __init__(self, n):
        self.n = n

    def __call__(self, fn):
        def wrapper(*args, **kwargs):
            print(self.n*'*')
            result = fn(*args, **kwargs)
            print(result)
            print(self.n*'*')
            return result
        return wrapperCode language: Python (python)

And you can use the Star class as a decorator like this:

@Star(5)
def add(a, b):
    return a + bCode language: Python (python)

The @Star(5) returns an instance of the Star class. That instance is a callable, so you can do something like:

add = Star(5)(add)Code language: Python (python)

So you can use callable classes to decorate functions.

Put it all together:

from functools import wraps


class Star:
    def __init__(self, n):
        self.n = n

    def __call__(self, fn):
        @wraps(fn)
        def wrapper(*args, **kwargs):
            print(self.n*'*')
            result = fn(*args, **kwargs)
            print(result)
            print(self.n*'*')
            return result
        return wrapper


@Star(5)
def add(a, b):
    return a + b


add(10, 20)Code language: Python (python)

Summary

• Use callable classes as decorators by implementing the __call__ method.
• Pass the decorator arguments to the __init__ method.