所谓单例，是指一个类的实例从始至终只能被创建一次,,而且自行实例化并向整个系统提供这个实例。
方法1
如果想使得某个类从始至终最多只有一个实例，使用__new__方法会很简单。Python中类是通过__new__来创建实例的：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class Singleton(object): def __new__(cls, *args, **kwargs): if not hasattr(cls, '_inst'): cls._inst = super(Singleton, cls).__new__(cls, *args, **kwargs) return cls._instif __name__ == '__main__': class A(Singleton): def __init__(self, s): self.s = s a = A('apple') b = A('banana') print id(a), a.s print id(b), b.s |
结果：
|
1
2
|
29922256 banana29922256 banana |
通过__new__方法，将类的实例在创建的时候绑定到类属性_inst上。如果cls._inst为None，说明类还未实例化，实例化并将实例绑定到cls._inst，以后每次实例化的时候都返回第一次实例化创建的实例。注意从Singleton派生子类的时候，不要重载__new__。
方法2：
有时候我们并不关心生成的实例是否具有同一id，而只关心其状态和行为方式。我们可以允许许多个实例被创建，但所有的实例都共享状态和行为方式：
|
1
2
3
4
5
6
|
class Borg(object): _shared_state = {} def __new__(cls, *args, **kwargs): obj = super(Borg,cls).__new__(cls, *args, **kwargs) obj.__dict__ = cls._shared_state return obj |
将所有实例的__dict__指向同一个字典，这样实例就共享相同的方法和属性。对任何实例的名字属性的设置，无论是在__init__中修改还是直接修改，所有的实例都会受到影响。不过实例的id是不同的。要保证类实例能共享属性，但不和子类共享，注意使用cls._shared_state,而不是Borg._shared_state。
因为实例是不同的id，所以每个实例都可以做字典的key：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
if __name__ == '__main__': class Example(Borg): pass a = Example() b = Example() c = Example() adict = {} j = 0 for i in a, b, c: adict[i] = j j += 1 for i in a, b, c: print adict[i] |
结果：
|
1
2
3
|
012 |
如果这种行为不是你想要的，可以为Borg类添加__eq__和__hash__方法，使其更接近于单例模式的行为：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
class Borg(object): _shared_state = {} def __new__(cls, *args, **kwargs): obj = super(Borg,cls).__new__(cls, *args, **kwargs) obj.__dict__ = cls._shared_state return obj def __hash__(self): return 1 def __eq__(self, other): try: return self.__dict__ is other.__dict__ except: return Falseif __name__ == '__main__': class Example(Borg): pass a = Example() b = Example() c = Example() adict = {} j = 0 for i in a, b, c: adict[i] = j j += 1 for i in a, b, c: print adict[i] |
结果：
|
1
2
3
|
222 |
所有的实例都能当一个key使用了。
方法3
当你编写一个类的时候，某种机制会使用类名字，基类元组，类字典来创建一个类对象。新型类中这种机制默认为type，而且这种机制是可编程的，称为元类__metaclass__ 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class Singleton(type): def __init__(self, name, bases, class_dict): super(Singleton,self).__init__(name, bases, class_dict) self._instance = None def __call__(self, *args, **kwargs): if self._instance is None: self._instance = super(Singleton,self).__call__(*args, **kwargs) return self._instanceif __name__ == '__main__': class A(object): __metaclass__ = Singleton a = A() b = A() print id(a), id(b) |
结果：
|
1
|
34248016 34248016 |
id是相同的。
例子中我们构造了一个Singleton元类，并使用__call__方法使其能够模拟函数的行为。构造类A时，将其元类设为Singleton，那么创建类对象A时，行为发生如下：
A=Singleton(name,bases,class_dict),A其实为Singleton类的一个实例。
创建A的实例时，A()=Singleton(name,bases,class_dict)()=Singleton(name,bases,class_dict).__call__()，这样就将A的所有实例都指向了A的属性_instance上，这种方法与方法1其实是相同的。
方法4
python中的模块module在程序中只被加载一次，本身就是单例的。可以直接写一个模块，将你需要的方法和属性，写在模块中当做函数和模块作用域的全局变量即可，根本不需要写类。
而且还有一些综合模块和类的优点的方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class _singleton(object): class ConstError(TypeError): pass def __setattr__(self, name, value): if name in self.__dict__: raise self.ConstError self.__dict__[name] = value def __delattr__(self, name): if name in self.__dict__: raise self.ConstError raise NameErrorimport syssys.modules[__name__] = _singleton() |
python并不会对sys.modules进行检查以确保他们是模块对象，我们利用这一点将模块绑定向一个类对象，而且以后都会绑定向同一个对象了。
将代码存放在single.py中：
|
1
2
3
4
5
6
|
>>> import single>>> single.a=1>>> single.a=2ConstError>>> del single.aConstError |
方法5
最简单的方法：
|
1
2
3
|
class singleton(object): passsingleton = singleton() |
将名字singleton绑定到实例上，singleton就是它自己类的唯一对象了。
更多
#-*- encoding=utf-8 -*- print '----------------------方法1--------------------------' #方法1,实现__new__方法 #并在将一个类的实例绑定到类变量_instance上, #如果cls._instance为None说明该类还没有实例化过,实例化该类,并返回 #如果cls._instance不为None,直接返回cls._instance class Singleton(object): def __new__(cls, *args, **kw): if not hasattr(cls, '_instance'): orig = super(Singleton, cls) cls._instance = orig.__new__(cls, *args, **kw) return cls._instance class MyClass(Singleton): a = 1 one = MyClass() two = MyClass() two.a = 3 print one.a #3 #one和two完全相同,可以用id(), ==, is检测 print id(one) #29097904 print id(two) #29097904 print one == two #True print one is two #True print '----------------------方法2--------------------------' #方法2,共享属性;所谓单例就是所有引用(实例、对象)拥有相同的状态(属性)和行为(方法) #同一个类的所有实例天然拥有相同的行为(方法), #只需要保证同一个类的所有实例具有相同的状态(属性)即可 #所有实例共享属性的最简单最直接的方法就是__dict__属性指向(引用)同一个字典(dict) #可参看:http://code.activestate.com/recipes/66531/ class Borg(object): _state = {} def __new__(cls, *args, **kw): ob = super(Borg, cls).__new__(cls, *args, **kw) ob.__dict__ = cls._state return ob class MyClass2(Borg): a = 1 one = MyClass2() two = MyClass2() #one和two是两个不同的对象,id, ==, is对比结果可看出 two.a = 3 print one.a #3 print id(one) #28873680 print id(two) #28873712 print one == two #False print one is two #False #但是one和two具有相同的（同一个__dict__属性）,见: print id(one.__dict__) #30104000 print id(two.__dict__) #30104000 print '----------------------方法3--------------------------' #方法3:本质上是方法1的升级（或者说高级）版 #使用__metaclass__（元类）的高级python用法 class Singleton2(type): def __init__(cls, name, bases, dict): super(Singleton2, cls).__init__(name, bases, dict) cls._instance = None def __call__(cls, *args, **kw): if cls._instance is None: cls._instance = super(Singleton2, cls).__call__(*args, **kw) return cls._instance class MyClass3(object): __metaclass__ = Singleton2 one = MyClass3() two = MyClass3() two.a = 3 print one.a #3 print id(one) #31495472 print id(two) #31495472 print one == two #True print one is two #True print '----------------------方法4--------------------------' #方法4:也是方法1的升级（高级）版本, #使用装饰器(decorator), #这是一种更pythonic,更elegant的方法, #单例类本身根本不知道自己是单例的,因为他本身(自己的代码)并不是单例的 def singleton(cls, *args, **kw): instances = {} def _singleton(): if cls not in instances: instances[cls] = cls(*args, **kw) return instances[cls] return _singleton @singleton class MyClass4(object): a = 1 def __init__(self, x=0): self.x = x one = MyClass4() two = MyClass4() two.a = 3 print one.a #3 print id(one) #29660784 print id(two) #29660784 print one == two #True print one is two #True one.x = 1 print one.x #1 print two.x #1