方法1
如果想使得某个类从始至终最多只有一个实例，使用__new__方法会很简单。python中类是通过__new__来创建实例的：
class singleton(object): def __new__(cls,*args,**kwargs): if not hasattr(cls,'_inst'): cls._inst=super(singleton,cls).__new__(cls,*args,**kwargs) return cls._inst if __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
结果：
29922256 banana
29922256 banana
通过__new__方法，将类的实例在创建的时候绑定到类属性_inst上。如果cls._inst为none，说明类还未实例化，实例化并将实例绑定到cls._inst，以后每次实例化的时候都返回第一次实例化创建的实例。注意从singleton派生子类的时候，不要重载__new__。
方法2：
有时候我们并不关心生成的实例是否具有同一id，而只关心其状态和行为方式。我们可以允许许多个实例被创建，但所有
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：
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]
结果：
0
1
2
如果这种行为不是你想要的，可以为borg类添加__eq__和__hash__方法，使其更接近于单例模式的行为：
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 false 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]
结果：
2
2
2
所有的实例都能当一个key使用了。
方法3
当你编写一个类的时候，某种机制会使用类名字，基类元组，类字典来创建一个类对象。新型类中这种机制默认为type，而且这种机制是可编程的，称为元类__metaclass__ 。
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._instance if __name__=='__main__': class a(object): __metaclass__=singleton a=a() b=a() print id(a),id(b)
结果：
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在程序中只被加载一次，本身就是单例的。可以直接写一个模块，将你需要的方法和属性，写在模块中当做函数和模块作用域的全局变量即可，根本不需要写类。
而且还有一些综合模块和类的优点的方法：
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 nameerror import sys sys.modules[__name__]=_singleton()
python并不会对sys.modules进行检查以确保他们是模块对象，我们利用这一点将模块绑定向一个类对象，而且以后都会绑定向同一个对象了。
将代码存放在single.py中：
>>> import single >>> single.a=1 >>> single.a=2
consterror
>>> del single.a
consterror
方法5
最简单的方法：
class singleton(object): pass singleton=singleton()
将名字singleton绑定到实例上，singleton就是它自己类的唯一对象了。