似乎有很多方法可以在 Python中定义单例。对 Stack Overflow 是否有共识？
Jamie
问问题
370963 次
21 回答
400
我真的不认为有必要，因为具有函数（而不是类）的模块可以很好地用作单例。它的所有变量都将绑定到模块，无论如何都不能重复实例化。
如果您确实希望使用一个类，则无法在 Python 中创建私有类或私有构造函数，因此您无法防止多个实例化，只能通过使用 API 的约定。我仍然会将方法放在模块中，并将模块视为单例。
于 2008-08-28T09:10:12.743 回答
345
这是我自己的单例实现。您所要做的就是装饰班级；要获得单例，您必须使用该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)
于 2011-09-08T09:46:25.667 回答
207
您可以像这样覆盖该__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"
于 2009-11-27T19:37:43.380 回答
127
在 Python 中实现单例的一个稍微不同的方法是 Alex Martelli（Google 员工和 Python 天才）的borg 模式。
class Borg:
__shared_state = {}
def __init__(self):
self.__dict__ = self.__shared_state
因此，它们不是强制所有实例具有相同的身份，而是共享状态。
于 2008-08-28T14:53:54.680 回答
88
模块方法效果很好。如果我绝对需要一个单例，我更喜欢 Metaclass 方法。
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
于 2008-08-28T19:39:25.117 回答
47
请参阅PEP318中的此实现，使用装饰器实现单例模式：
def singleton(cls):
instances = {}
def getinstance():
if cls not in instances:
instances[cls] = cls()
return instances[cls]
return getinstance
@singleton
class MyClass:
...
于 2010-05-02T02:47:11.607 回答
34
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")]
...
于 2012-07-17T06:38:44.117 回答
27
正如公认的答案所说，最惯用的方法是只使用一个模块。
考虑到这一点，这里有一个概念证明：
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!"
笔记：
为此，您必须使用新型类（派生自
object）。单例在定义时初始化，而不是在第一次使用时初始化。
这只是一个玩具示例。我从未在生产代码中实际使用过它，也不打算这样做。
于 2012-10-12T00:13:51.143 回答
26
我对此非常不确定，但我的项目使用“约定单例”（不是强制单例），也就是说，如果我有一个名为 的类DataController，我会在同一个模块中定义它：
_data_controller = None
def GetDataController():
global _data_controller
if _data_controller is None:
_data_controller = DataController()
return _data_controller
它并不优雅，因为它是整整六行。但是我所有的单身人士都使用这种模式，而且它至少非常明确（这是pythonic）。
于 2009-08-22T00:44:23.967 回答
18
有一次我在 Python 中编写了一个单例，我使用了一个类，其中所有成员函数都有 classmethod 装饰器。
class Foo:
x = 1
@classmethod
def increment(cls, y=1):
cls.x += y
于 2008-08-29T19:15:02.393 回答
13
如果您想在未来装饰（注释）类，创建单例装饰器（也称为注释）是一种优雅的方式。然后，您只需将 @singleton 放在您的类定义之前。
def singleton(cls):
instances = {}
def getinstance():
if cls not in instances:
instances[cls] = cls()
return instances[cls]
return getinstance
@singleton
class MyClass:
...
于 2012-02-22T22:16:50.400 回答
9
Google 测试博客上也有一些有趣的文章，讨论了为什么单例是/可能是坏的并且是一种反模式：
于 2008-09-15T07:47:20.000 回答
7
我认为强迫一个类或一个实例成为单例是过分的。就个人而言，我喜欢定义一个普通的可实例化类、一个半私有引用和一个简单的工厂函数。
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()
这样，您可以针对新实例编写测试而不会产生副作用，并且无需在模块中添加全局语句，并且如果需要，您可以在将来派生变体。
于 2011-07-27T12:00:02.120 回答
3
由 ActiveState 提供的用 Python 实现的单例模式。
看起来诀窍是将应该只有一个实例的类放在另一个类中。
于 2008-09-03T20:54:25.827 回答
3
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
于 2009-12-17T15:10:32.147 回答
3
好吧，我知道单身可能是好是坏。这是我的实现，我只是扩展了一种经典方法，在内部引入缓存并生成许多不同类型的实例，或者许多相同类型但具有不同参数的实例。
我将其命名为 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>}
每个对象都带有单例缓存......这可能是邪恶的，但它对某些人来说很好:)
于 2012-02-28T20:42:40.507 回答
2
作为 Python 的新手，我不确定最常见的习惯用法是什么，但我能想到的最简单的事情就是使用模块而不是类。类上的实例方法只是模块中的函数，任何数据都只是模块中的变量而不是类的成员。我怀疑这是解决人们使用单例的问题类型的pythonic方法。
如果你真的想要一个单例类，在谷歌的第一次点击中描述了一个合理的实现“Python单例”，特别是：
class Singleton:
__single = None
def __init__( self ):
if Singleton.__single:
raise Singleton.__single
Singleton.__single = self
这似乎可以解决问题。
于 2008-08-28T09:09:22.073 回答
2
我的简单解决方案是基于函数参数的默认值。
def getSystemContext(contextObjList=[]):
if len( contextObjList ) == 0:
contextObjList.append( Context() )
pass
return contextObjList[0]
class Context(object):
# Anything you want here
于 2011-11-28T13:15:24.813 回答
2
辛格尔顿的同父异母兄弟
我完全同意 staale 的观点，我在这里留下一个创建单身同父异母兄弟的示例：
class void:pass
a = void();
a.__class__ = Singleton
a现在将报告为与单例相同的类，即使它看起来不像。因此，使用复杂类的单例最终取决于我们对它们的处理程度。
这样一来，我们就可以达到同样的效果，并使用更简单的东西，比如变量或模块。尽管如此，如果我们为了清楚起见想要使用类，并且因为在 Python 中类是一个对象，所以我们已经有了对象（不是和实例，但它会这样做）。
class Singleton:
def __new__(cls): raise AssertionError # Singletons can't have instances
如果我们尝试创建一个实例，我们会遇到一个很好的断言错误，我们可以存储派生静态成员并在运行时对它们进行更改（我喜欢 Python）。这个对象和其他大约半兄弟一样好（如果你愿意，你仍然可以创建它们），但是由于简单，它会运行得更快。
于 2013-01-11T15:10:23.487 回答
1
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))
于 2012-08-15T07:08:55.117 回答
0
如果您不想要上面基于元类的解决方案，并且您不喜欢简单的基于函数装饰器的方法（例如，因为在这种情况下单例类上的静态方法不起作用），这种折衷方案有效：
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)
于 2011-10-28T09:52:42.733 回答