Python中的元類(metaclass)

一、什么是元類

元類(metaclass) ：就是創建類的類。

這么說可能不太好理解，下面我們來解釋下上面這句話：

在⼤多數編程語⾔中，類就是⼀組⽤來描述如何⽣成⼀個對象的代碼段，在python中也不例外。

實例對象是由類生成的，而python中，類本身也是可以被傳遞和自省的對象。

類對象是用什么創建和生成的呢？答案是元類，元類就是一種知道如何創建和管理類的對象，也可以叫做類生成器。 

所有的對象都是實例化或者說調用類而得到的（調用類的過程稱為類的實例化),python內置了一個方法可以看到類對象的類，就是type,：

查看對象的類型：

查看類的類型

 結果為<class 'type'>，證明是調用了type這個元類而產生的StanfordTeacher，即默認的元類為type，是不是有些驚訝

於是我們可以推導出：

 二、class關鍵字創建類的流程分析

上文我們基於python中一切皆為對象的概念分析出：我們用class關鍵字定義的類本身也是一個對象，負責產生該對象的類稱之為元類（元類可以簡稱為類的類），內置的元類為type

class關鍵字在幫我們創建類時，必然幫我們調用了元類StanfordTeacher=type(...)，那調用type時傳入的參數是什么呢？必然是類的關鍵組成部分，一個類有三大組成部分，分別是：

1、類名class_name='StanfordTeacher'

2、基類們class_bases=(object,)

3、類的名稱空間class_dic，類的名稱空間是執行類體代碼而得到的

調用type時會依次傳入以上三個參數

type可以接受一個類的描述作為參數，然后返回一個類。type可以像這樣工作：

type(類名, 由父類名稱組成的元組（針對繼承的情況，可以為空），包含屬性的字典（名稱和值）)

比如下面的代碼：

可以手動像這樣創建：

那么class關鍵字底層的做了哪些事?

# 1、先拿到一個類名
class_name = "StanfordTeacher"

# 2、然后拿到類的父類 class_bases = (object,)

# 3、再運行類體代碼，將產生的名字放到名稱空間中 class_dic = {}
class_body = """
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)
"""

exec(class_body,{},class_dic)
# print(class_dic)

# 4、調用元類（傳入類的三大要素：類名、基類、類的名稱空間）得到一個元類的對象，然后將元類的對象賦值給變量名StanfordTeacher,StanfordTeacher就是我們用class自定義的那個類 StanfordTeacher = type(class_name,class_bases,class_dic)

綜上，class關鍵字幫我們創建一個類應該細分為以下四個過程

 三、到底什么是元類

元類就是用來創建類的“東西”。你創建類就是為了創建類的實例對象，不是嗎？但是我們已經學習到了Python中的類也是對象。

元類就是用來創建這些類（對象）的，元類就是類的類，你可以這樣理解為：

MyClass = MetaClass() #使用元類創建出一個對象，這個對象稱為“類” MyObject = MyClass() #使用“類”來創建出實例對象 

你已經看到了type可以讓你像這樣做：　　

MyClass = type('MyClass', (), {}) 

這是因為函數type實際上是一個元類。type就是Python在背后用來創建所有類的元類。type就是創建類對象的類。你可以通過檢查__class__屬性來看到這一點。Python中所有的東西，注意，我是指所有的東西——都是對象。這包括整數、字符串、函數以及類。它們全部都是對象，而且它們都是從一個類創建而來，這個類就是type。　　

四、 自定義元類控制類的創建

一個類沒有聲明自己的元類，默認他的元類就是type，除了使用內置元類type，我們也可以通過繼承type來自定義元類，然后使用metaclass關鍵字參數為一個類指定元類

class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類
    pass

# StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})
class StanfordTeacher(object,metaclass=Mymeta): 
    school='Stanford'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)

自定義元類可以控制類的產生過程，類的產生過程其實就是元類的調用過程,即

StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})，

調用Mymeta會先產生一個空對象StanfordTeacher，

然后連同調用Mymeta括號內的參數一同傳給Mymeta下的__init__方法，完成初始化，　　

於是我們可以自定義元類來控制StanfordTeacher類的產生：如下示例

1.自定義元類來控制StanfordTeacher類的產生

import re

class Mymeta(type):  # 只有繼承了type類的類才是自定義的元類
    def __init__(self, class_name, class_bases, class_dic):
        # print(self)  # 類<class '__main__.StanfordTeacher'>
        # print(class_name)
        # print(class_bases)
        # print(class_dic)

        if not re.match("[A-Z]", class_name):
            raise BaseException("類名必須用駝峰體")

        if len(class_bases) == 0:
            raise BaseException("至少繼承一個父類")

        # print("文檔注釋：",class_dic.get('__doc__'))
        doc=class_dic.get('__doc__')

        if not (doc and len(doc.strip()) > 0):
            raise BaseException("必須要有文件注釋，並且注釋內容不為空")

# StanfordTeacher = Mymeta("StanfordTeacher",(object,),{...})
class StanfordTeacher(object,metaclass=Mymeta):
    """
    adsaf
    """

    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)

自定義元類來控制StanfordTeacher類的調用:

儲備知識：__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__方法的執行，如果把StanfordTeacher也當做一個對象，那么在StanfordTeacher這個對象的類中也必然存在一個__call__方法　　

class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類
    def __call__(self, *args, **kwargs):
        print(self) #<class '__main__.StanfordTeacher'>
        print(args) #('lili', 18)
        print(kwargs) #{}
        return 123

class StanfordTeacher(object,metaclass=Mymeta):
    school='Stanford'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)



# 調用StanfordTeacher就是在調用StanfordTeacher類中的__call__方法 # 然后將StanfordTeacher傳給self,溢出的位置參數傳給*，溢出的關鍵字參數傳給** # 調用StanfordTeacher的返回值就是調用__call__的返回值
t1=StanfordTeacher('lili',18)
print(t1) #123

默認地，調用t1=StanfordTeacher('lili',18)會做三件事:

1、產生一個空對象obj

2、調用__init__方法初始化對象obj

3、返回初始化好的obj

對應着，StanfordTeacher類中的__call__方法也應該做這三件事:

class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類
    def __call__(self, *args, **kwargs): #self=<class '__main__.StanfordTeacher'>
        #1、調用__new__產生一個空對象obj
 obj=self.__new__(self) # 此處的self是類StanfordTeacher，必須傳參，代表創建一個StanfordTeacher的對象obj 
 #2、調用__init__初始化空對象obj         self.__init__(obj,*args,**kwargs)

 #3、返回初始化好的對象obj         return obj

class StanfordTeacher(object,metaclass=Mymeta):
    school='Stanford'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)

t1=StanfordTeacher('lili',18)
print(t1.__dict__) #{'name': 'lili', 'age': 18}

上例的__call__相當於一個模板，我們可以在該基礎上改寫__call__的邏輯從而控制調用StanfordTeacher的過程，比如將StanfordTeacher的對象的所有屬性都變成私有的　　

import re


class Mymeta(type):  # 只有繼承了type類的類才是自定義的元類
    def __init__(self, class_name, class_bases, class_dic):
        # print(self)  # 類<class '__main__.StanfordTeacher'>
        # print(class_name)
        # print(class_bases)
        # print(class_dic)

        if not re.match("[A-Z]", class_name):
            raise BaseException("類名必須用駝峰體")

        if len(class_bases) == 0:
            raise BaseException("至少繼承一個父類")

        # print("文檔注釋：",class_dic.get('__doc__'))
        doc = class_dic.get('__doc__')

        if not (doc and len(doc.strip()) > 0):
            raise BaseException("必須要有文件注釋，並且注釋內容不為空")

    # res = StanfordTeacher('egon',18)
    def __call__(self, *args, **kwargs):
        # 1、先創建一個老師的空對象
        tea_obj = object.__new__(self)
 # 2、調用老師類內的__init__函數，然后將老師的空對象連同括號內的參數的參數一同傳給__init__         self.__init__(tea_obj, *args, **kwargs)
        tea_obj.__dict__ = {"_%s__%s" %(self.__name__,k): v for k, v in tea_obj.__dict__.items()}

 # 3、將初始化好的老師對象賦值給變量名res         return tea_obj


# StanfordTeacher = Mymeta("StanfordTeacher",(object,),{...})
class StanfordTeacher(object, metaclass=Mymeta):
    """
    adsaf
    """

    school = 'oldboy'

    #            tea_obj,'egon',18
    def __init__(self, name, age):
        self.name = name  # tea_obj.name='egon'
        self.age = age  # tea_obj.age=18

    def say(self):
        print('%s says welcome to the oldboy to learn Python' % self.name)


res = StanfordTeacher('egon', 18)
print(res.__dict__)
# print(res.name)
# print(res.age)
# print(res.say)

# 調用StanfordTeacher類做的事情：
# 1、先創建一個老師的空對象 # 2、調用老師類內的__init__方法，然后將老師的空對象連同括號內的參數的參數一同傳給__init__ # 3、將初始化好的老師對象賦值給變量名res 

最后說明一點

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 StanfordTeacher(object,metaclass=Mymeta): #StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})
    n=111

    school='Stanford'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)


print(type(Mymeta)) #<class 'type'>
# 產生類StanfordTeacher的過程就是在調用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

五、元類沖突

假如有兩個不同的元類，要生成一個繼承這兩個類的子類，會產生什么情況呢？

這時會報錯， 元類沖突。

我們需要手動構造新的子類元類，讓新的子類元類繼承自A和B的元類：

六、元類的應用

應用元類之前我們首先要知道使用元類編程的缺點：

實現麻煩
代碼可讀性不高
不易維護

其實在開頭引用TimPeters的話就說明，不要隨意在生產代碼中使用元類，而且現有的編碼規范也極不推薦使用。

就元類本身而言，它的作用是：

攔截類的創建
修改類
返回修改之后的類

使用元類還是有一些好處的：

意圖更加明確。當然你的metaclass名字要起好
面向對象。可以隱式繼承到子類
可以更好地組織代碼
可以用__new__，__init__,__call__等方法更好地控制

七、在Python當中，__call__,__new__,__init__三者之間的關系

在類實例化的過程當中，哪個對象加()就尋找產生這個對象的類的__call__方法，只要是__call__方法，一定會做三件事情：

第一：調用__new__方法，構造新的對象，相當於Java當中的構造函數.（對象自己的__new__）

第二：調用__init__方法,去初始化這個對象（對象自己的__init__）

第三：返回這個對象.

注意:__new__更像是其他語言當中的構造函數，必須有返回值，返回值實例化的對象，__init__只是初始化構造函數，必須沒有返回值，僅僅只是初始化功能，並不能new創建對象.

也就是說,一個類在實例化的時候實際上是做了三件事情：

第一：觸發元類中（造出這個類的類）的__call__方法

第二：通過__new__產生一個空對象

第三：通過__init__初始化這個對象

第四：返回這個對象

類在實例化對象的時候函數的調用順序依次是:

__call__==>__new__==>__init__

八、練習：　　

1、在元類中控制把自定義類的數據屬性都變成大寫

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}
'''

2、在元類中控制自定義的類不使用__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='lili',age=18,sex='male')
print(p.__dict__)

3、在元類中控制自定義的類產生的對象相關的屬性全部為隱藏屬性　　

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('lili',18,'male')
print(obj.__dict__)

4、基於元類實現單例模式

# 單例：即單個實例，指的是同一個類實例化多次的結果指向同一個對象，用於節省內存空間
# 如果我們從配置文件中讀取配置來進行實例化，在配置相同的情況下，就沒必要重復產生對象浪費內存了
#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)  # 初始化對象

    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　　

抄自於：https://zhuanlan.zhihu.com/p/109336845