与从元类派生相比，我更喜欢decorator语法。我的两分钱：

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失败）属性、classmethod和staticmethod仍将按预期工作__init__（）构造函数只执行一次您可以再次使用@singleton从修饰类（无用？）继承

欺骗：

打印（MyClass（）__第__类__name__）将返回Singleton而不是MyClass。如果您仍然需要这个，我建议使用上面建议的元类。

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

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

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

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

从输出中可以看到，只有一个对象被实例化

我只是偶然做了一个简单的，想分享一下。。。

class MySingleton(object):
    def __init__(self, *, props={}):
        self.__dict__ = props

mything = MySingleton()
mything.test = 1
mything2 = MySingleton()
print(mything2.test)
mything2.test = 5
print(mything.test)

使用类变量（无修饰符）

通过重写__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

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

也许我误解了单例模式，但我的解决方案是简单实用的（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!