Master Python Singleton Patterns: Decorators, Metaclasses, and __new__

Using a Class Decorator

A decorator can enforce singleton behavior without the class itself being aware of the restriction. The decorator stores created instances in a dictionary and returns the existing instance on subsequent calls.

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

Applying this decorator to a class guarantees that only one instance will ever be created.

Metaclass (__metaclass__) and Callable Object (__call__)

In Python, classes are themselves objects created by a metaclass. By defining a custom metaclass that overrides __call__, we can control instance creation and ensure a single shared instance.

class Singleton(type):
    def __init__(cls, name, bases, attrs):
        super(Singleton, cls).__init__(name, bases, attrs)
        cls._instance = None
    def __call__(cls, *args, **kwargs):
        if cls._instance is None:
            # Use super to actually create the instance and avoid recursion
            cls._instance = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instance

class Foo(object):
    __metaclass__ = Singleton

Now every call to Foo() returns the same object, and identity checks confirm the singleton property.

Using __new__

The __new__ method is responsible for creating a new instance before __init__ runs. By overriding it, we can intercept the creation process and store a single instance.

class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance

class Foo(Singleton):
    pass

Instances of Foo share the same identity, demonstrating a clean singleton implementation via __new__.