这个解决方案在模块级别造成了一些命名空间污染（三个定义而不是一个），但我发现很容易理解。

我希望能够编写这样的东西（惰性初始化），但不幸的是，类在它们自己的定义体中不可用。

# 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

由于这是不可能的，我们可以在

Eagle初始化：

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

延迟初始化：

Eagle初始化：

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

这里是一个结合@agf和@（Siddhesh Suhas Sathe）解决方案的简单实现，它使用元类并考虑构造函数参数，因此如果使用完全相同的参数创建foo类，则可以返回相同的实例

class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        """
        Possible changes to the value of the `__init__` argument do not affect
        the returned instance.
        """
        cls_instances = cls._instances.get(cls) or []
        matching_instances = list(
            filter(
                lambda x: x["args"] == args and x["kwargs"] == kwargs,
                cls_instances,
            )
        )
        if len(matching_instances) == 1:
            return matching_instances[0]["instance"]
        else:
            instance = super().__call__(*args, **kwargs)
            cls_instances.append({"instance": instance, "args": args, "kwargs": kwargs})
            cls._instances[cls] = cls_instances
            return instance


class foo(metaclass=SingletonMeta):
    def __init__(self, param, k_param=None) -> None:
        print("Creating new instance")
        self.param = param
        self.k_param = k_param
        self._creation_time = time.time()

如果想要拥有同一类的多个实例，但只有当args或kwargs不同时，才可以使用第三方python包Handy Decorator（包装饰器）。前任。如果您有一个处理串行通信的类，并且要创建一个实例，您希望将串行端口作为参数发送，那么使用传统的方法是行不通的如果参数不同，可以使用上面提到的修饰符创建类的多个实例。对于相同的参数，decorator将返回已创建的相同实例。

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

使用元类

我建议使用方法#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，它们不影响代码的执行，没有“副作用”。日志记录就是一个很好的例子。它装载着辛格尔顿和全球状态。这是可以接受的（因为它不会伤害您），因为无论是否启用了给定的记录器，您的应用程序的行为都没有任何不同。这里的信息是单向流动的：从应用程序到记录器。即使认为记录器是全局状态，因为没有信息从记录器流到应用程序中，记录器也是可以接受的。如果您希望您的测试断言某些内容正在被记录，您仍然应该注入您的日志，但一般情况下，尽管日志充满了状态，但它不会有害。

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

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

赞成的意见这是一个真正的类Auto神奇地覆盖继承使用元类出于正当目的（并使我意识到）有吗？

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