一句话（我并不骄傲，但它确实起到了作用）：

import sys

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

使用元类

我建议使用方法#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)

到Singleton中的if语句__呼叫__。

关于元类的几句话。元类是类的类；也就是说，类是其元类的实例。您可以在Python中找到类型为（obj）的对象元类。正常的新型类是类型类型。上面代码中的Logger类型为“your_module.Singleton”，就像Logger的（唯一）实例类型为“your_module.Logger”一样。当您使用Logger（）调用Logger时，Python首先询问Logger的元类Singleton要做什么，允许预先创建实例。这个过程与Python在通过执行myclass.attribute引用类的一个属性时，通过调用__getattr__询问类要做什么相同。

元类本质上决定了类的定义意味着什么以及如何实现该定义。例如，请参见http://code.activestate.com/recipes/498149/，它本质上使用元类在Python中重新创建C样式结构。线程元类的一些（具体）用例是什么？还提供了一些示例，它们通常似乎与声明性编程有关，尤其是在ORM中使用。

在这种情况下，如果您使用方法#2，并且子类定义了__new__方法，那么它将在每次调用SubClassOfSingleton（）时执行，因为它负责调用返回存储实例的方法。对于元类，当创建唯一的实例时，它只会被调用一次。您需要自定义调用类的含义，这取决于类的类型。

通常，使用元类来实现单例是有意义的。单例是特殊的，因为它只创建一次，元类是您自定义类创建的方式。在需要以其他方式自定义单例类定义的情况下，使用元类可以提供更多的控制。

您的单例不需要多重继承（因为元类不是基类），但是对于使用多重继承的创建类的子类，您需要确保单例类是第一个/最左边的元类，元类重新定义__call__。这不太可能是问题。实例dict不在实例的命名空间中，因此不会意外覆盖它。

您还会听到单例模式违反了“单一责任原则”——每个类只能做一件事。这样，如果您需要更改另一个代码，您就不必担心会弄乱代码所做的一件事，因为它们是独立的和封装的。元类实现通过了这个测试。元类负责实施模式，创建的类和子类不需要知道它们是单体。方法#1未能通过此测试，正如您在“MyClass本身是一个函数，而不是一个类，因此您不能从中调用类方法”中指出的那样

Python 2和3兼容版本

编写在Python2和Python3中都有效的内容需要使用稍微复杂一些的方案。由于元类通常是类型类型的子类，因此可以使用元类在运行时动态创建一个中间基类，将其作为元类，然后将其用作公共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。

更正

在另一个主题上，您可能已经注意到了这一点，但您最初文章中的基类实现是错误的_实例需要在类上引用，您需要使用super（）或递归，__new__实际上是一个静态方法，您必须将类传递给它，而不是类方法，因为实际的类在调用时尚未创建。所有这些对于元类实现也是正确的。

class Singleton(object):
  _instances = {}
  def __new__(class_, *args, **kwargs):
    if class_ not in class_._instances:
        class_._instances[class_] = super(Singleton, class_).__new__(class_, *args, **kwargs)
    return class_._instances[class_]

class MyClass(Singleton):
  pass

c = MyClass()

装饰师返回类

我本来是在写一篇评论，但太长了，所以我会在这里加上这个。方法#4比其他装饰器版本更好，但它的代码比单例所需的要多，而且它的作用也不太清楚。

主要问题源于类是其自身的基类。首先，让一个类是一个几乎相同的类的子类，并且只有__class__属性中有相同的名称，这不是很奇怪吗？这也意味着你不能用super（）在基类上定义任何调用同名方法的方法，因为它们会递归。这意味着您的类不能自定义__new__，也不能从需要调用__init__的任何类派生。

何时使用单例模式

您的用例是想要使用单例的更好示例之一。你在其中一条评论中说：“对我来说，日志记录似乎一直是辛格尔顿的天然选择。”。

当人们说单身者不好时，最常见的原因是他们是隐性共享状态。虽然全局变量和顶级模块导入是显式共享状态，但传递的其他对象通常是实例化的。这是一个很好的观点，但有两个例外。

第一个，也是在很多地方提到的，是当单重态是恒定的。全局常量的使用，特别是枚举，被广泛接受，并被认为是合理的，因为不管怎样，没有一个用户可以为任何其他用户弄乱它们。这对于一个常量单例也是如此。

第二个例外是相反的，这一点很少提及——当单例只是一个数据接收器，而不是一个数据源（直接或间接）时。这就是为什么伐木工人感觉自己是单身汉的“自然”用途。由于不同的用户并没有以其他用户关心的方式更改日志记录程序，因此没有真正的共享状态。这否定了反对单例模式的主要论点，并使它们成为合理的选择，因为它们易于用于任务。

这里有一段来自http://googletesting.blogspot.com/2008/08/root-cause-of-singletons.html:

现在，有一种Singleton是可以的，那就是所有可到达的对象都是不可变的。如果所有对象都是不可变的，那么Singleton就没有全局状态，因为一切都是恒定的。但要将这种单例转换为可变单例是非常容易的，这是非常困难的。因此，我也反对这些单身汉，不是因为他们很坏，而是因为他们很容易变坏。（顺便说一句，Java枚举就是这类单例。只要不在枚举中输入状态，就可以了，所以请不要这样做。）另一种是半可接受的Singleton，它们不影响代码的执行，没有“副作用”。日志记录就是一个很好的例子。它装载着辛格尔顿和全球状态。这是可以接受的（因为它不会伤害您），因为无论是否启用了给定的记录器，您的应用程序的行为都没有任何不同。这里的信息是单向流动的：从应用程序到记录器。即使认为记录器是全局状态，因为没有信息从记录器流到应用程序中，记录器也是可以接受的。如果您希望您的测试断言某些内容正在被记录，您仍然应该注入您的日志，但一般情况下，尽管日志充满了状态，但它不会有害。

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

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

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]

MC = Singleton('MC', (object), {})

class MyClass(MC):
    pass    # Code for the class implementation

我假设赋值中的“object”需要替换为“BaseClass”，但我还没有尝试过（我已经尝试了如图所示的代码）。

查看堆栈溢出问题是否有一种简单、优雅的方法来定义Python中的单体？有几种解决方案。

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

这是我自己的单线图实现。你所要做的就是装饰课堂；要获得单例，您必须使用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)

如果要将实例用作属性，可以使用元类。例如

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