在Python中创建单例模式

Method: override __new__ after single use

class Singleton():
    def __init__(self):
        Singleton.instance = self
        Singleton.__new__ = lambda _: Singleton.instance

优点

• 极其简单明了
• 真正的类，不需要模块
• 适当使用lambda和Pythonic猴子补丁技术

缺点

• __new__可能会再次被覆盖

除了同意在模块级别全局变量上具有一般的Python建议之外，还有什么想法吗：

def singleton(class_):
    class class_w(class_):
        _instance = None
        def __new__(class2, *args, **kwargs):
            if class_w._instance is None:
                class_w._instance = super(class_w, class2).__new__(class2, *args, **kwargs)
                class_w._instance._sealed = False
            return class_w._instance
        def __init__(self, *args, **kwargs):
            if self._sealed:
                return
            super(class_w, self).__init__(*args, **kwargs)
            self._sealed = True
    class_w.__name__ = class_.__name__
    return class_w

@singleton
class MyClass(object):
    def __init__(self, text):
        print text
    @classmethod
    def name(class_):
        print class_.__name__

x = MyClass(111)
x.name()
y = MyClass(222)
print id(x) == id(y)

输出结果为：

111     # the __init__ is called only on the 1st time
MyClass # the __name__ is preserved
True    # this is actually the same instance

def singleton(cls):
    instance=cls()
    cls.__new__ = cls.__call__= lambda cls: instance
    cls.__init__ = lambda self: None
    return instance

将其用作应该是单例的类上的装饰器，就像这样：

@singleton
class MySingleton:
    #....

这与另一个答案中的 singleton = lambda c: c() 装饰器类似。与其他解决方案一样，唯一的实例具有类名 (MySingleton)。然而，使用此解决方案，您仍然可以通过执行 MySingleton() 从类中“创建”实例（实际上获取唯一实例）。它还通过执行 type(MySingleton)() （也返回相同的实例）来防止您创建额外的实例。

我更喜欢使用装饰器语法而不是从元类中派生。我的看法是：

from typing import Callable, Dict, Set


def singleton(cls_: Callable) -> type:
    """ Implements a simple singleton decorator
    """
    class Singleton(cls_):  # type: ignore
        __instances: Dict[type, object] = {}
        __initialized: Set[type] = set()

        def __new__(cls, *args, **kwargs):
            if Singleton.__instances.get(cls) is None:
                Singleton.__instances[cls] = super().__new__(cls, *args, **kwargs)
            return Singleton.__instances[cls]

        def __init__(self, *args, **kwargs):
            if self.__class__ not in Singleton.__initialized:
                Singleton.__initialized.add(self.__class__)
                super().__init__(*args, **kwargs)

    return Singleton


@singleton
class MyClass(...):
    ...

这种装饰器相对于其他提供的装饰器具有一些优点：

• isinstance(MyClass(), MyClass) 仍然有效（返回闭包中的函数而不是类将使isinstance失败）
• property、classmethod和staticmethod仍能按预期工作
• __init__()构造函数只执行一次
• 您可以再次使用@singleton从您的装饰类继承（无用？）

缺点：

• print(MyClass().__class__.__name__)将返回Singleton而不是MyClass。如果您仍然需要此功能，建议按上面建议的使用元类。

如果您需要基于构造函数参数的不同实例，则需要改进此解决方案（由siddhesh-suhas-sathe提供的解决方案提供了此功能）。

最后，正如其他人建议的那样，在Python中考虑使用模块。模块是对象。您甚至可以将它们传递给变量并将其注入其他类中。

优点

真正的类，自动覆盖继承，使用元类来实现它的正确目的（并提醒了我），

缺点

有吗？

这将成为序列化的问题。如果您尝试从文件（pickle）反序列化对象，则不会使用 __call__，因此它将创建新文件。您可以使用基类继承和 __new__ 来防止出现这种情况。

#decorator, modyfies new_cls
def _singleton(new_cls):
    instance = new_cls()                                              #2
    def new(cls):
        if isinstance(instance, cls):                                 #4
            return instance
        else:
            raise TypeError("I can only return instance of {}, caller wanted {}".format(new_cls, cls))
    new_cls.__new__  = new                                            #3
    new_cls.__init__ = lambda self: None                              #5
    return new_cls


#decorator, creates new class
def singleton(cls):
    new_cls = type('singleton({})'.format(cls.__name__), (cls,), {} ) #1
    return _singleton(new_cls)


#metaclass
def meta_singleton(name, bases, attrs):
    new_cls = type(name, bases, attrs)                                #1
    return _singleton(new_cls)

解释：

1. 创建一个新类，继承给定的 cls（如果有人想要例如 singleton(list)，它不会修改 cls）。

2. 创建实例。在覆盖 __new__ 之前，这很容易。

3. 现在，当我们已经轻松创建了实例，使用刚才定义的方法覆盖 __new__。

4. 当调用者期望的是 instance 时，函数仅返回它，否则会引发 TypeError。
   当有人试图从装饰的类继承时，条件未满足。

5. 如果 __new__() 返回一个 cls 的实例，则将调用新实例的 __init__() 方法，如 __init__(self[, ...])，其中 self 是新实例，其余参数与传递给 __new__() 的相同。

   instance 已经初始化，因此该函数将 __init__ 替换为不执行任何操作的函数。

在网上看它工作

如果您想将instance用作属性，则可以使用metaclass。例如：

class SingletonMeta(type):
    def __init__(cls, *args, **kwargs):
        super().__init__(*args, **kwargs)
        cls._instance = None
        cls._locker = threading.Lock()

    @property
    def instance(self, *args, **kwargs):
        if self._instance is None:
            with self._locker:
                if self._instance is None:
                    self._instance = self(*args, **kwargs)
        return self._instance


class MyClass(metaclass=SingletonMeta):
    def __init__(self):
        # init here
        pass


# get the instance
my_class_instance = MyClass.instance

我记不清我在哪里找到这个解决方案，但我认为从我这个非Python专家的角度来看，它是最“优雅”的：

class SomeSingleton(dict):
    __instance__ = None
    def __new__(cls, *args,**kwargs):
        if SomeSingleton.__instance__ is None:
            SomeSingleton.__instance__ = dict.__new__(cls)
        return SomeSingleton.__instance__

    def __init__(self):
        pass

    def some_func(self,arg):
        pass

为什么我喜欢这个？没有装饰器，没有元类，没有多重继承……如果你决定不再想让它成为一个单例，只需删除__new__方法即可。由于我是Python（和OOP）新手，我希望有人能告诉我为什么这种方法很糟糕？

我要强调几个注意事项：

1. metaclass 方法：

• 你不能从两个元类中继承。查看
• 如果你正在使用工厂模式，那么所有单例类都不会起作用。
• 如果你的父类已经继承了 ABC（即元类），则你不能继承单例元类。

2. 装饰器方法:

• 我正在使用一个函数作为工厂接口，它从 base.__subclasses__() 创建 T 实例。
• 这将跳过子类初始化的单例装饰器。

import sys

class Myclass:
  def __init__(self):
     # do your stuff
      vars(sys.modules[__name__])[type(self).__name__] = lambda: self # singletonify