在Python中创建Singleton类并计算实例数

Question

我试图理解如何用Python创建一个单例类。下面是我如何尝试的

class Singleton(object):
    _instance = None

    def __new__(class_, *args, **kwargs):
        if not isinstance(class_._instance, class_):
            class_._instance = object.__new__(class_)
        return class_._instance

class MyClass(Singleton):
    num_of_instances = 0
    def __init__(self, real = 5, imaginary = 6):
        self.real = real
        self.imaginary = imaginary
        MyClass.num_of_instances += 1

a = MyClass(10, 20)
print(a.real)
print(a.imaginary)
b = MyClass()

print(MyClass.num_of_instances)  # 2

理想情况下，__new__()使用对象实例调用__init__()，但是在上面的情况下，当我尝试创建第二个对象b时，不会调用__new__，因为MyClass的实例已经存在，那么为什么print语句printing num_of_instancesprint 2？你知道吗

Answer 1

对于每个MyClass(...)调用，都调用__new__。如果没有调用它，它将无法返回singleton实例。你知道吗

当__new__方法返回一个对象，并且该对象是传递给__new__（或子类）的cls参数的实例时，也会调用__init__方法。你知道吗

因此，对于每个MyClass(...)调用，__new__被调用。__new__方法总是返回当前类的实例，因此每次都会调用__init__。在这里，每次都是同一个实例并不重要。你知道吗

从^{} method documentation：

If __new__() returns an instance of cls, then the new instance’s __init__() method will be invoked like __init__(self[, ...]), where self is the new instance and the remaining arguments are the same as were passed to __new__().

如果在方法中添加一些print()调用，则可以看到这种情况：

>>> class Singleton(object):
...     _instance = None
...     def __new__(class_, *args, **kwargs):
...         print(f'Calling {class_!r}(*{args!r}, **{kwargs!r})')
...         if not isinstance(class_._instance, class_):
...             print(f'Creating the singleton instance for {class_!r}')
...             class_._instance = object.__new__(class_)
...         return class_._instance
...
>>> class MyClass(Singleton):
...     num_of_instances = 0
...     def __init__(self, real=5, imaginary=6):
...         print(f'Calling {type(self)!r}.__init__(self, real={real!r}, imaginary={imaginary!r})')
...         self.real = real
...         self.imaginary = imaginary
...         MyClass.num_of_instances += 1
...
>>> a = MyClass(10, 20)
Calling <class '__main__.MyClass'>(*(10, 20), **{})
Creating the singleton instance for <class '__main__.MyClass'>
Calling <class '__main__.MyClass'>.__init__(self, real=10, imaginary=20)
>>> b = MyClass()
Calling <class '__main__.MyClass'>(*(), **{})
Calling <class '__main__.MyClass'>.__init__(self, real=5, imaginary=6)

您无法阻止自动__init__调用，至少在不重写其他内容的情况下是这样。如果您想避免每次调用__init__，您有一些选择：

不必对子类使用__init__方法。您可以发明自己的机制，__new__可以寻找__singleton_init__方法并调用：

class Singleton(object):
    _instance = None

    def __new__(class_, *args, **kwargs):
        if not isinstance(class_._instance, class_):
            class_._instance = object.__new__(class_)
            if hasattr(class_._instance, '__singleton_init__'):
                class_._instance.__singleton_init__(*args, **kwargs)`
        return class_._instance

或者您的__init__方法可以检查是否已经在vars(self)（或self.__dict__）中设置了属性，只是不再设置属性：

class MyClass(Singleton):
    def __init__(self, real=5, imaginary=6):
        if vars(self):
            # we already set attributes on this instance before
            return
        self.real = real
        self.imaginary = imaginary

__new__和__init__逻辑在type.__call__中实现；您可以创建一个metaclass来覆盖该逻辑。虽然您可以只调用__new__（并保持一切不变），但让元类负责处理单例模式是有意义的：

class SingletonMeta(type):
    def __new__(mcls, *args, **kwargs):
        cls = super().__new__(mcls, *args, **kwargs)
        cls._instance = None
        return cls

    def __call__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__call__(*args, **kwargs)
        return cls._instance

然后不要将其用作基类，而是与metaclass=...一起使用。如果更简单，可以创建空基类：

class Singleton(metaclass=SingletonMeta):
    pass

class MyClass(Singleton):
    # ...

上面的代码将在类上调用__new__，在结果实例上可选地后跟__init__，只需一次。SingletonMeta.__call__实现将永远返回singleton实例，而无需进一步调用：

>>> class SingletonMeta(type):
...     def __new__(mcls, *args, **kwargs):
...         cls = super().__new__(mcls, *args, **kwargs)
...         cls._instance = None
...         return cls
...     def __call__(cls, *args, **kwargs):
...         print(f'Calling {cls!r}(*{args!r}, **{kwargs!r})')
...         if cls._instance is None:
...             cls._instance = super().__call__(*args, **kwargs)
...         return cls._instance
...
>>> class Singleton(metaclass=SingletonMeta):
...     pass
...
>>> class MyClass(Singleton):
...     def __init__(self, real=5, imaginary=6):
...         print(f'Calling {type(self)!r}.__init__(self, real={real!r}, imaginary={imaginary!r})')
...         self.real = real
...         self.imaginary = imaginary
...
>>> a = MyClass(10, 20)
Calling <class '__main__.MyClass'>(*(10, 20), **{})
Calling <class '__main__.MyClass'>.__init__(self, real=10, imaginary=20)
>>> MyClass()
Calling <class '__main__.MyClass'>(*(), **{})
<__main__.MyClass object at 0x10bf33a58>
>>> MyClass() is a
Calling <class '__main__.MyClass'>(*(), **{})
True
>>> MyClass().real
Calling <class '__main__.MyClass'>(*(), **{})
10