使用类变量（无修饰符）

通过重写__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中使用模块。模块是对象。您甚至可以在变量中传递它们，并将它们注入到其他类中。

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

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

我更喜欢使用静态方法GetInstance（）来创建单例对象（也不允许任何其他方法这样做），以强调我使用的是单例设计模式。

import inspect
class SingletonMeta(type):
    __instances = {}
    GET_INSTANCE = 'GetInstance' # class method ussed to create Singleton instance

    def __call__(cls, *args, **kwargs):
        caller_frame = inspect.currentframe().f_back

        caller_class = caller_frame.f_locals.get('cls_ref')
        caller_method_name = caller_frame.f_code.co_name
        if caller_class is cls and \
            caller_method_name == SingletonMeta.GET_INSTANCE:
            obj = super(SingletonMeta, cls).__call__(*args, **kwargs)
        else:
            raise Exception(f"Class '{cls.__name__}' is a singleton! Use '{cls.__name__}.{SingletonMeta.GET_INSTANCE}()' to create its instance.")

        return obj

    def __new__(cls, name, bases, dct):
        def GetInstance(cls_ref):
            if cls_ref not in cls_ref.__instances:
                cls_ref.__instances[cls_ref] = cls_ref()

            return cls_ref.__instances[cls_ref]
       
        return super().__new__(cls, name, bases, {**dct, GetInstance.__name__: classmethod(GetInstance)})
#------------------------
if __name__ == '__main__':
    class SingletonSample1(metaclass=SingletonMeta):
        def __init__(self):
            self.__x = 1

        @property
        def x(self) -> int:
            return self.__x

        @x.setter
        def x(self, value):
            self.__x = value

    s1 = SingletonSample1.GetInstance()
    s1.x = 3

    try:
        s2 = SingletonSample1()
    Exception as error:
        print(repr(error))

这个答案可能不是你想要的。我想要一个单例，因为只有那个对象才有它的身份，以便与之比较。在我的例子中，它被用作Sentinel Value。答案很简单，将任何对象设为mything=object（），根据python的性质，只有该对象才具有其身份。

#!python
MyNone = object()  # The singleton

for item in my_list:
    if item is MyNone:  # An Example identity comparison
        raise StopIteration

方法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”，但我还没有尝试过（我已经尝试了如图所示的代码）。