目錄
- 一、引言
- 二、什么是元類
- 三、為什么用元類
- 四、內置函數exec(儲備)
- 五、class創建類
- 5.1 type實現
- 六、自定義元類控制類的創建
- 6.1 應用
- 七、__call__(儲備)
- 八、__new__(儲備)
- 九、自定義元類控制類的實例化
- 一十、自定義元類后類的繼承順序
- 十一、練習
一、引言
元類屬于python面向對象編程的深層魔法，99%的人都不得要領，一些自以為搞明白元類的人其實也只是自圓其說、點到為止，從對元類的控制上來看就破綻百出、邏輯混亂，今天我就來帶大家來深度了解python元類的來龍去脈。
筆者深入淺出的背后是對技術一日復一日的執念，希望可以大家可以尊重原創，為大家能因此文而解開對元類所有的疑惑而感到開心！！！
二、什么是元類
- 在python中一切皆對象，那么我們用class關鍵字定義的類本身也是一個對象，負責產生該對象的類稱之為元類，即元類可以簡稱為類的類
class Foo: # Foo=元類()pass
三、為什么用元類
- 元類是負責產生類的，所以我們學習元類或者自定義元類的目的：是為了控制類的產生過程，還可以控制對象的產生過程
四、內置函數exec(儲備)
cmd = """
x=1
print('exec函數運行了')
def func(self):pass
"""
class_dic = {}
# 執行cmd中的代碼，然后把產生的名字丟入class_dic字典中
exec(cmd, {}, class_dic)exec函數運行了print(class_dic){'x': 1, 'func': <function func at 0x10a0bc048>}五、class創建類
如果說類也是對象，那么用class關鍵字的去創建類的過程也是一個實例化的過程，該實例化的目的是為了得到一個類，調用的是元類
用class關鍵字創建一個類，用的默認的元類type，因此以前說不要用type作為類別判斷
class People: # People=type(...)country = 'China'def __init__(self, name, age):self.name = nameself.age = agedef eat(self):print('%s is eating' % self.name)print(type(People))<class 'type'>
5.1 type實現
創建類的3個要素：類名，基類，類的名稱空間
People = type(類名，基類，類的名稱空間)
class_name = 'People' # 類名class_bases = (object, ) # 基類# 類的名稱空間
class_dic = {}
class_body = """
country='China'
def __init__(self,name,age):self.name=nameself.age=age
def eat(self):print('%s is eating' %self.name)
"""exec(class_body,{},class_dic,
)print(class_name)Peopleprint(class_bases)(<class 'object'>,)print(class_dic) # 類的名稱空間{'country': 'China', '__init__': <function __init__ at 0x10a0bc048>, 'eat': <function eat at 0x10a0bcd08>}- People = type(類名，基類，類的名稱空間)
People1 = type(class_name, class_bases, class_dic)
print(People1)<class '__main__.People'>obj1 = People1(1, 2)
obj1.eat()1 is eating- class創建的類的調用
print(People)<class '__main__.People'>obj = People1(1, 2)
obj.eat()1 is eating六、自定義元類控制類的創建
- 使用自定義的元類
class Mymeta(type): # 只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類def __init__(self, class_name, class_bases, class_dic):print('self:', self) # 現在是Peopleprint('class_name:', class_name)print('class_bases:', class_bases)print('class_dic:', class_dic)super(Mymeta, self).__init__(class_name, class_bases,class_dic) # 重用父類type的功能分析用class自定義類的運行原理（而非元類的的運行原理）：
拿到一個字符串格式的類名class_name='People'
拿到一個類的基類們class_bases=(obejct,)
執行類體代碼，拿到一個類的名稱空間class_dic={...}
調用People=type(class_name,class_bases,class_dic)
class People(object, metaclass=Mymeta): # People=Mymeta(類名,基類們,類的名稱空間)country = 'China'def __init__(self, name, age):self.name = nameself.age = agedef eat(self):print('%s is eating' % self.name)self: <class '__main__.People'>
class_name: People
class_bases: (<class 'object'>,)
class_dic: {'__module__': '__main__', '__qualname__': 'People', 'country': 'China', '__init__': <function People.__init__ at 0x10a0bcbf8>, 'eat': <function People.eat at 0x10a0bc2f0>}6.1 應用
自定義元類控制類的產生過程，類的產生過程其實就是元類的調用過程
我們可以控制類必須有文檔，可以使用如下的方式實現
class Mymeta(type): # 只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類def __init__(self, class_name, class_bases, class_dic):if class_dic.get('__doc__') is None or len(class_dic.get('__doc__').strip()) == 0:raise TypeError('類中必須有文檔注釋，并且文檔注釋不能為空')if not class_name.istitle():raise TypeError('類名首字母必須大寫')super(Mymeta, self).__init__(class_name, class_bases,class_dic) # 重用父類的功能try:class People(object, metaclass=Mymeta): #People = Mymeta('People',(object,),{....})# """這是People類"""country = 'China'def __init__(self, name, age):self.name = nameself.age = agedef eat(self):print('%s is eating' % self.name)
except Exception as e:print(e)類中必須有文檔注釋，并且文檔注釋不能為空七、__call__(儲備)
- 要想讓obj這個對象變成一個可調用的對象，需要在該對象的類中定義一個方法、、__call__方法，該方法會在調用對象時自動觸發
class Foo:def __call__(self, *args, **kwargs):print(args)print(kwargs)print('__call__實現了，實例化對象可以加括號調用了')obj = Foo()
obj('nick', age=18)('nick',)
{'age': 18}
__call__實現了，實例化對象可以加括號調用了八、__new__(儲備)
我們之前說類實例化第一個調用的是__init__，但__init__其實不是實例化一個類的時候第一個被調用 的方法。當使用 Persion(name, age) 這樣的表達式來實例化一個類時，最先被調用的方法 其實是 __new__ 方法。
__new__方法接受的參數雖然也是和__init__一樣，但__init__是在類實例創建之后調用，而 __new__方法正是創建這個類實例的方法。
注意：new() 函數只能用于從object繼承的新式類。
class A:passclass B(A):def __new__(cls):print("__new__方法被執行")return cls.__new__(cls)def __init__(self):print("__init__方法被執行")b = B()九、自定義元類控制類的實例化
class Mymeta(type):def __call__(self, *args, **kwargs):print(self) # self是Peopleprint(args) # args = ('nick',)print(kwargs) # kwargs = {'age':18}# return 123# 1. 先造出一個People的空對象，申請內存空間# __new__方法接受的參數雖然也是和__init__一樣，但__init__是在類實例創建之后調用，而 __new__方法正是創建這個類實例的方法。obj = self.__new__(self) # 雖然和下面同樣是People，但是People沒有，找到的__new__是父類的# 2. 為該對空對象初始化獨有的屬性self.__init__(obj, *args, **kwargs)# 3. 返回一個初始化好的對象return obj- People = Mymeta()，People()則會觸發__call__
class People(object, metaclass=Mymeta):country = 'China'def __init__(self, name, age):self.name = nameself.age = agedef eat(self):print('%s is eating' % self.name)# 在調用Mymeta的__call__的時候，首先會找自己（如下函數）的，自己的沒有才會找父類的
# def __new__(cls, *args, **kwargs):
# # print(cls) # cls是People
# # cls.__new__(cls) # 錯誤，無限死循環，自己找自己的，會無限遞歸
# obj = super(People, cls).__new__(cls) # 使用父類的，則是去父類中找__new__
# return obj類的調用，即類實例化就是元類的調用過程，可以通過元類Mymeta的__call__方法控制
分析：調用Pepole的目的
先造出一個People的空對象
為該對空對象初始化獨有的屬性
返回一個初始化好的對象
obj = People('nick', age=18)<class '__main__.People'>
('nick',)
{'age': 18}print(obj.__dict__){'name': 'nick', 'age': 18}一十、自定義元類后類的繼承順序
結合python繼承的實現原理+元類重新看屬性的查找應該是什么樣子呢？？？
在學習完元類后，其實我們用class自定義的類也全都是對象（包括object類本身也是元類type的 一個實例，可以用type(object)查看），我們學習過繼承的實現原理，如果把類當成對象去看，將下述繼承應該說成是：對象OldboyTeacher繼承對象Foo，對象Foo繼承對象Bar，對象Bar繼承對象object
class Mymeta(type): # 只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類n = 444def __call__(self, *args,**kwargs): #self=<class '__main__.OldboyTeacher'>obj = self.__new__(self)self.__init__(obj, *args, **kwargs)return objclass Bar(object):n = 333class Foo(Bar):n = 222class OldboyTeacher(Foo, metaclass=Mymeta):n = 111school = 'oldboy'def __init__(self, name, age):self.name = nameself.age = agedef 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->type111print(OldboyTeacher.n)111查找順序：
先對象層：OldoyTeacher->Foo->Bar->object
然后元類層：Mymeta->type
依據上述總結，我們來分析下元類Mymeta中__call__里的self.__new__的查找
class Mymeta(type):n = 444def __call__(self, *args,**kwargs): #self=<class '__main__.OldboyTeacher'>obj = self.__new__(self)print(self.__new__ is object.__new__) #Trueclass 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 = 111school = 'oldboy'def __init__(self, name, age):self.name = nameself.age = agedef say(self):print('%s says welcome to the oldboy to learn Python' % self.name)# def __new__(cls, *args, **kwargs):# print('OldboyTeacher.__new__')OldboyTeacher('nick',18) # 觸發OldboyTeacher的類中的__call__方法的執行，進而執行self.__new__開始查找總結，Mymeta下的__call__里的self.__new__在OldboyTeacher、Foo、Bar里都沒有找到__new__的情況下，會去找object里的__new__，而object下默認就有一個__new__，所以即便是之前的類均未實現__new__,也一定會在object中找到一個，根本不會、也根本沒必要再去找元類Mymeta->type中查找__new__
十一、練習
需求：使用元類修改屬性為隱藏屬性
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): vfor k, v in obj.__dict__.items()}return objclass Foo(object, metaclass=Mymeta): # Foo = Mymeta(...)def __init__(self, name, age, sex):self.name = nameself.age = ageself.sex = sexobj = Foo('nick', 18, 'male')print(obj.__dict__){'_Foo__name': 'egon', '_Foo__age': 18, '_Foo__sex': 'male'}
)
