class Singeltone(type):
    instances = dict()

    def __call__(cls, *args, **kwargs):
        if cls.__name__ not in Singeltone.instances:            
            Singeltone.instances[cls.__name__] = type.__call__(cls, *args, **kwargs)
        return Singeltone.instances[cls.__name__]


class Test(object):
    __metaclass__ = Singeltone


inst0 = Test()
inst1 = Test()
print(id(inst1) == id(inst0))

我对此非常不确定，但我的项目使用'惯例单例'(不是强制单例)，也就是说，如果我有一个名为DataController的类，我在同一个模块中定义这个:

_data_controller = None
def GetDataController():
    global _data_controller
    if _data_controller is None:
        _data_controller = DataController()
    return _data_controller

它并不优雅，因为它足足有六行。但是我所有的单例都使用这个模式，而且它至少是非常显式的(这是python的)。

如果你不想要上面的基于元类的解决方案，并且你不喜欢简单的基于函数装饰器的方法(例如，因为在这种情况下，单例类上的静态方法将不起作用)，这种妥协是可行的:

class singleton(object):
  """Singleton decorator."""

  def __init__(self, cls):
      self.__dict__['cls'] = cls

  instances = {}

  def __call__(self):
      if self.cls not in self.instances:
          self.instances[self.cls] = self.cls()
      return self.instances[self.cls]

  def __getattr__(self, attr):
      return getattr(self.__dict__['cls'], attr)

  def __setattr__(self, attr, value):
      return setattr(self.__dict__['cls'], attr, value)

辛格尔顿同父异母的兄弟

我完全同意staale的观点，我在这里留下了一个创建单胎同父异母兄弟的例子:

class void:pass
a = void();
a.__class__ = Singleton

即使看起来不像单例，A现在也会报告为与单例属于同一个类。因此，使用复杂类的单例最终依赖于我们没有过多地干扰它们。

因此，我们可以使用更简单的东西，如变量或模块，以达到同样的效果。尽管如此，如果我们想要使用类来明确，并且因为在Python中类是一个对象，所以我们已经有了对象(不是实例，但它会像)。

class Singleton:
    def __new__(cls): raise AssertionError # Singletons can't have instances

如果我们尝试创建一个实例，我们会有一个很好的断言错误，我们可以在派生上存储静态成员，并在运行时对它们进行更改(我喜欢Python)。这个对象和其他同父异母的兄弟一样好(如果你愿意，你仍然可以创建它们)，但是由于简单，它往往会运行得更快。

作为Python的新手，我不确定最常见的习语是什么，但我能想到的最简单的事情就是使用模块而不是类。类中的实例方法变成了模块中的函数，任何数据都变成了模块中的变量，而不是类的成员。我怀疑这是解决人们使用单例对象的问题的python方法。

如果你真的想要一个单例类，有一个合理的实现描述在谷歌的第一个点击“Python singleton”，具体地说:

class Singleton:
    __single = None
    def __init__( self ):
        if Singleton.__single:
            raise Singleton.__single
        Singleton.__single = self

这似乎奏效了。

如果你想继续装饰(注释)类，创建一个单例装饰器(又名注释)是一种优雅的方式。然后将@singleton放在类定义之前。

def singleton(cls):
    instances = {}
    def getinstance():
        if cls not in instances:
            instances[cls] = cls()
        return instances[cls]
    return getinstance

@singleton
class MyClass:
    ...