在Python中创建单例

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

@singleton
class MyClass(BaseClass):
    pass

 x = MyClass();
y = MyClass();
t = type(n)();
 

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

class MyClass(Singleton, BaseClass):
    pass

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

#Python2
class MyClass(BaseClass):
    __metaclass__ = Singleton

#Python3
class MyClass(BaseClass, metaclass=Singleton):
    pass

def singleton(class_):
    class class_w(class_):
        _instance = None
        def __new__(class_, *args, **kwargs):
            if class_w._instance is None:
                class_w._instance = super(class_w,
                                    class_).__new__(class_,
                                                    *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(BaseClass):
    pass

#1 楼

使用元类
我建议使用方法2，但最好使用元类而不是基类。这是一个示例实现：

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]
        
class Logger(object):
    __metaclass__ = Singleton

或在Python3中

class Logger(metaclass=Singleton):
    pass

如果要在每次调用该类时运行__init__，请添加

        else:
            cls._instances[cls].__init__(*args, **kwargs)

请参阅if中的Singleton.__call__语句。
关于元类的几句话。元类是类的类。也就是说，类是其元类的实例。您可以使用type(obj)在Python中找到对象的元类。普通的新式类的类型为type。上面代码中的Logger将是class 'your_module.Singleton'类型，就像Logger的（唯一）实例是class 'your_module.Logger'类型一样。当您使用Logger()调用logger时，Python首先询问Logger，Singleton的元类该怎么做，从而允许实例创建被抢占​​。此过程与Python通过执行__getattr__引用类的一个属性时，通过调用myclass.attribute来询问类该做什么。参见例如http://code.activestate.com/recipes/498149/，它实质上是使用元类在Python中重新创建C风格的struct。线程元类的一些（具体）用例是什么？还提供了一些示例，它们通常似乎与声明式编程有关，尤其是在ORM中使用。
在这种情况下，如果使用方法＃2，并且子类定义了__new__方法，则它将在每个调用SubClassOfSingleton()的时间-因为它负责调用返回存储实例的方法。对于元类，仅在创建唯一实例时才调用一次。您想自定义调用类的含义，这取决于类的类型。
通常，使用元类实现单例是有意义的。单例很特殊，因为它仅创建一次，而元类是自定义类创建的方式。如果需要以其他方式自定义单例类定义，使用元类可以为您提供更多控制。
您的单例将不需要多重继承（因为元类不是基类），但是需要创建的子类使用多重继承的类，您需要确保单例类是第一个/最左边的一个具有重新定义__call__的元类的类。这不太可能成为问题。实例dict不在实例的名称空间中，因此不会意外覆盖它。
您还将听到单例模式违反了“单一责任原则”-每个类只能做一件事。这样，您就不必担心如果需要更改另一代码，便会弄乱代码要做的一件事，因为它们是分开封装的。元类实现通过了此测试。元类负责执行模式，创建的类和子类无需知道它们是单例。方法1未能通过此测试，正如您提到的“ MyClass本身是一个函数，不是类，因此您无法从中调用类方法。”
Python 2和3兼容版本
编写有效的内容在Python2和3中，都需要使用稍微复杂一些的方案。由于元类通常是type类型的子类，因此可以在运行时使用它作为元类动态创建一个中间基类，然后将其用作公共Singleton基类的基类。如下所示，这比做起来更难解释。

# works in Python 2 & 3
class _Singleton(type):
    """ A metaclass that creates a Singleton base class when called. """
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(_Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class Singleton(_Singleton('SingletonMeta', (object,), {})): pass

class Logger(Singleton):
    pass

这种方法具有讽刺意味的是，它使用子类来实现元类。一种可能的优点是，与纯元类不同，isinstance(inst, Singleton)将返回True。
更正
关于另一个主题，您可能已经注意到了这一点，但是原始文章中的基类实现是错误的。 _instances需要在类上引用，您需要使用super()或递归，而__new__实际上是一个静态方法，您必须将该类传递给它，而不是一个类方法，因为尚未创建实际的类何时被调用。所有这些事情对于元类实现也将是正确的。 。方法4比其他装饰器版本要好，但它的代码比单例所需的代码多，而且它的功能尚不清楚。
主要问题出在类是它自己的基类上。首先，让一个类成为几乎相同的类的子类，并且名称仅存在于其__class__属性中，这不是很奇怪吗？这也意味着您无法定义使用super()在其基类上调用相同名称的方法的任何方法，因为它们将递归。这意味着您的类无法自定义__new__，并且不能从需要对其进行调用的任何类中派生。
何时使用单例模式
您的用例是想要的更好示例之一使用单例。您在其中一项评论中说：“对我而言，伐木一直是Singletons的自然选择。”你是完全正确的。
当人们说单身人士很糟糕时，最普遍的原因是他们是隐性的共享状态。尽管全局变量和顶级模块导入是显式共享状态，但通常会实例化传递的其他对象。这是一个好点，但有两个例外。
The first, and one that gets mentioned in various places, is when the singletons are constant. Use of global constants, especially enums, is widely accepted, and considered sane because no matter what, none of the users can mess them up for any other user. This is equally true for a constant singleton.
The second exception, which get mentioned less, is the opposite -- when the singleton is only a data sink, not a data source (directly or indirectly). This is why loggers feel like a "natural" use for singletons. As the various users are not changing the loggers in ways other users will care about, there is not really shared state. This negates the primary argument against the singleton pattern, and makes them a reasonable choice because of their ease of use for the task.
Here is a quote from http://googletesting.blogspot.com/2008/08/root-cause-of-singletons.html:

Now, there is one kind of Singleton which is OK. That is a singleton where all of the reachable objects are immutable. If all objects are immutable than Singleton has no global state, as everything is constant. But it is so easy to turn this kind of singleton into mutable one, it is very slippery slope. Therefore, I am against these Singletons too, not because they are bad, but because it is very easy for them to go bad. (As a side note Java enumeration are just these kind of singletons. As long as you don't put state into your enumeration you are OK, so please don't.)
另一种半可接受的单例是那些不影响代码执行的单例，它们没有“副作用”。日志记录就是一个很好的例子。它加载了Singletons和全局状态。这是可以接受的（因为它不会对您造成伤害），因为无论是否启用给定的记录器，您的应用程序的行为都没有任何不同。此处的信息以一种方式流动：从您的应用程序进入记录器。甚至认为记录器是全局状态，因为没有信息从记录器流入您的应用程序，所以记录器是可以接受的。如果您想让测试断言某些东西正在被记录，那么您仍然应该注入记录器，但是一般来说，记录器即使处于满状态也不会有害。

#2 楼

class Foo(object):
     pass

some_global_variable = Foo()

模块仅导入一次，其他所有内容都过分考虑。不要使用单例，不要使用全局。

#3 楼

使用模块。它仅导入一次。在其中定义一些全局变量-它们将是单例的“属性”。添加一些功能-单例的“方法”。

#4 楼

您可能永远不需要Python中的单例。只需在一个模块中定义所有数据和函数，您就可以拥有一个单例： >

 import datetime
file_name=None

def set_file_name(new_file_name: str):
    global file_name
    file_name=new_file_name

def write(message: str):
    global file_name
    if file_name:
        with open(file_name, 'a+') as f:
            f.write("{} {}\n".format(datetime.datetime.now(), message))
    else:
        print("LOG: {}", message)
 

如果真的需要一个单例课程，那我就去：

     import log
    log.set_file_name("debug.log")
    log.write("System starting")
    ...
 

要使用：

     class My_Singleton(object):
        def foo(self):
            pass

    my_singleton = My_Singleton()
 

其中mysingleton.py是您定义My_Singleton的文件名。之所以起作用，是因为第一次导入文件后，Python不会重新执行代码。

#5 楼

这是为您提供的一线工具：急于实例化。这可能是您想要的，也可能不是。

#6 楼

看看Stack Overflow问题，是否有一种简单，优雅的方法在Python中定义单例？

我强烈建议观看Alex Martelli在python中关于设计模式的演讲：第1部分和第2部分。尤其是在第1部分中，他谈论单例/共享状态对象。

#7 楼

这是我自己的单例实现。您所要做的就是装饰教室。要获取单例，则必须使用Instance方法。这是示例：

   @Singleton
   class Foo:
       def __init__(self):
           print 'Foo created'

   f = Foo() # Error, this isn't how you get the instance of a singleton

   f = Foo.Instance() # Good. Being explicit is in line with the Python Zen
   g = Foo.Instance() # Returns already created instance

   print f is g # True

这是代码：

class Singleton:
    """
    A non-thread-safe helper class to ease implementing singletons.
    This should be used as a decorator -- not a metaclass -- to the
    class that should be a singleton.

    The decorated class can define one `__init__` function that
    takes only the `self` argument. Other than that, there are
    no restrictions that apply to the decorated class.

    To get the singleton instance, use the `Instance` method. Trying
    to use `__call__` will result in a `TypeError` being raised.

    Limitations: The decorated class cannot be inherited from.

    """

    def __init__(self, decorated):
        self._decorated = decorated

    def Instance(self):
        """
        Returns the singleton instance. Upon its first call, it creates a
        new instance of the decorated class and calls its `__init__` method.
        On all subsequent calls, the already created instance is returned.

        """
        try:
            return self._instance
        except AttributeError:
            self._instance = self._decorated()
            return self._instance

    def __call__(self):
        raise TypeError('Singletons must be accessed through `Instance()`.')

    def __instancecheck__(self, inst):
        return isinstance(inst, self._decorated)

#8 楼

如果要具有多个相同类的实例，但仅当args或kwargs不同时，才可以使用第三方python软件包Handy Decorators（软件包decorators）。


如果您有一个处理serial通讯的类，并且要创建一个实例，想要将串行端口作为参数发送，那么采用传统方法将无法正常工作上述装饰器，如果args不同，则可以创建该类的多个实例。
对于相同的args，装饰器将返回已经创建的相同实例。

 >>> from decorators import singleton
>>>
>>> @singleton
... class A:
...     def __init__(self, *args, **kwargs):
...         pass
...
>>>
>>> a = A(name='Siddhesh')
>>> b = A(name='Siddhesh', lname='Sathe')
>>> c = A(name='Siddhesh', lname='Sathe')
>>> a is b  # has to be different
False
>>> b is c  # has to be same
True
>>>
 

#9 楼

方法3看起来很整洁，但是如果您希望程序同时在Python 2和Python 3中运行，则无法使用。即使通过Python版本的测试来保护单独的变体也失败了，因为Python 3版本在Python 2中给出了语法错误。

感谢Mike Watkins：http://mikewatkins.ca/2008/11 / 29 / python-2-and-3-metaclasses /。如果要让程序在Python 2和Python 3中都可以运行，则需要执行以下操作：

被“ BaseClass”替换，但我还没有尝试过（我尝试了如图所示的代码）。

#10 楼

我将我扔进戒指。这是一个简单的装饰器。

from abc import ABC

def singleton(real_cls):

    class SingletonFactory(ABC):

        instance = None

        def __new__(cls, *args, **kwargs):
            if not cls.instance:
                cls.instance = real_cls(*args, **kwargs)
            return cls.instance

    SingletonFactory.register(real_cls)
    return SingletonFactory

# Usage
@singleton
class YourClass:
    ...  # Your normal implementation, no special requirements.

好处我认为它具有其他一些解决方案：


它简洁明了（在我看来； D）。
它的动作已完全封装。您无需更改有关YourClass的实现的任何内容。这包括不需要为您的类使用元类（请注意，上面的元类在工厂中，而不是“真正的”类）。
它不依赖于猴子修补任何东西。对呼叫者透明：


呼叫者仍然简单地导入YourClass，它看起来像一个类（因为它是类），并且可以正常使用。无需使调用者适应工厂功能。
YourClass()实例化的内容仍然是您实现的YourClass的真实实例，而不是任何形式的代理，因此不会因此而产生副作用。

isinstance(instance, YourClass)和类似的操作仍然可以按预期工作（尽管此位确实需要abc，因此排除了Python <2.6）。实类的静态方法不能通过隐藏它的工厂类来透明地调用。我已经很少使用了它，以至于从未碰到过这种需求，但是通过在工厂中使用实现__getattr__()的自定义元类来轻松纠正该问题，该类实现了q4312079q，将所有属性的访问权限委派给真实类。 />
我实际上发现了一个相关的模式更有用（并不是说我经常需要这些东西）是“唯一”模式，其中使用相同的参数实例化该类会导致恢复相同的实例。即“每个论点单身”。上面的代码很好地适应了这个问题，并且变得更加简洁：

def unique(real_cls):

    class UniqueFactory(ABC):

        @functools.lru_cache(None)  # Handy for 3.2+, but use any memoization decorator you like
        def __new__(cls, *args, **kwargs):
            return real_cls(*args, **kwargs)

    UniqueFactory.register(real_cls)
    return UniqueFactory

综上所述，我确实同意以下一般性建议：如果您认为自己需要这些东西之一，则可能应该停一会儿并问自己是否确实需要。 YAGNI 99％的时间。

#11 楼

好吧，除了同意关于模块级全局的Pythonic通用建议外，如何处理：

#12 楼

怎么样：

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)()（也返回相同的实例）来创建其他实例。

#13 楼

使用函数属性也非常简单

def f():
    if not hasattr(f, 'value'):
        setattr(f, 'value', singletonvalue)
    return f.value

#14 楼

基于Tolli答案的代码。

#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)

解释：


创建新类，继承给定的cls
（如果有人想要cls，它不会修改singleton(list)）
创建实例。
现在，当我们轻松创建实例后，使用刚才定义的方法覆盖__new__。
该函数仅在调用者期望的情况下返回__new__，否则引发instance。
当有人尝试从修饰的类继承时，不满足条件。


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


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

#15 楼

它与fab的答案有些相似，但并不完全相同。

单例合约不需要我们能够多次调用构造函数。作为一个单例应该仅创建一次，是否不应该将其视为仅创建一次？ “欺骗”构造函数可能会损害可读性。

所以我的建议是这样的：

class Elvis():
    def __init__(self):
        if hasattr(self.__class__, 'instance'):
            raise Exception()
        self.__class__.instance = self
        # initialisation code...

    @staticmethod
    def the():
        if hasattr(Elvis, 'instance'):
            return Elvis.instance
        return Elvis()

这并不排除使用构造函数或按用户代码输入的字段instance：

if Elvis() is King.instance:

...如果您确定Elvis尚未创建，而King已经创建。 >
但它鼓励用户普遍使用the方法：

Elvis.the().leave(Building.the())

要完成此操作，如果尝试执行此操作，也可以重写__delattr__()以引发异常删除instance并重写__del__()以便引发异常（除非我们知道程序即将结束...）

进一步的改进


我的谢谢那些对注释和编辑有所帮助的人，欢迎其中的更多。当我使用Jython时，这应该可以更普遍地工作并且是线程安全的。如果您不从python2.x中的对象子类化，您将获得一个不使用__new__的旧类。 method
可以通过使用元类来改进，因为这可以使__new__成为类级别的属性，并可能将其重命名为__new__

#16 楼

一支班轮（我不为此感到自豪，但确实能胜任）：

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

#17 楼

如果不需要懒惰地初始化Singleton实例，则以下操作应该很容易且具有线程安全性：

在模块导入时。

#18 楼

也许我误会了单例模式，但是我的解决方案是这个简单而实用的（pythonic？）。这段代码实现了两个目标


使Foo的实例可在任何地方访问（全局）。代码。

#!/usr/bin/env python3

class Foo:
    me = None

    def __init__(self):
        if Foo.me != None:
            raise Exception('Instance of Foo still exists!')

        Foo.me = self


if __name__ == '__main__':
    Foo()
    Foo()

输出

Traceback (most recent call last):
  File "./x.py", line 15, in <module>
    Foo()
  File "./x.py", line 8, in __init__
    raise Exception('Instance of Foo still exists!')
Exception: Instance of Foo still exists!

#19 楼

经过一段时间的努力，我最终想到了以下内容，以便从单独的模块中调用配置对象时，它只会被加载一次。元类允许将全局类实例存储在内置字典中，这在目前看来是存储适当程序全局的最简洁的方法。

#20 楼

我将推荐一种使用元类的优雅解决方案

class Singleton(type): 
    # Inherit from "type" in order to gain access to method __call__
    def __init__(self, *args, **kwargs):
        self.__instance = None # Create a variable to store the object reference
        super().__init__(*args, **kwargs)

    def __call__(self, *args, **kwargs):
        if self.__instance is None:
            # if the object has not already been created
            self.__instance = super().__call__(*args, **kwargs) # Call the __init__ method of the subclass (Spam) and save the reference
            return self.__instance
        else:
            # if object (Spam) reference already exists; return it
            return self.__instance

class Spam(metaclass=Singleton):
    def __init__(self, x):
        print('Creating Spam')
        self.x = x


if __name__ == '__main__':
    spam = Spam(100)
    spam2 = Spam(200)

输出：

Creating Spam

从输出中可以看到，仅实例化了一个对象

#21 楼

我更喜欢这种解决方法，我发现它非常清楚和直接。
例如，如果已经创建了其他一些线程，则使用双重检查。其他任何实例。
https://gist.github.com/werediver/4396488

import threading


# Based on tornado.ioloop.IOLoop.instance() approach.
# See https://github.com/facebook/tornado
class SingletonMixin(object):
    __singleton_lock = threading.Lock()
    __singleton_instance = None

    @classmethod
    def instance(cls):
        if not cls.__singleton_instance:
            with cls.__singleton_lock:
                if not cls.__singleton_instance:
                    cls.__singleton_instance = cls()
        return cls.__singleton_instance


if __name__ == '__main__':
    class A(SingletonMixin):
        pass

    class B(SingletonMixin):
        pass

    a, a2 = A.instance(), A.instance()
    b, b2 = B.instance(), B.instance()

    assert a is a2
    assert b is b2
    assert a is not b

    print('a:  %s\na2: %s' % (a, a2))
    print('b:  %s\nb2: %s' % (b, b2))

#22 楼

我也更喜欢装饰器语法而不是从元类派生。我的两分钱：

 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失败）仅执行一次
您可以再次使用@singleton从修饰的类继承（没用吗？）



od property。如果仍然需要此方法，我建议使用上面建议的元类。 ）。
最后，按照其他建议，考虑在python中使用模块。模块是对象。您甚至可以将它们传递给变量，然后将其注入其他类。

#23 楼

我不记得在哪里找到该解决方案，但是从我的非Python专家的角度来看，它是最“优雅”的：
我为什么喜欢这个？没有装饰器，没有元类，没有多重继承...，如果您决定不再希望它成为Singleton，只需删除__new__方法。因为我是Python（和OOP的新手）的新手，所以我希望有人会直接告诉我为什么这是一种糟糕的方法？

#24 楼

这个答案可能不是您想要的。我想要一个单例，因为只有那个对象才具有其身份，以便进行比较。就我而言，它被用作前哨值。答案很简单，根据python的性质，使任何对象mything = object()都只有该东西才具有其标识。

#25 楼

这是实现单例的首选方式：

class Test(object):
    obj = None

    def __init__(self):
        if Test.obj is not None:
            raise Exception('A Test Singleton instance already exists')
        # Initialization code here

    @classmethod
    def get_instance(cls):
        if cls.obj is None:
            cls.obj = Test()
        return cls.obj

    @classmethod
    def custom_method(cls):
        obj = cls.get_instance()
        # Custom Code here

#26 楼

这种解决方案在模块级别上导致了一些名称空间污染（三个定义，而不仅仅是一个定义），但是我发现它很容易遵循。 ），但不幸的是，类在其自身的定义中不可用。

# wouldn't it be nice if we could do this?
class Foo(object):
    instance = None

    def __new__(cls):
        if cls.instance is None:
            cls.instance = object()
            cls.instance.__class__ = Foo
        return cls.instance

由于不可能，我们可以将初始化和静态实例分解开in

急于初始化：

import random


class FooMaker(object):
    def __init__(self, *args):
        self._count = random.random()
        self._args = args


class Foo(object):
    def __new__(self):
        return foo_instance


foo_instance = FooMaker()
foo_instance.__class__ = Foo

懒惰初始化： >

import random


class FooMaker(object):
    def __init__(self, *args):
        self._count = random.random()
        self._args = args


class Foo(object):
    def __new__(self):
        global foo_instance
        if foo_instance is None:
            foo_instance = FooMaker()
        return foo_instance


foo_instance = None