这个怎么样：

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）（）（也返回相同的实例）来创建其他实例。

如果您不需要对Singleton实例进行延迟初始化，那么以下操作应该是简单且线程安全的：

class A:
    instance = None
    # Methods and variables of the class/object A follow
A.instance = A()

这样，A是在模块导入时初始化的单例。

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

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