Python面向對象編程——元類
一、只是儲備
exec：三個參數
參數一：字符串形式的命令
參數二：全局作用域（字典形式），如果不指定，默認為globals()
參數三：局部作用域（字典形式），如果不指定，默認為locals()
exec的使用
#可以把exec命令的執行當成是一個函數的執行，會將執行期間產生的名字存放于局部名稱空間中
g={
'x':1,
'y':2
}
l={}
exec('''
global x,z
x=100
z=200
m=300
''',g,l)
print(g) #{'x': 100, 'y': 2,'z':200,......}
print(l) #{'m': 300}
二、引子（類也是對象）
class Foo:
pass
f1=Foo() #f1是通過Foo類實例化的對象
python中一切皆是對象，類本身也是一個對象，當使用關鍵字class的時候，python解釋器在加載class的時候就會創建一個對象(這里的對象指的是類而非類的實例)，因而我們可以將類當作一個對象去使用，同樣滿足第一類對象的概念，可以：
把類賦值給一個變量
把類作為函數參數進行傳遞
把類作為函數的返回值
在運行時動態地創建類
上例可以看出f1是由Foo這個類產生的對象，而Foo本身也是對象，那它又是由哪個類產生的呢？
#type函數可以查看類型，也可以用來查看對象的類，二者是一樣的
print(type(f1)) # 輸出：
表示，obj 對象由Foo類創建
print(type(Foo)) # 輸出：
三、什么是元類
元類是類的類，是類的模板。
元類是用來控制如何創建類的，正如類是創建對象的模板一樣，而元類的主要目的是為了控制類的創建行為
元類的實例化的結果為我們用class定義的類，正如類的實例為對象(f1對象是Foo類的一個實例，Foo類是 type 類的一個實例)
type是python的一個內建元類，用來直接控制生成類，python中任何class定義的類其實都是type類實例化的對象。
四、創建類的兩種方式
方式一：使用class關鍵字
class Chinese(object):
country='China'
def __init__(self,name,age):
self.name=name
self.age=age
def talk(self):
print('%s is talking' %self.name)
方式二：就是手動模擬class創建類的過程）：將創建類的步驟拆分開，手動去創建
#準備工作：
#創建類主要分為三部分
1 類名
2 類的父類
3 類體
#類名
class_name='Chinese'
#類的父類
class_bases=(object,)
#類體
class_body="""
country='China'
def __init__(self,name,age):
self.name=name
self.age=age
def talk(self):
print('%s is talking' %self.name)
"""
步驟一（先處理類體->名稱空間）：類體定義的名字都會存放于類的名稱空間中（一個局部的名稱空間），我們可以事先定義一個空字典，然后用exec去執行類體的代碼（exec產生名稱空間的過程與真正的class過程類似，只是后者會將__開頭的屬性變形），生成類的局部名稱空間，即填充字典。
class_dic={}
exec(class_body,globals(),class_dic)
print(class_dic)
#{'country': 'China', 'talk':
, '__init__':
}
步驟二：調用元類type（也可以自定義）來產生類Chinense。
Foo=type(class_name,class_bases,class_dic) #實例化type得到對象Foo，即我們用class定義的類Foo
print(Foo)
print(type(Foo))
print(isinstance(Foo,type))
'''
True
'''
我們看到，type 接收三個參數：
- 第 1 個參數是字符串 ‘Foo’，表示類名
- 第 2 個參數是元組 (object, )，表示所有的父類
- 第 3 個參數是字典，這里是一個空字典，表示沒有定義屬性和方法
補充：若Foo類有繼承，即class Foo(Bar):.... 則等同于type('Foo',(Bar,),{})
五、自定義元類控制類的行為
#一個類沒有聲明自己的元類，默認他的元類就是type，除了使用元類type，用戶也可以通過繼承type來自定義元類（順便我們也可以瞅一瞅元類如何控制類的行為，工作流程是什么）
5步帶你學會元類（來自egon老師）
#知識儲備：
#產生的新對象 = object.__new__(繼承object類的子類)
#步驟一：如果說People=type(類名,類的父類們,類的名稱空間)，那么我們定義元類如下，來控制類的創建
class Mymeta(type): # 繼承默認元類的一堆屬性
def __init__(self, class_name, class_bases, class_dic):
if '__doc__' not in class_dic or not class_dic.get('__doc__').strip():
raise TypeError('必須為類指定文檔注釋')
if not class_name.istitle():
raise TypeError('類名首字母必須大寫')
super(Mymeta, self).__init__(class_name, class_bases, class_dic)
class People(object, metaclass=Mymeta):
country = 'China'
def __init__(self, name, age):
self.name = name
self.age = age
def talk(self):
print('%s is talking' % self.name)
#步驟二：如果我們想控制類實例化的行為，那么需要先儲備知識__call__方法的使用
class People(object,metaclass=type):
def __init__(self,name,age):
self.name=name
self.age=age
def __call__(self, *args, **kwargs):
print(self,args,kwargs)
# 調用類People，并不會出發__call__
obj=People('egon',18)
# 調用對象obj(1,2,3,a=1,b=2,c=3)，才會出發對象的綁定方法obj.__call__(1,2,3,a=1,b=2,c=3)
obj(1,2,3,a=1,b=2,c=3) #打印：<__main__.People object at 0x10076dd30> (1, 2, 3) {'a': 1, 'b': 2, 'c': 3}
#總結：如果說類People是元類type的實例，那么在元類type內肯定也有一個__call__，會在調用People('egon',18)時觸發執行，然后返回一個初始化好了的對象obj
#步驟三：自定義元類，控制類的調用（即實例化）的過程
class Mymeta(type): #繼承默認元類的一堆屬性
def __init__(self,class_name,class_bases,class_dic):
if not class_name.istitle():
raise TypeError('類名首字母必須大寫')
super(Mymeta,self).__init__(class_name,class_bases,class_dic)
def __call__(self, *args, **kwargs):
#self=People
print(self,args,kwargs) #
('egon', 18) {}
#1、實例化People，產生空對象obj
obj=object.__new__(self)
#2、調用People下的函數__init__，初始化obj
self.__init__(obj,*args,**kwargs)
#3、返回初始化好了的obj
return obj
class People(object,metaclass=Mymeta):
country='China'
def __init__(self,name,age):
self.name=name
self.age=age
def talk(self):
print('%s is talking' %self.name)
obj=People('egon',18)
print(obj.__dict__) #{'name': 'egon', 'age': 18}
#步驟四：
class Mymeta(type): #繼承默認元類的一堆屬性
def __init__(self,class_name,class_bases,class_dic):
if not class_name.istitle():
raise TypeError('類名首字母必須大寫')
super(Mymeta,self).__init__(class_name,class_bases,class_dic)
def __call__(self, *args, **kwargs):
#self=People
print(self,args,kwargs) #
('egon', 18) {}
#1、調用self，即People下的函數__new__，在該函數內完成：1、產生空對象obj 2、初始化 3、返回obj
obj=self.__new__(self,*args,**kwargs)
#2、一定記得返回obj，因為實例化People(...)取得就是__call__的返回值
return obj
class People(object,metaclass=Mymeta):
country='China'
def __init__(self,name,age):
self.name=name
self.age=age
def talk(self):
print('%s is talking' %self.name)
def __new__(cls, *args, **kwargs):
obj=object.__new__(cls)
cls.__init__(obj,*args,**kwargs)
return obj
obj=People('egon',18)
print(obj.__dict__) #{'name': 'egon', 'age': 18}
#步驟五：基于元類實現單例模式,比如數據庫對象,實例化時參數都一樣,就沒必要重復產生對象,浪費內存
class Mysql:
__instance=None
def __init__(self,host='127.0.0.1',port='3306'):
self.host=host
self.port=port
@classmethod
def singleton(cls,*args,**kwargs):
if not cls.__instance:
cls.__instance=cls(*args,**kwargs)
return cls.__instance
obj1=Mysql()
obj2=Mysql()
print(obj1 is obj2) #False
obj3=Mysql.singleton()
obj4=Mysql.singleton()
print(obj3 is obj4) #True
#應用：定制元類實現單例模式
class Mymeta(type):
def __init__(self,name,bases,dic): #定義類Mysql時就觸發
self.__instance=None
super().__init__(name,bases,dic)
def __call__(self, *args, **kwargs): #Mysql(...)時觸發
if not self.__instance:
self.__instance=object.__new__(self) #產生對象
self.__init__(self.__instance,*args,**kwargs) #初始化對象
#上述兩步可以合成下面一步
# self.__instance=super().__call__(*args,**kwargs)
return self.__instance
class Mysql(metaclass=Mymeta):
def __init__(self,host='127.0.0.1',port='3306'):
self.host=host
self.port=port
obj1=Mysql()
obj2=Mysql()
print(obj1 is obj2)
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
