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

class Foo(object):
     pass

some_global_variable = Foo()

模块只导入一次，其他一切都在考虑之中。不要使用singleton，也不要使用globals。

我更喜欢使用静态方法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))

这与fab的答案略有相似，但并不完全相同。

单例模式不要求我们能够多次调用构造函数。作为一个单例应该创建一次，而且只能创建一次。难道它不应该被视为只创建一次吗？“欺骗”构造函数可能会损害易读性。

所以我的建议是：

class Elvis():
    def __init__(self):
        if hasattr(self.__class__, 'instance'):
            raise Exception()
        self.__class__.instance = self
        # initialisation code...

    @staticmethod
    def the():
        if hasattr(Elvis, 'instance'):
            return Elvis.instance
        return Elvis()

这并不排除用户代码使用构造函数或字段实例：

if Elvis() is King.instance:

…如果你确定猫王还没有被创造，而国王已经被创造了。

但它鼓励用户普遍使用以下方法：

Elvis.the().leave(Building.the())

若要完成此操作，您还可以重写__delattr__（）以在尝试删除实例时引发异常，并重写__del__（）以便引发异常（除非我们知道程序正在结束…）

进一步改进

我感谢那些帮助评论和编辑的人，欢迎更多评论和编辑。当我使用Jython时，这应该更普遍地工作，并且是线程安全的。

try:
    # This is jython-specific
    from synchronize import make_synchronized
except ImportError:
    # This should work across different python implementations
    def make_synchronized(func):
        import threading
        func.__lock__ = threading.Lock()
    
        def synced_func(*args, **kws):
            with func.__lock__:
                return func(*args, **kws)

        return synced_func

class Elvis(object): # NB must be subclass of object to use __new__
    instance = None

    @classmethod
    @make_synchronized
    def __new__(cls, *args, **kwargs):
        if cls.instance is not None:
            raise Exception()
        cls.instance = object.__new__(cls, *args, **kwargs)
        return cls.instance
    
    def __init__(self):
        pass
        # initialisation code...

    @classmethod
    @make_synchronized
    def the(cls):
        if cls.instance is not None:
            return cls.instance
        return cls()

注意事项：

如果您不从python2.x中的对象子类，您将得到一个不使用__new的旧式类__当修饰__new__时，必须用@classmethod修饰，否则__new__将是未绑定的实例方法这可以通过使用元类来改进，因为这将允许您创建类级属性，并可能将其重命名为实例

正如@Staale在这里提到的，在python中创建单例的最简单方法是使用带有全局变量的模块（作为“属性”，而全局函数作为“方法”）。但我想为这个已经令人惊叹的答案补充一点非常重要的东西：继承也在这里发挥作用！

要创建一个继承自另一个“singleton module”a.py的“singleton模块”B.py，只需使用以下行启动B.py：from a import*，这将尊重私有变量（默认情况下不导入它们）。

一句话（我并不骄傲，但它确实起到了作用）：

import sys

class Myclass:
  def __init__(self):
     # do your stuff
      vars(sys.modules[__name__])[type(self).__name__] = lambda: self # singletonify