單例模式是一個軟件的設計模式，為了保證一個類，無論調用多少次產生的實例對象，都是指向同一個內存地址，僅僅只有一個實例(只有一個對象)。
實現(xiàn)單例模式的手段有很多種，但總的原則是保證一個類只要實例化一個對象，下一次再實例的時候就直接返回這個對象，不再做實例化的操作。所以這里面的關鍵一點就是，如何判斷這個類是否實例化過一個對象。
這里介紹兩類方式：
一類是通過模塊導入的方式;
一類是通過魔法方法判斷的方式;
#基本原理：
-第一類通過模塊導入的方式，借用了模塊導入時的底層原理實現(xiàn)。
-當一個模塊(py文件)被導入時，首先會執(zhí)行這個模塊的代碼，然后將這個模塊的名稱空間加載到內存。
-當這個模塊第二次再被導入時，不會再執(zhí)行該文件，而是直接在內存中找。
-于是，如果第一次導入模塊，執(zhí)行文件源代碼時實例化了一個類，那再次導入的時候，就不會再實例化。
-第二類主要是基于類和元類實現(xiàn)，在'對象'的魔法方法中判斷是否已經實例化過一個對象
-這類方式，根據實現(xiàn)的手法不同，又分為不同的方法，如：
-通過類的綁定方法;通過元類;通過類下的__new__;通過裝飾器(函數(shù)裝飾器，類裝飾器)實現(xiàn)等。
下面分別介紹這幾種不同的實現(xiàn)方式，僅供參考實現(xiàn)思路，不做具體需求。
通過模塊導入
#cls_singleton.py
classFoo(object):
pass
instance=Foo()
#test.py
importcls_singleton
obj1=cls_singleton.instance
obj2=cls_singleton.instance
print(obj1isobj2)
#原理：模塊第二次導入從內存找的機制
通過類的綁定方法
classStudent:
_instance=None#記錄實例化對象
def__init__(self,name,age):
self.name=name
self.age=age
@classmethod
defget_singleton(cls,*args,**kwargs):
ifnotcls._instance:
cls._instance=cls(*args,**kwargs)
returncls._instance
stu1=Student.get_singleton('jack',18)
stu2=Student.get_singleton('jack',18)
print(stu1isstu2)
print(stu1.__dict__,stu2.__dict__)
#原理：類的綁定方法是第二種實例化對象的方式，
#第一次實例化的對象保存成類的數(shù)據屬性_instance，
#第二次再實例化時，在get_singleton中判斷已經有了實例對象，直接返回類的數(shù)據屬性_instance
通過魔法方法__new__
classStudent:
_instance=None
def__init__(self,name,age):
self.name=name
self.age=age
def__new__(cls,*args,**kwargs):
#ifcls._instance:
#returncls._instance#有實例則直接返回
#else:
#cls._instance=super().__new__(cls)#沒有實例則new一個并保存
#returncls._instance#這個返回是給是給init，再實例化一次，也沒有關系
ifnotcls._instance:#這是簡化的寫法，上面注釋的寫法更容易提現(xiàn)判斷思路
cls._instance=super().__new__(cls)
returncls._instance
stu1=Student('jack',18)
stu2=Student('jack',18)
print(stu1isstu2)
print(stu1.__dict__,stu2.__dict__)
#原理：和方法2類似，將判斷的實現(xiàn)方式，從類的綁定方法中轉移到類的__new__中
#歸根結底都是判斷類有沒有實例，有則直接返回，無則實例化并保存到_instance中。
通過元類
classMymeta(type):
def__init__(cls,name,bases,dic):
super().__init__(name,bases,dic)
cls._instance=None#將記錄類的實例對象的數(shù)據屬性放在元類中自動定義了
def__call__(cls,*args,**kwargs):#此call會在類被調用(即實例化時觸發(fā))
ifcls._instance:#判斷類有沒有實例化對象
returncls._instance
else:#沒有實例化對象時，控制類造空對象并初始化
obj=cls.__new__(cls,*args,**kwargs)
obj.__init__(*args,**kwargs)
cls._instance=obj#保存對象，下一次再實例化可以直接返回而不用再造對象
returnobj
classStudent(metaclass=Mymeta):
def__init__(self,name,age):
self.name=name
self.age=age
stu1=Student('jack',18)
stu2=Student('jack',18)
print(stu1isstu2)
print(stu1.__dict__,stu2.__dict__)
#原理：類定義時會調用元類下的__init__，類調用(實例化對象)時會觸發(fā)元類下的__call__方法
#類定義時，給類新增一個空的數(shù)據屬性，
#第一次實例化時，實例化之后就將這個對象賦值給類的數(shù)據屬性;第二次再實例化時，直接返回類的這個數(shù)據屬性
#和方式3的不同之處1：類的這個數(shù)據屬性是放在元類中自動定義的，而不是在類中顯示的定義的。
#和方式3的不同之處2：類調用時觸發(fā)元類__call__方法判斷是否有實例化對象，而不是在類的綁定方法中判斷
函數(shù)裝飾器
defsingleton(cls):
_instance_dict={}#采用字典，可以裝飾多個類，控制多個類實現(xiàn)單例模式
definner(*args,**kwargs):
ifclsnotin_instance_dict:
_instance_dict[cls]=cls(*args,**kwargs)
return_instance_dict.get(cls)
returninner
@singleton
classStudent:
def__init__(self,name,age):
self.name=name
self.age=age
#def__new__(cls,*args,**kwargs):#將方法3的這部分代碼搬到了函數(shù)裝飾器中
#ifnotcls._instance:
#cls._instance=super().__new__(cls)
#returncls._instan
stu1=Student('jack',18)
stu2=Student('jack',18)
print(stu1isstu2)
print(stu1.__dict__,stu2.__dict__)
類裝飾器
classSingleTon:
_instance_dict={}
def__init__(self,cls_name):
self.cls_name=cls_name
def__call__(self,*args,**kwargs):
ifself.cls_namenotinSingleTon._instance_dict:
SingleTon._instance_dict[self.cls_name]=self.cls_name(*args,**kwargs)
returnSingleTon._instance_dict.get(self.cls_name)
@SingleTon#這個語法糖相當于Student=SingleTon(Student),即Student是SingleTon的實例對象
classStudent:
def__init__(self,name,age):
self.name=name
self.age=age
stu1=Student('jack',18)
stu2=Student('jack',18)
print(stu1isstu2)
print(stu1.__dict__,stu2.__dict__)
#原理：在函數(shù)裝飾器的思路上，將裝飾器封裝成類。
#程序執(zhí)行到與語法糖時，會實例化一個Student對象，這個對象是SingleTon的對象。
#后面使用的Student本質上使用的是SingleTon的對象。
#所以使用Student('jack',18)來實例化對象，其實是在調用SingleTon的對象，會觸發(fā)其__call__的執(zhí)行
#所以就在__call__中，判斷Student類有沒有實例對象了。
以上內容為大家介紹了Python的6種方式實現(xiàn)單例模式，希望對大家有所幫助，如果想要了解更多Python相關知識，請關注IT培訓機構:千鋒教育。http://m.2667701.com/
京公網安備 11010802030320號