This example implements Singleton using metaclasses, by overriding the __call__() metamethod, which is invoked when a new instance is created:
# Metaclasses/Singleton.py class Singleton(type): instance = None def __call__(cls, *args, **kw): if not cls.instance: cls.instance = super(Singleton, cls).__call__(*args, **kw) return cls.instance class ASingleton(object): __metaclass__ = Singleton a = ASingleton() b = ASingleton() assert a is b print(a.__class__.__name__, b.__class__.__name__) class BSingleton(object): __metaclass__ = Singleton c = BSingleton() d = BSingleton() assert c is d print(c.__class__.__name__, d.__class__.__name__) assert c is not a """ Output: ('ASingleton', 'ASingleton') ('BSingleton', 'BSingleton') """
By overriding __call__() in the metaclass, the creation of instances are intercepted. Instance creation is bypassed if one already exists.
Note the dependence upon the behavior of static class fields. When cls.instance is first read, it gets the static value of instance from the metaclass, which is None. However, when the assignment is made, Python creates a local version for the particular class, and the next time cls.instance is read, it sees that local version. Because of this behavior, each class ends up with its own class-specific instance field (thus instance is not somehow being “inherited” from the metaclass).