Decorators in Python are a powerful way to modify or extend the behavior of functions or classes without permanently modifying them. They are often used for logging, access control, memoization, etc. In this guide, we'll explore how to use decorators in classes, including both class- and function-based decorators, with and without arguments.

1. Function-Based Decorators on Classes

1.1 Function-Based Decorator Without Arguments

A function-based decorator without arguments is a simple function that takes a class as an argument and returns a modified version of that class.

Example 1: Logging Class Creation

# Define a function-based decorator

def log_class_creation(cls):

# Modify the class by adding a logging statement

original_init = cls.__init__

def new_init(self, *args, **kwargs):

print(f"Creating an instance of {cls.__name__}")

original_init(self, *args, **kwargs)

# Replace the original __init__ with the new one

cls.__init__ = new_init

return cls

# Apply the decorator to a class

@log_class_creation

class MyClass:

def __init__(self, value):

self.value = value

# Create an instance of the decorated class

obj = MyClass(10) # Output: Creating an instance of MyClass

print(obj.value) # Output: 10

Explanation:

The log_class_creation decorator modifies the __init__ method of the class to log a message whenever an instance is created.

Example 2: Automatically Adding a String Representation

def add_str(cls):

"""Decorator that adds a default __str__ method to the class."""

def __str__(self):

return f"{cls.__name__} instance with attributes {self.__dict__}"

cls.__str__ = __str__

return cls

@add_str

class Product:

def __init__(self, name, price):

self.name = name

self.price = price

p = Product("Laptop", 1200)

print(p) # Output: Product instance with attributes {'name': 'Laptop', 'price': 1200}

1.2 Function-Based Decorator With Arguments

A function-based decorator with arguments requires an additional layer of nesting to accept the arguments.

Example: Adding a Prefix to Class Attributes

# Define a function-based decorator with arguments

def add_prefix(prefix):

# This is the actual decorator function

def decorator(cls):

# Modify the class by adding a prefix to all attribute names

for name in list(cls.__dict__.keys()):

attr = cls.__dict__[name]

if not name.startswith('__'):

setattr(cls, f"{prefix}_{name}", attr)

delattr(cls, name)

return cls

return decorator

# Apply the decorator with arguments to a class

@add_prefix('prefixed')

class MyClass:

def __init__(self, value):

self.value = value

def display(self):

print(f"Value: {self.value}")

# Create an instance of the decorated class

obj = MyClass(10)

obj.prefixed_display() # Output: Value: 10

print(dir(obj))

Explanation:

The add_prefix decorator takes a prefix argument and returns the decorator function.
The decorator function modifies the class by adding a prefix to all attribute names.

2. Class-Based Decorators on Classes

2.1 Class-Based Decorator Without Arguments

A class-based decorator without arguments is a class that implements the __call__ method to modify the target class.

Example: Enforcing Read-Only Attributes

class Singleton:

"""Class decorator that enforces a singleton pattern."""

def __init__(self, cls):

self.cls = cls

self.__instance = None

def __call__(self, *args, **kwargs):

if not self.__instance:

self.__instance = self.cls(*args, **kwargs)

return self.__instance

@Singleton

class Database:

"""A singleton Database class."""

def __init__(self, connection_string):

self.connection_string = connection_string

# Both instances will be the same

db1 = Database("db://localhost")

db2 = Database("db://remote")

print(db1 is db2) # Output: True

print(type(db1)) # Output: <class '__main__.Database'>

print(type(Database)) # Output: <class '__main__.Singleton'>

print(db1.connection_string) # Output: db://localhost

print(db2.connection_string) # Output: db://localhost

Explanation:

The Singleton class is defined as a decorator that enforces the singleton pattern. It maintains a property called __instances to keep track of an instance of the class it decorates. The __init__ method of the Singleton the class takes a class (cls) as an argument and stores it. The __call__ method is overridden to control the instantiation of the class.
When used as a decorator, the instance of the class will be created, the decorated class being the value of cls. Thus, the value of the decorated class will be an instance of the Singleton i.e., Database is an instance of Singleton. When the decorated class (Database) is called the __call__ method that checks if an instance of the class already exists, i.e., if the __instances property is set. It creates a new instance and stores it if it does not exist. If it does exist, it returns the existing instance. Thus, the same instance is returned even when different connection strings are passed.

2.2 Class-Based Decorator With Arguments

A class-based decorator with arguments requires an additional layer of nesting to accept the arguments.

Example: Adding Suffix to Class Attributes

# Define a class-based decorator with arguments

class AddSuffix:

def __init__(self, suffix):

self.suffix = suffix

def __call__(self, cls):

# Modify the class by adding a suffix to all attribute names

for name in list(cls.__dict__.keys()):

attr = getattr(cls, name)

if not name.startswith('__'):

setattr(cls, f"{name}_{self.suffix}", attr)

delattr(cls, name)

return cls

# Apply the class-based decorator with arguments to a class

@AddSuffix('suffixed')

class MyClass:

def __init__(self, value):

self.value = value

def display(self):

print(f"Value: {self.value}")

# Create an instance of the decorated class

obj = MyClass(10)

obj.display_suffixed() # Output: Value: 10

Explanation:

The AddSuffix class takes a suffix argument and modifies the target class by adding a suffix to all attribute names.
The __call__ method is used to apply the modifications to the class.

NOTE: It is possible to combine both class-based and function-based decorator on a single class instance

@Singleton

@add_str

class Config:

"""A singleton config class with string representation."""

def __init__(self, settings):

self.settings = settings

config1 = Config({"debug": True})

config2 = Config({"debug": False})

print(config1 is config2) # Output: True

print(config1) # Output: Config instance with attributes {'settings': {'debug': True}}

Explanation

The Singleton decorator ensures one instance exists.
The add_str decorator enhances debugging.