from functools import cache

@cache
class xxx:
   ....

非常简单，而且有效！

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

使Foo的实例可以在任何地方访问（全局）。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!

您可能永远不需要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 MySingleton(object):
    def foo(self):
        pass

my_singleton = MySingleton()

要使用：

from mysingleton import my_singleton
my_singleton.foo()

其中mysingleton.py是定义mysingleton的文件名。这是因为在第一次导入文件后，Python不会重新执行代码。

使用类变量（无修饰符）

通过重写__new__方法返回类的相同实例。仅首次初始化类的布尔值：

class SingletonClass:
    _instance = None

    def __new__(cls, *args, **kwargs):
        # If no instance of class already exits
        if cls._instance is None:
            cls._instance = object.__new__(cls)
            cls._instance._initialized = False
        return cls._instance
        
    def __init__(self, *args, **kwargs):
        if self._initialized:
            return

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

看看这个。其思想是通过args和kwargs来散列实例密钥。https://stackoverflow.com/a/73495782/2910384