目錄

• 一、引言
• 二、什么是元類
• 三、為什么用元類
• 四、內置函數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) People print(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->type 111 print(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 obj class 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'}

轉載于:https://www.cnblogs.com/nickchen121/p/10992975.html

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的元类(metaclass)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。