Python 单例模式详解 __new__, import ,__dict__,__metaclass__
来源:互联网 发布:入侵网站数据库 编辑:程序博客网 时间:2024/06/05 08:19
定义:
单例模式:保证一个类仅有一个实例,并提供一个访问他的全局访问点。
实现某个类只有一个实例的途径:
1,让一个全局变量使得一个对象被访问,但是他不能防止外部实例化多个对象。
2,让类自身保存他的唯一实例,这个类可以保证没有其他实例可以被创建
#-*- 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,有时候我们并不关心生成的实例是否具有同一id,而只关心其状态和行为方式。我们可以允许许多个实例被创建, # 但所有的实例都共享状态和行为方式共享属性;所谓单例就是所有引用(实例、对象)拥有相同的状态(属性)和行为(方法) #同一个类的所有实例天然拥有相同的行为(方法), #只需要保证同一个类的所有实例具有相同的状态(属性)即可 #所有实例共享属性的最简单最直接的方法就是__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 '''将所有实例的__dict__指向同一个字典,这样实例就共享相同的方法和属性。对任何实例的名字属性的设置,无论是在__init__中修改还是直接修改,所有的实例都会受到影响。不过实例的id是不同的。要保证类实例能共享属性,但不和子类共享,注意使用cls._shared_state,而不是Borg._shared_state。因为实例是不同的id,所以每个实例都可以做字典的key: ''' 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 print '----------------------方法5--------------------------' '''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 NameErrorimport syssys.modules[__name__]=_singleton()python并不会对sys.modules进行检查以确保他们是模块对象,我们利用这一点将模块绑定向一个类对象,而且以后都会绑定向同一个对象了。将代码存放在single.py中:>>> import single>>> single.a=1>>> single.a=2ConstError>>> del single.aConstErrorprint '----------------------方法5--------------------------' '''当你编写一个类的时候,某种机制会使用类名字,基类元组,类字典来创建一个类对象。新型类中这种机制默认为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._instanceif __name__=='__main__': class A(object): __metaclass__=Singleton a=A() b=A() print id(a),id(b) ''' 结果:34248016 34248016id是相同的。例子中我们构造了一个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其实是相同的。 '''
多线程时的单例模式:加锁-双重锁定
饿汉式单例类:在类被加载时就将自己实例化(静态初始化)。其优点是躲避了多线程访问的安全性问题,缺点是提前占用系统资源。
懒汉式单例类:在第一次被引用时,才将自己实例化。避免开始时占用系统资源,但是有多线程访问安全性问题。
import threading# 单例类class Singleton(): instance = None mutex = threading.Lock() def _init__(self): pass @staticmethod def GetInstance(): if (Singleton.instance == None): Singleton.mutex.acquire() if (Singleton.instance == None): PrintInfo('初始化实例') Singleton.instance = Singleton() else: PrintInfo('单例已经实例化!') Singleton.mutex.release() else: PrintInfo('单例已经实例化') return Singleton.instancedef clientUI(): Singleton.GetInstance() Singleton.GetInstance() Singleton.GetInstance() returnif __name__ == '__main__': clientUI();
0 0
- Python 单例模式详解 __new__, import ,__dict__,__metaclass__
- Python 3.6 单例模式 __new__实现
- python实现单例模式__init__ __new__区别
- 使用 __new__ 实现 Python 的单例模式
- 由单例模式看python类的__new__方法
- Python __new__, __init__, __metaclass__, __call__, __del__, __getattr__, __getattribute__
- Python通过__new__实现单例设计
- python中类的学习:类属性,实例属性 __new__方法:单例模式
- python基础-单例模式、__new__方法、利用new构造对象
- 详解python中的__new__方法
- python __new__ __init__ __call__详解
- python __dict__
- python中7种实现单例模式的方法:staticmethod、classmethod、类属性方法、__new__、装饰器、元类、名字覆盖
- Python学习之单例模式详解
- python元类__metaclass__
- python当中__metaclass__探讨
- python __metaclass__ metaclass
- 详解Python中的__init__和__new__
- 文字识别的代码
- OSG嵌入MFC多文档例子
- android笔记之可拖动的不要权限的悬浮框
- 微信小程序学习篇(一)
- dd命令选项参数
- Python 单例模式详解 __new__, import ,__dict__,__metaclass__
- 变量声明-TS学习笔记(2)
- CString,string,char*之间的转换
- Eclipse下android的R文件不生成最全终极解决办法
- linux kernel errno
- java Date SimpleDateFormate日期时间格式 Calendar
- 斐波那契数列[剑指offer]之python实现
- java集合(4)——map的一些应用
- 字节流和字符流的区别