有没有一种简单、优雅的方法来定义单例？[重复]-IT科技

摘要：问题描述：在 Python 中定义单例的方式似乎有很多种。Stack Overflow 上是否有统一的意见？解决方案 1：我觉得没必要，因为带有函数的模块（而不是类）可以很好地用作单例。它的所有变量都将绑定到模块，无论如何都无法重复实例化。如果您确实希望使用类，则无法在 Python 中创建私有类或私有构造函...

问题描述：

在 Python 中定义单例的方式似乎有很多种。Stack Overflow 上是否有统一的意见？

解决方案 1：

我觉得没必要，因为带有函数的模块（而不是类）可以很好地用作单例。它的所有变量都将绑定到模块，无论如何都无法重复实例化。

如果您确实希望使用类，则无法在 Python 中创建私有类或私有构造函数，因此您无法防止多次实例化，除非通过 API 的使用约定。我仍然会将方法放在模块中，并将模块视为单例。

解决方案 2：

这是我自己实现的单例。你所要做的就是装饰类；要获得单例，你必须使用Instance方法。以下是一个例子：

@Singleton
class Foo:
   def __init__(self):
       print 'Foo created'

f = Foo() # Error, this isn't how you get the instance of a singleton

f = Foo.instance() # Good. Being explicit is in line with the Python Zen
g = Foo.instance() # Returns already created instance

print f is g # True

代码如下：

class Singleton:
    """
    A non-thread-safe helper class to ease implementing singletons.
    This should be used as a decorator -- not a metaclass -- to the
    class that should be a singleton.

    The decorated class can define one `__init__` function that
    takes only the `self` argument. Also, the decorated class cannot be
    inherited from. Other than that, there are no restrictions that apply
    to the decorated class.

    To get the singleton instance, use the `instance` method. Trying
    to use `__call__` will result in a `TypeError` being raised.

    """

    def __init__(self, decorated):
        self._decorated = decorated

    def instance(self):
        """
        Returns the singleton instance. Upon its first call, it creates a
        new instance of the decorated class and calls its `__init__` method.
        On all subsequent calls, the already created instance is returned.

        """
        try:
            return self._instance
        except AttributeError:
            self._instance = self._decorated()
            return self._instance

    def __call__(self):
        raise TypeError('Singletons must be accessed through `instance()`.')

    def __instancecheck__(self, inst):
        return isinstance(inst, self._decorated)

解决方案 3：

您可以__new__像这样覆盖该方法：

class Singleton(object):
    _instance = None
    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(
                                cls, *args, **kwargs)
        return cls._instance


if __name__ == '__main__':
    s1 = Singleton()
    s2 = Singleton()
    if (id(s1) == id(s2)):
        print("Same")
    else:
        print("Different")

解决方案 4：

在 Python 中实现单例的稍微不同的方法是Alex Martelli（Google 员工和 Python 天才）提出的Borg 模式。

class Borg:
    __shared_state = {}
    def __init__(self):
        self.__dict__ = self.__shared_state

因此，不是强制所有实例具有相同的身份，而是它们共享状态。

解决方案 5：

模块方法效果很好。如果我绝对需要单例，我更喜欢元类方法。

class Singleton(type):
    def __init__(cls, name, bases, dict):
        super(Singleton, cls).__init__(name, bases, dict)
        cls.instance = None 

    def __call__(cls,*args,**kw):
        if cls.instance is None:
            cls.instance = super(Singleton, cls).__call__(*args, **kw)
        return cls.instance

class MyClass(object):
    __metaclass__ = Singleton

解决方案 6：

参见PEP318中的实现，使用装饰器实现单例模式：

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

@singleton
class MyClass:
    ...

解决方案 7：

Python 文档确实涵盖了这一点：

class Singleton(object):
    def __new__(cls, *args, **kwds):
        it = cls.__dict__.get("__it__")
        if it is not None:
            return it
        cls.__it__ = it = object.__new__(cls)
        it.init(*args, **kwds)
        return it
    def init(self, *args, **kwds):
        pass

我可能会将其重写为看起来更像这样：

class Singleton(object):
    """Use to create a singleton"""
    def __new__(cls, *args, **kwds):
        """
        >>> s = Singleton()
        >>> p = Singleton()
        >>> id(s) == id(p)
        True
        """
        it_id = "__it__"
        # getattr will dip into base classes, so __dict__ must be used
        it = cls.__dict__.get(it_id, None)
        if it is not None:
            return it
        it = object.__new__(cls)
        setattr(cls, it_id, it)
        it.init(*args, **kwds)
        return it

    def init(self, *args, **kwds):
        pass


class A(Singleton):
    pass


class B(Singleton):
    pass


class C(A):
    pass


assert A() is A()
assert B() is B()
assert C() is C()
assert A() is not B()
assert C() is not B()
assert C() is not A()

扩展这个应该相对干净：

class Bus(Singleton):
    def init(self, label=None, *args, **kwds):
        self.label = label
        self.channels = [Channel("system"), Channel("app")]
        ...

解决方案 8：

我对此非常不确定，但我的项目使用“约定单例”（而不是强制单例），也就是说，如果我有一个名为的类DataController，我会在同一个模块中定义它：

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

它并不优雅，因为它有整整六行。但我的所有单例都使用这种模式，而且它至少非常明确（这是 Pythonic）。

解决方案 9：

正如接受的答案所说，最惯用的方法就是使用模块。

考虑到这一点，这里有一个概念证明：

def singleton(cls):
    obj = cls()
    # Always return the same object
    cls.__new__ = staticmethod(lambda cls: obj)
    # Disable __init__
    try:
        del cls.__init__
    except AttributeError:
        pass
    return cls

有关的更多详细信息，请参阅Python 数据模型__new__。

例子：

@singleton
class Duck(object):
    pass

if Duck() is Duck():
    print("It works!")
else:
    print("It doesn't work!")

笔记：

object为此，您必须使用新式类（派生自）。
单例在定义时进行初始化，而不是第一次使用时。
这只是一个玩具示例。我从未在生产代码中实际使用过它，也不打算这么做。

解决方案 10：

有一次我用 Python 编写了一个单例，我使用了一个类，其中所有成员函数都有类方法装饰器。

class Foo:
    x = 1
  
    @classmethod
    def increment(cls, y=1):
        cls.x += y

解决方案 11：

如果您想装饰（注释）类，创建单例装饰器（又称注释）是一种优雅的方法。然后，您只需在类定义之前放置 @singleton 即可。

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

@singleton
class MyClass:
    ...

解决方案 12：

Google Testing 博客上还有一些有趣的文章，讨论了为什么单例是/可能不好并且是一种反模式：

单身人士都是病态说谎者
单身人士都去哪儿了？
单例的根本原因

解决方案 13：

我认为强制将类或实例设为单例有点过头了。我个人喜欢定义一个普通的可实例化类、一个半私有引用和一个简单的工厂函数。

class NothingSpecial:
    pass

_the_one_and_only = None

def TheOneAndOnly():
    global _the_one_and_only
    if not _the_one_and_only:
        _the_one_and_only = NothingSpecial()
    return _the_one_and_only

或者，如果首次导入模块时实例化没有问题：

class NothingSpecial:
    pass

THE_ONE_AND_ONLY = NothingSpecial()

这样，您可以针对没有副作用的新实例编写测试，并且不需要在模块中添加全局语句，如果需要，您可以在将来派生变体。

解决方案 14：

由 ActiveState使用 Python 实现的单例模式。

看起来诀窍就是将仅具有一个实例的类放入另一个类中。

解决方案 15：

class Singleton(object[,...]):

    staticVar1 = None
    staticVar2 = None

    def __init__(self):
        if self.__class__.staticVar1==None :
            # create class instance variable for instantiation of class
            # assign class instance variable values to class static variables
        else:
            # assign class static variable values to class instance variables

解决方案 16：

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))

解决方案 17：

好吧，我知道单例可能是好事也可能是坏事。这是我的实现，我只是扩展了一个经典方法，在内部引入一个缓存，并生成许多不同类型的实例，或者许多相同类型的实例，但具有不同的参数。

我将其称为 Singleton_group，因为它将相似的实例组合在一起并防止创建具有相同参数的同一类的对象：

# Peppelinux's cached singleton
class Singleton_group(object):
    __instances_args_dict = {}
    def __new__(cls, *args, **kwargs):
        if not cls.__instances_args_dict.get((cls.__name__, args, str(kwargs))):
            cls.__instances_args_dict[(cls.__name__, args, str(kwargs))] = super(Singleton_group, cls).__new__(cls, *args, **kwargs)
        return cls.__instances_args_dict.get((cls.__name__, args, str(kwargs)))


# It's a dummy real world use example:
class test(Singleton_group):
    def __init__(self, salute):
        self.salute = salute

a = test('bye')
b = test('hi')
c = test('bye')
d = test('hi')
e = test('goodbye')
f = test('goodbye')

id(a)
3070148780L

id(b)
3070148908L

id(c)
3070148780L

b == d
True


b._Singleton_group__instances_args_dict

{('test', ('bye',), '{}'): <__main__.test object at 0xb6fec0ac>,
 ('test', ('goodbye',), '{}'): <__main__.test object at 0xb6fec32c>,
 ('test', ('hi',), '{}'): <__main__.test object at 0xb6fec12c>}

每个对象都带有单例缓存...这可能是邪恶的，但对于某些人来说它效果很好:)

解决方案 18：

我的简单解决方案是基于函数参数的默认值。

def getSystemContext(contextObjList=[]):
    if len( contextObjList ) == 0:
        contextObjList.append( Context() )
        pass
    return contextObjList[0]

class Context(object):
    # Anything you want here

解决方案 19：

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

如果你真的想要一个单例类，那么在 Google 上搜索“Python 单例”的第一个结果中描述了一个合理的实现，具体来说：

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

这似乎很有效。

解决方案 20：

辛格尔顿同父异母的兄弟

我完全同意 staale 的观点，并且在这里留下一个创建单例同父异母兄弟的示例：

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

a现在将报告为与单例属于同一类，即使看起来不像。因此，使用复杂类的单例最终取决于我们不会过多地干扰它们。

这样，我们可以获得相同的效果并使用更简单的东西，例如变量或模块。不过，如果我们想使用类来清晰表达，并且因为在 Python 中类是对象，所以我们已经有了对象（不是实例，但它会像实例一样工作）。

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

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

解决方案 21：

如果您不想要上述基于元类的解决方案，并且不喜欢基于简单函数装饰器的方法（例如，因为在这种情况下单例类上的静态方法不起作用），那么这种折衷方法是可行的：

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)