这与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__将是未绑定的实例方法这可以通过使用元类来改进，因为这将允许您创建类级属性，并可能将其重命名为实例

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

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

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

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

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

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

我不记得我在哪里找到了这个解决方案，但从我的非Python专家的角度来看，我发现它是最“优雅”的：

class SomeSingleton(dict):
    __instance__ = None
    def __new__(cls, *args,**kwargs):
        if SomeSingleton.__instance__ is None:
            SomeSingleton.__instance__ = dict.__new__(cls)
        return SomeSingleton.__instance__

    def __init__(self):
        pass

    def some_func(self,arg):
        pass

我为什么喜欢这个？没有修饰符，没有元类，没有多重继承。。。如果你决定不再让它成为单身汉，就删除__new__方法。由于我刚接触Python（以及OOP），我希望有人能告诉我为什么这是一种可怕的方法？

赞成的意见这是一个真正的类Auto神奇地覆盖继承使用元类出于正当目的（并使我意识到）有吗？

这将是串行化的问题。如果您尝试从文件（pickle）反序列化对象，它将不使用__call__，因此将创建新文件，您可以使用__new__的基类继承来防止这种情况。

如果想要拥有同一类的多个实例，但只有当args或kwargs不同时，才可以使用第三方python包Handy Decorator（包装饰器）。前任。如果您有一个处理串行通信的类，并且要创建一个实例，您希望将串行端口作为参数发送，那么使用传统的方法是行不通的如果参数不同，可以使用上面提到的修饰符创建类的多个实例。对于相同的参数，decorator将返回已创建的相同实例。

>>> from decorators import singleton
>>>
>>> @singleton
... class A:
...     def __init__(self, *args, **kwargs):
...         pass
...
>>>
>>> a = A(name='Siddhesh')
>>> b = A(name='Siddhesh', lname='Sathe')
>>> c = A(name='Siddhesh', lname='Sathe')
>>> a is b  # has to be different
False
>>> b is c  # has to be same
True
>>>