我想强调的几个注意事项是，

元类方法：

不能从2个元类继承。检查如果您使用的工厂模式都是单例类，那么它就不会工作。您的父级已经从ABC继承（它是元类），那么您不能从单例元类继承

装饰方法：

我使用一个函数作为工厂接口，它从base创建T的实例__子类__（）。这将跳过子类初始化的单例修饰符

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

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

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

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

这个怎么样：

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（）从类中“创建”实例（实际上是唯一的实例）。它还防止您通过执行类型（MySingleton）（）（也返回相同的实例）来创建其他实例。

使用类变量（无修饰符）

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

与从元类派生相比，我更喜欢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中使用模块。模块是对象。您甚至可以在变量中传递它们，并将它们注入到其他类中。