是有一个简单优雅的方式来定义的单身?[重复]

Question

这个问题已经有一个答案在这里：

• 创建一个单独Python 20答案

似乎有许多方法来定义 单身 在蟒蛇。是有一个协商一致意见堆溢?

Answer 1

我真的不认为有必要，因为一个模块的功能(以及不一类)将作为一个单独的.其所有的变量定会来的模块，它就不可能实例重复。

如果你希望使用的一类，是没有办法创造私人类或私人的构造Python,所以你不能保护对多个实例，其他的不仅仅是通过《公约》在利用你的API。我仍然只是把方法中一个模块，并且考虑的模块作为单独.

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

Answer 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"

Answer 4

一个稍微不同的方法实施单独在蟒蛇的 伯格图案 通过亚历克斯Martelli(谷歌雇员和Python天才).

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

因此，而不是迫使所有情况下有相同的身份、他们的共有状态。

Answer 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

Answer 6

看到这种实现从 PEP318, 实施单一模式有一个装饰:

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

@singleton
class MyClass:
    ...

Answer 7

作为 接受答案 说，大多数习惯用的方式是只是 使用一个模块.

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

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

看看 蟒蛇的数据模型 更多详细信息 __new__.

例如：

@singleton
class Duck(object):
    pass

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

注：

1. 你必须使用新式的课程(获得从 object)。

2. 单一被初始化时，它被定义，而不是第一次使用它。

3. 这只是一个玩具的例子。我从来没有实际使用这一产品代码，不要计划。

Answer 8

我非常不确定关于这一点，但我的项目中使用'《公约》的单身'(不受强迫单身人士)，也就是说，如果我有一类称为 DataController, 我这个定义相同的模块：

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

这是不优雅的，因为它是一个完整的六线。但我所有的单身使用这一模式，这是至少是非常明确的(这是python).

Answer 9

的 蟒蛇的文件 不会涵盖这一点：

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
        """
        self = "__self__"
        if not hasattr(cls, self):
            instance = object.__new__(cls)
            instance.init(*args, **kwds)
            setattr(cls, self, instance)
        return getattr(cls, self)

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

它应该是比较干净的延长：

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

Answer 10

一个时候，我写了一个单独的蟒蛇在我使用的一类，所有成员的功能有classmethod装饰。

class foo:
  x = 1

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

Answer 11

还有一些有趣的文章在测试的博客，探讨为什么单独都可能是坏的，是防模式：

• 单身是病态的骗子
• 那里有所有的单身走了吗？
• 根本原因的单身

Answer 12

创建一个单独的装饰(aka一个注释)是一个优雅的方式如果你想装饰(注释)的课程向前发展。然后你只要把@单之类的定义。

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

@singleton
class MyClass:
    ...

Answer 13

这里是一个例子彼得Norvig的蟒蛇室内空气质量 我该怎么做Singleton案中蟒蛇? (你应该使用的搜索功能的浏览器发现这个问题，有没有直接的联系，对不起)

布鲁斯还有爱可尔的另一个例子在他的书 想在蟒蛇 (再次没有直接链接到代码)

Answer 14

我认为， 强迫 一个类别或一个实例是单独被矫枉过正。就个人而言，我要定义一个正常的instantiable类、半私人参考，并以一个简单的工厂的功能。

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

这样你可以写测试新鲜的情况下，没有副作用，而且没有必要洒的模块与全球的发言，并且如果需要的话，你可以得到变异中的未来。

Answer 15

单一的模式实施的蟒蛇 礼貌的ActiveState.

它看起来喜欢的一招是把类的应该只有一个实例内的另一类。

Answer 16

正在相对较新的Python我不知道什么是最常见的惯用语，但是最简单的事我能想到的只是使用一个模块，而不是一类。什么已经实例的方法在您的类成就的功能模块和任何数据只是成为变量的模块，而不是成员类。我怀疑这是python的方法来解决问题的类型，人们使用单。

如果你真的想要一个单独的类，有一个合理的执行情况的描述上 第一个打击在谷歌 对于"蟒单"，具体是：

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

这似乎做的伎俩。

Answer 17

OK，单可能是好的或邪恶的，我知道。这是我的执行情况，我简单地延长一个经典的做法引入一个缓内产生许多实例中的一个不同的类型或者，许多情况下的同一类型，但是与不同的参数。

我叫它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>}

每个对象携带的单独的缓存...这可能是邪恶的，但它的伟大工程，对于一些:)

Answer 18

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

Answer 19

我简单的解决方案，这是基于默认值的功能的参数。

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

class Context(object):
    # Anything you want here

Answer 20

单独的一半，兄弟

我完全同意staale和我离开这里一样建立一个单一半的弟弟：

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

a 将报告现在作为同一类别作为单独即使它看起来并不喜欢它。以单一实例的使用复杂的课程最终取决于我们不烂摊子多。

正因为如此，我们可以有同样的效果以及使用更简单的东西就像一个变量或一个模块。仍然，如果我们想使用类为清晰起见并且因为 在蟒蛇类的一个目, 所以我们已经有对象(不和的实例，但它将这样做等)。

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

我们有一个很好的错误断言，如果我们试图创建的一个实例，我们可以存储关于派生的静态成员和更改它们在运行时(我爱Python).这个对象是不如其他大约一半的兄弟(你仍然可以创建他们的如果你想)，但它往往会运行得更快，由于简单。

Answer 21

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

Answer 22

在这种情况下您不想元类为基础的解决方案上，并且你不喜欢简单的功能的装饰为基础的方法(例如因为在这种情况下，静态的方法，在单独的类不工作)，这种折衷的工作：

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)