一 前言
元類屬於python面向對象編程的深層魔法，99%的人都不得要領，一些自以為搞明白元類的人其實也只是自圓其說、點到為止，從對元類的控制上來看就破綻百出、邏輯混亂，今天我就來帶大家來深度了解python元類的來龍去脈。
筆者深入淺出的背后是對技術一日復一日的執念，希望可以大家可以尊重原創，為大家能因此文而解開對元類所有的疑惑而感到開心！！！
二 什么是元類
一切源自於一句話：python中一切皆為對象。讓我們先定義一個類，然后逐步分析
class OldboyTeacher(object): school='oldboy' def __init__(self,name,age): self.name=name self.age=age def say(self): print('%s says welcome to the oldboy to learn Python' %self.name)
所有的對象都是實例化或者說調用類而得到的（調用類的過程稱為類的實例化），比如對象t1是調用類OldboyTeacher得到的
t1=OldboyTeacher('egon',18) print(type(t1)) #查看對象t1的類是<class '__main__.OldboyTeacher'>
如果一切皆為對象，那么類OldboyTeacher本質也是一個對象，既然所有的對象都是調用類得到的，那么OldboyTeacher必然也是調用了一個類得到的，這個類稱為元類
於是我們可以推導出===>產生OldboyTeacher的過程一定發生了：OldboyTeacher=元類(...)
print(type(OldboyTeacher)) # 結果為<class 'type'>，證明是調用了type這個元類而產生的OldboyTeacher，即默認的元類為type
三 class關鍵字創建類的流程分析
上文我們基於python中一切皆為對象的概念分析出：我們用class關鍵字定義的類本身也是一個對象，負責產生該對象的類稱之為元類（元類可以簡稱為類的類），內置的元類為type
class關鍵字在幫我們創建類時，必然幫我們調用了元類OldboyTeacher=type(...)，那調用type時傳入的參數是什么呢？必然是類的關鍵組成部分，一個類有三大組成部分，分別是
1、類名class_name='OldboyTeacher'
2、基類們class_bases=(object,)
3、類的名稱空間class_dic，類的名稱空間是執行類體代碼而得到的
調用type時會依次傳入以上三個參數
綜上，class關鍵字幫我們創建一個類應該細分為以下四個過程
補充：exec的用法
#exec：三個參數 #參數一：包含一系列python代碼的字符串 #參數二：全局作用域（字典形式），如果不指定，默認為globals() #參數三：局部作用域（字典形式），如果不指定，默認為locals() #可以把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}
五 自定義元類控制類OldboyTeacher的創建
一個類沒有聲明自己的元類，默認他的元類就是type，除了使用內置元類type，我們也可以通過繼承type來自定義元類，然后使用metaclass關鍵字參數為一個類指定元類
class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類 pass class OldboyTeacher(object,metaclass=Mymeta): # OldboyTeacher=Mymeta('OldboyTeacher',(object),{...}) school='oldboy' def __init__(self,name,age): self.name=name self.age=age def say(self): print('%s says welcome to the oldboy to learn Python' %self.name)
自定義元類可以控制類的產生過程，類的產生過程其實就是元類的調用過程,即OldboyTeacher=Mymeta('OldboyTeacher',(object),{...})，調用Mymeta會先產生一個空對象OldoyTeacher，然后連同調用Mymeta括號內的參數一同傳給Mymeta下的__init__方法，完成初始化，於是我們可以
class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類 def __init__(self,class_name,class_bases,class_dic): # print(self) #<class '__main__.OldboyTeacher'> # print(class_bases) #(<class 'object'>,) # print(class_dic) #{'__module__': '__main__', '__qualname__': 'OldboyTeacher', 'school': 'oldboy', '__init__': <function OldboyTeacher.__init__ at 0x102b95ae8>, 'say': <function OldboyTeacher.say at 0x10621c6a8>} super(Mymeta, self).__init__(class_name, class_bases, class_dic) # 重用父類的功能 if class_name.islower(): raise TypeError('類名%s請修改為駝峰體' %class_name) if '__doc__' not in class_dic or len(class_dic['__doc__'].strip(' \n')) == 0: raise TypeError('類中必須有文檔注釋，並且文檔注釋不能為空') class OldboyTeacher(object,metaclass=Mymeta): # OldboyTeacher=Mymeta('OldboyTeacher',(object),{...}) """ 類OldboyTeacher的文檔注釋 """ school='oldboy' def __init__(self,name,age): self.name=name self.age=age def say(self): print('%s says welcome to the oldboy to learn Python' %self.name)
六 自定義元類控制類OldboyTeacher的調用
儲備知識：__call__
class Foo: def __call__(self, *args, **kwargs): print(self) print(args) print(kwargs) obj=Foo() #1、要想讓obj這個對象變成一個可調用的對象，需要在該對象的類中定義一個方法__call__方法，該方法會在調用對象時自動觸發 #2、調用obj的返回值就是__call__方法的返回值 res=obj(1,2,3,x=1,y=2)
由上例得知，調用一個對象，就是觸發對象所在類中的__call__方法的執行，如果把OldboyTeacher也當做一個對象，那么在OldboyTeacher這個對象的類中也必然存在一個__call__方法
class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類 def __call__(self, *args, **kwargs): print(self) #<class '__main__.OldboyTeacher'> print(args) #('egon', 18) print(kwargs) #{} return 123 class OldboyTeacher(object,metaclass=Mymeta): school='oldboy' def __init__(self,name,age): self.name=name self.age=age def say(self): print('%s says welcome to the oldboy to learn Python' %self.name) # 調用OldboyTeacher就是在調用OldboyTeacher類中的__call__方法 # 然后將OldboyTeacher傳給self,溢出的位置參數傳給*，溢出的關鍵字參數傳給** # 調用OldboyTeacher的返回值就是調用__call__的返回值 t1=OldboyTeacher('egon',18) print(t1) #123
默認地，調用t1=OldboyTeacher('egon',18)會做三件事
1、產生一個空對象obj
2、調用__init__方法初始化對象obj
3、返回初始化好的obj
對應着，OldboyTeacher類中的__call__方法也應該做這三件事
class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類 def __call__(self, *args, **kwargs): #self=<class '__main__.OldboyTeacher'> #1、調用__new__產生一個空對象obj obj=self.__new__(self) # 此處的self是類OldoyTeacher，必須傳參，代表創建一個OldboyTeacher的對象obj #2、調用__init__初始化空對象obj self.__init__(obj,*args,**kwargs) #3、返回初始化好的對象obj return obj class OldboyTeacher(object,metaclass=Mymeta): school='oldboy' def __init__(self,name,age): self.name=name self.age=age def say(self): print('%s says welcome to the oldboy to learn Python' %self.name) t1=OldboyTeacher('egon',18) print(t1.__dict__) #{'name': 'egon', 'age': 18}
上例的__call__相當於一個模板，我們可以在該基礎上改寫__call__的邏輯從而控制調用OldboyTeacher的過程，比如將OldboyTeacher的對象的所有屬性都變成私有的
class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類 def __call__(self, *args, **kwargs): #self=<class '__main__.OldboyTeacher'> #1、調用__new__產生一個空對象obj obj=self.__new__(self) # 此處的self是類OldoyTeacher，必須傳參，代表創建一個OldboyTeacher的對象obj #2、調用__init__初始化空對象obj self.__init__(obj,*args,**kwargs) # 在初始化之后，obj.__dict__里就有值了 obj.__dict__={'_%s__%s' %(self.__name__,k):v for k,v in obj.__dict__.items()} #3、返回初始化好的對象obj return obj class OldboyTeacher(object,metaclass=Mymeta): school='oldboy' def __init__(self,name,age): self.name=name self.age=age def say(self): print('%s says welcome to the oldboy to learn Python' %self.name) t1=OldboyTeacher('egon',18) print(t1.__dict__) #{'_OldboyTeacher__name': 'egon', '_OldboyTeacher__age': 18}
上例中涉及到查找屬性的問題，比如self.__new__，請看下一小節
六 再看屬性查找
結合python繼承的實現原理+元類重新看屬性的查找應該是什么樣子呢？？？
在學習完元類后，其實我們用class自定義的類也全都是對象（包括object類本身也是元類type的 一個實例，可以用type(object)查看），我們學習過繼承的實現原理，如果把類當成對象去看，將下述繼承應該說成是：對象OldboyTeacher繼承對象Foo，對象Foo繼承對象Bar，對象Bar繼承對象object
class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類 n=444 def __call__(self, *args, **kwargs): #self=<class '__main__.OldboyTeacher'> obj=self.__new__(self) self.__init__(obj,*args,**kwargs) return obj class Bar(object): n=333 class Foo(Bar): n=222 class OldboyTeacher(Foo,metaclass=Mymeta): n=111 school='oldboy' def __init__(self,name,age): self.name=name self.age=age def say(self): print('%s says welcome to the oldboy to learn Python' %self.name) print(OldboyTeacher.n) #自下而上依次注釋各個類中的n=xxx，然后重新運行程序，發現n的查找順序為OldboyTeacher->Foo->Bar->object->Mymeta->type
於是屬性查找應該分成兩層，一層是對象層（基於c3算法的MRO）的查找，另外一個層則是類層（即元類層）的查找
#查找順序： #1、先對象層：OldoyTeacher->Foo->Bar->object #2、然后元類層：Mymeta->type
依據上述總結，我們來分析下元類Mymeta中__call__里的self.__new__的查找
class Mymeta(type): n=444 def __call__(self, *args, **kwargs): #self=<class '__main__.OldboyTeacher'> obj=self.__new__(self) print(self.__new__ is object.__new__) #True class Bar(object): n=333 # def __new__(cls, *args, **kwargs): # print('Bar.__new__') class Foo(Bar): n=222 # def __new__(cls, *args, **kwargs): # print('Foo.__new__') class OldboyTeacher(Foo,metaclass=Mymeta): n=111 school='oldboy' def __init__(self,name,age): self.name=name self.age=age def say(self): print('%s says welcome to the oldboy to learn Python' %self.name) # def __new__(cls, *args, **kwargs): # print('OldboyTeacher.__new__') OldboyTeacher('egon',18) #觸發OldboyTeacher的類中的__call__方法的執行，進而執行self.__new__開始查找
總結，Mymeta下的__call__里的self.__new__在OldboyTeacher、Foo、Bar里都沒有找到__new__的情況下，會去找object里的__new__，而object下默認就有一個__new__，所以即便是之前的類均未實現__new__,也一定會在object中找到一個，根本不會、也根本沒必要再去找元類Mymeta->type中查找__new__
我們在元類的__call__中也可以用object.__new__(self)去造對象
但我們還是推薦在__call__中使用self.__new__（self）去創造空對象，因為這種方式會檢索三個類OldboyTeacher->Foo->Bar,而object.__new__則是直接跨過了他們三個
最后說明一點
class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類 n=444 def __new__(cls, *args, **kwargs): obj=type.__new__(cls,*args,**kwargs) # 必須按照這種傳值方式 print(obj.__dict__) # return obj # 只有在返回值是type的對象時，才會觸發下面的__init__ return 123 def __init__(self,class_name,class_bases,class_dic): print('run。。。') class OldboyTeacher(object,metaclass=Mymeta): #OldboyTeacher=Mymeta('OldboyTeacher',(object),{...}) n=111 school='oldboy' def __init__(self,name,age): self.name=name self.age=age def say(self): print('%s says welcome to the oldboy to learn Python' %self.name) print(type(Mymeta)) #<class 'type'> # 產生類OldboyTeacher的過程就是在調用Mymeta，而Mymeta也是type類的一個對象，那么Mymeta之所以可以調用，一定是在元類type中有一個__call__方法 # 該方法中同樣需要做至少三件事： # class type: # def __call__(self, *args, **kwargs): #self=<class '__main__.Mymeta'> # obj=self.__new__(self,*args,**kwargs) # 產生Mymeta的一個對象 # self.__init__(obj,*args,**kwargs) # return obj
七 練習題
練習一：在元類中控制把自定義類的數據屬性都變成大寫
class Mymetaclass(type): def __new__(cls,name,bases,attrs): update_attrs={} for k,v in attrs.items(): if not callable(v) and not k.startswith('__'): update_attrs[k.upper()]=v else: update_attrs[k]=v return type.__new__(cls,name,bases,update_attrs) class Chinese(metaclass=Mymetaclass): country='China' tag='Legend of the Dragon' #龍的傳人 def walk(self): print('%s is walking' %self.name) print(Chinese.__dict__) ''' {'__module__': '__main__', 'COUNTRY': 'China', 'TAG': 'Legend of the Dragon', 'walk': <function Chinese.walk at 0x0000000001E7B950>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__doc__': None} '''
練習二：在元類中控制自定義的類無需__init__方法
1.元類幫其完成創建對象，以及初始化操作；
2.要求實例化時傳參必須為關鍵字形式，否則拋出異常TypeError: must use keyword argument
3.key作為用戶自定義類產生對象的屬性，且所有屬性變成大寫
class Mymetaclass(type): # def __new__(cls,name,bases,attrs): # update_attrs={} # for k,v in attrs.items(): # if not callable(v) and not k.startswith('__'): # update_attrs[k.upper()]=v # else: # update_attrs[k]=v # return type.__new__(cls,name,bases,update_attrs) def __call__(self, *args, **kwargs): if args: raise TypeError('must use keyword argument for key function') obj = object.__new__(self) #創建對象，self為類Foo for k,v in kwargs.items(): obj.__dict__[k.upper()]=v return obj class Chinese(metaclass=Mymetaclass): country='China' tag='Legend of the Dragon' #龍的傳人 def walk(self): print('%s is walking' %self.name) p=Chinese(name='egon',age=18,sex='male') print(p.__dict__)
練習三：在元類中控制自定義的類產生的對象相關的屬性全部為隱藏屬性
class Mymeta(type): def __init__(self,class_name,class_bases,class_dic): #控制類Foo的創建 super(Mymeta,self).__init__(class_name,class_bases,class_dic) def __call__(self, *args, **kwargs): #控制Foo的調用過程，即Foo對象的產生過程 obj = self.__new__(self) self.__init__(obj, *args, **kwargs) obj.__dict__={'_%s__%s' %(self.__name__,k):v for k,v in obj.__dict__.items()} return obj class Foo(object,metaclass=Mymeta): # Foo=Mymeta(...) def __init__(self, name, age,sex): self.name=name self.age=age self.sex=sex obj=Foo('egon',18,'male') print(obj.__dict__)
練習四：基於元類實現單例模式
#步驟五：基於元類實現單例模式 # 單例：即單個實例，指的是同一個類實例化多次的結果指向同一個對象，用於節省內存空間 # 如果我們從配置文件中讀取配置來進行實例化，在配置相同的情況下，就沒必要重復產生對象浪費內存了 #settings.py文件內容如下 HOST='1.1.1.1' PORT=3306 #方式一:定義一個類方法實現單例模式 import settings class Mysql: __instance=None def __init__(self,host,port): self.host=host self.port=port @classmethod def singleton(cls): if not cls.__instance: cls.__instance=cls(settings.HOST,settings.PORT) return cls.__instance obj1=Mysql('1.1.1.2',3306) obj2=Mysql('1.1.1.3',3307) print(obj1 is obj2) #False obj3=Mysql.singleton() obj4=Mysql.singleton() print(obj3 is obj4) #True #方式二：定制元類實現單例模式 import settings class Mymeta(type): def __init__(self,name,bases,dic): #定義類Mysql時就觸發 # 事先先從配置文件中取配置來造一個Mysql的實例出來 self.__instance = object.__new__(self) # 產生對象 self.__init__(self.__instance, settings.HOST, settings.PORT) # 初始化對象 # 上述兩步可以合成下面一步 # self.__instance=super().__call__(*args,**kwargs) super().__init__(name,bases,dic) def __call__(self, *args, **kwargs): #Mysql(...)時觸發 if args or kwargs: # args或kwargs內有值 obj=object.__new__(self) self.__init__(obj,*args,**kwargs) return obj return self.__instance class Mysql(metaclass=Mymeta): def __init__(self,host,port): self.host=host self.port=port obj1=Mysql() # 沒有傳值則默認從配置文件中讀配置來實例化，所有的實例應該指向一個內存地址 obj2=Mysql() obj3=Mysql() print(obj1 is obj2 is obj3) obj4=Mysql('1.1.1.4',3307) #方式三:定義一個裝飾器實現單例模式 import settings def singleton(cls): #cls=Mysql _instance=cls(settings.HOST,settings.PORT) def wrapper(*args,**kwargs): if args or kwargs: obj=cls(*args,**kwargs) return obj return _instance return wrapper @singleton # Mysql=singleton(Mysql) class Mysql: def __init__(self,host,port): self.host=host self.port=port obj1=Mysql() obj2=Mysql() obj3=Mysql() print(obj1 is obj2 is obj3) #True obj4=Mysql('1.1.1.3',3307) obj5=Mysql('1.1.1.4',3308) print(obj3 is obj4) #False