深入理解Python中的元類(metaclass)

時間 2019-12-13

原文原文鏈接

本文轉自博客在線，只供本身學習保存，任何轉載和使用，責任自負，原地址：http://blog.jobbole.com/21351/python

譯註：這是一篇在Stack overflow上很熱的帖子。提問者自稱已經掌握了有關Python OOP編程中的各類概念，但始終以爲元類(metaclass)難以理解。他知道這確定和自省有關，但仍然以爲不太明白，但願你們能夠給出一些實際的例子和代碼片斷以幫助理解，以及在什麼狀況下須要進行元編程。因而e-satis同窗給出了神通常的回覆，該回復得到了985點的贊同點數，更有人評論說這段回覆應該加入到Python的官方文檔中去。而e-satis同窗本人在Stack Overflow中的聲望積分也高達64271分。如下就是這篇精彩的回覆（提示：很是長）git

類也是對象github

在理解元類以前，你須要先掌握Python中的類。Python中類的概念借鑑於Smalltalk，這顯得有些奇特。在大多數編程語言中，類就是一組用來描述如何生成一個對象的代碼段。在Python中這一點仍然成立：數據庫

       
Python

         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         6 
       
        >>> 
        class 
        ObjectCreator 
        ( 
        object 
        ) 
        : 
       
         … 
                
        pass 
       
         … 
       
        >>> 
        my_object 
        = 
        ObjectCreator 
        ( 
        ) 
       
        >>> 
        print 
        my_object 
       
        < 
        __main__ 
        . 
        ObjectCreator  
        object 
        at 
        0x8974f2c 
        >

可是，Python中的類還遠不止如此。類一樣也是一種對象。是的，沒錯，就是對象。只要你使用關鍵字class，Python解釋器在執行的時候就會建立一個對象。下面的代碼段：編程

       
Python

         1 
       
         2 
       
         3 
       
        >>> 
        class 
        ObjectCreator 
        ( 
        object 
        ) 
        : 
       
         … 
                
        pass 
       
         …

將在內存中建立一個對象，名字就是ObjectCreator。這個對象（類）自身擁有建立對象（類實例）的能力，而這就是爲何它是一個類的緣由。可是，它的本質仍然是一個對象，因而乎你能夠對它作以下的操做：框架

1) 你能夠將它賦值給一個變量編程語言

2) 你能夠拷貝它函數

3) 你能夠爲它增長屬性學習

4) 你能夠將它做爲函數參數進行傳遞spa

下面是示例：

       
Python

         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         6 
       
         7 
       
         8 
       
         9 
       
         10 
       
         11 
       
         12 
       
         13 
       
         14 
       
         15 
       
         16 
       
         17 
       
        >>> 
        print 
        ObjectCreator 
              
        # 你能夠打印一個類，由於它其實也是一個對象 
       
        < 
        class 
        '__main__.ObjectCreator' 
        > 
       
        >>> 
        def 
        echo 
        ( 
        o 
        ) 
        : 
       
         … 
                
        print 
        o 
       
         … 
       
        >>> 
        echo 
        ( 
        ObjectCreator 
        ) 
                          
        # 你能夠將類作爲參數傳給函數 
       
        < 
        class 
        '__main__.ObjectCreator' 
        > 
       
        >>> 
        print 
        hasattr 
        ( 
        ObjectCreator 
        , 
        'new_attribute' 
        ) 
       
        Fasle 
       
        >>> 
        ObjectCreator 
        . 
        new_attribute 
        = 
        'foo' 
        #  你能夠爲類增長屬性 
       
        >>> 
        print 
        hasattr 
        ( 
        ObjectCreator 
        , 
        'new_attribute' 
        ) 
       
        True 
       
        >>> 
        print 
        ObjectCreator 
        . 
        new_attribute 
       
        foo 
       
        >>> 
        ObjectCreatorMirror 
        = 
        ObjectCreator 
        # 你能夠將類賦值給一個變量 
       
        >>> 
        print 
        ObjectCreatorMirror 
        ( 
        ) 
       
        < 
        __main__ 
        . 
        ObjectCreator  
        object 
        at 
        0x8997b4c 
        >

動態地建立類

由於類也是對象，你能夠在運行時動態的建立它們，就像其餘任何對象同樣。首先，你能夠在函數中建立類，使用class關鍵字便可。

       
Python

         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         6 
       
         7 
       
         8 
       
         9 
       
         10 
       
         11 
       
         12 
       
         13 
       
         14 
       
         15 
       
        >>> 
        def 
        choose_class 
        ( 
        name 
        ) 
        : 
       
         … 
                
        if 
        name 
        == 
        'foo' 
        : 
       
         … 
                    
        class 
        Foo 
        ( 
        object 
        ) 
        : 
       
         … 
                        
        pass 
       
         … 
                    
        return 
        Foo 
              
        # 返回的是類，不是類的實例 
       
         … 
                
        else 
        : 
       
         … 
                    
        class 
        Bar 
        ( 
        object 
        ) 
        : 
       
         … 
                        
        pass 
       
         … 
                    
        return 
        Bar 
       
         … 
       
        >>> 
        MyClass 
        = 
        choose_class 
        ( 
        'foo' 
        ) 
       
        >>> 
        print 
        MyClass 
                       
        # 函數返回的是類，不是類的實例 
       
        < 
        class 
        '__main__' 
        . 
        Foo 
        > 
       
        >>> 
        print 
        MyClass 
        ( 
        ) 
                     
        # 你能夠經過這個類建立類實例，也就是對象 
       
        < 
        __main__ 
        . 
        Foo  
        object 
        at 
        0x89c6d4c 
        >

但這還不夠動態，由於你仍然須要本身編寫整個類的代碼。因爲類也是對象，因此它們必須是經過什麼東西來生成的纔對。當你使用class關鍵字時，Python解釋器自動建立這個對象。但就和Python中的大多數事情同樣，Python仍然提供給你手動處理的方法。還記得內建函數type嗎？這個古老但強大的函數可以讓你知道一個對象的類型是什麼，就像這樣：

       
Python

         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         6 
       
         7 
       
         8 
       
        >>> 
        print 
        type 
        ( 
        1 
        ) 
       
        < 
        type 
        'int' 
        > 
       
        >>> 
        print 
        type 
        ( 
        "1" 
        ) 
       
        < 
        type 
        'str' 
        > 
       
        >>> 
        print 
        type 
        ( 
        ObjectCreator 
        ) 
       
        < 
        type 
        'type' 
        > 
       
        >>> 
        print 
        type 
        ( 
        ObjectCreator 
        ( 
        ) 
        ) 
       
        < 
        class 
        '__main__.ObjectCreator' 
        >

這裏，type有一種徹底不一樣的能力，它也能動態的建立類。type能夠接受一個類的描述做爲參數，而後返回一個類。（我知道，根據傳入參數的不一樣，同一個函數擁有兩種徹底不一樣的用法是一件很傻的事情，但這在Python中是爲了保持向後兼容性）

type能夠像這樣工做：

       
Python

         1 
       
        type 
        (類名 
        ,父類的元組（針對繼承的狀況，能夠爲空），包含屬性的字典（名稱和值） 
        )

好比下面的代碼：

       
Python

         1 
       
         2 
       
        >>> 
        class 
        MyShinyClass 
        ( 
        object 
        ) 
        : 
       
         … 
                
        pass

能夠手動像這樣建立：

       
Python

         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
        >>> 
        MyShinyClass 
        = 
        type 
        ( 
        'MyShinyClass' 
        , 
        ( 
        ) 
        , 
        { 
        } 
        ) 
           
        # 返回一個類對象 
       
        >>> 
        print 
        MyShinyClass 
       
        < 
        class 
        '__main__.MyShinyClass' 
        > 
       
        >>> 
        print 
        MyShinyClass 
        ( 
        ) 
           
        #  建立一個該類的實例 
       
        < 
        __main__ 
        . 
        MyShinyClass  
        object 
        at 
        0x8997cec 
        >

你會發現咱們使用「MyShinyClass」做爲類名，而且也能夠把它當作一個變量來做爲類的引用。類和變量是不一樣的，這裏沒有任何理由把事情弄的複雜。

type 接受一個字典來爲類定義屬性，所以

能夠翻譯爲：

而且能夠將Foo當成一個普通的類同樣使用：

       
Python

         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         6 
       
         7 
       
         8 
       
         9 
       
        >>> 
        print 
        Foo 
       
        < 
        class 
        '__main__.Foo' 
        > 
       
        >>> 
        print 
        Foo 
        . 
        bar 
       
        True 
       
        >>> 
        f 
        = 
        Foo 
        ( 
        ) 
       
        >>> 
        print 
        f 
       
        < 
        __main__ 
        . 
        Foo  
        object 
        at 
        0x8a9b84c 
        > 
       
        >>> 
        print 
        f 
        . 
        bar 
       
        True

固然，你能夠向這個類繼承，因此，以下的代碼：

就能夠寫成：

       
Python

         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
        >>> 
        FooChild 
        = 
        type 
        ( 
        'FooChild' 
        , 
        ( 
        Foo 
        , 
        ) 
        , 
        { 
        } 
        ) 
       
        >>> 
        print 
        FooChild 
       
        < 
        class 
        '__main__.FooChild' 
        > 
       
        >>> 
        print 
        FooChild 
        . 
        bar 
            
        # bar屬性是由Foo繼承而來 
       
        True

最終你會但願爲你的類增長方法。只須要定義一個有着恰當簽名的函數並將其做爲屬性賦值就能夠了。

你能夠看到，在Python中，類也是對象，你能夠動態的建立類。這就是當你使用關鍵字class時Python在幕後作的事情，而這就是經過元類來實現的。

到底什麼是元類（終於到主題了）

元類就是用來建立類的「東西」。你建立類就是爲了建立類的實例對象，不是嗎？可是咱們已經學習到了Python中的類也是對象。好吧，元類就是用來建立這些類（對象）的，元類就是類的類，你能夠這樣理解爲：

       
Python

         1 
       
         2 
       
        MyClass 
        = 
        MetaClass 
        ( 
        ) 
       
        MyObject 
        = 
        MyClass 
        ( 
        )

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

這是由於函數type其實是一個元類。type就是Python在背後用來建立全部類的元類。如今你想知道那爲何type會所有采用小寫形式而不是Type呢？好吧，我猜這是爲了和str保持一致性，str是用來建立字符串對象的類，而int是用來建立整數對象的類。type就是建立類對象的類。你能夠經過檢查__class__屬性來看到這一點。Python中全部的東西，注意，我是指全部的東西——都是對象。這包括整數、字符串、函數以及類。它們所有都是對象，並且它們都是從一個類建立而來。

       
Python

         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         6 
       
         7 
       
         8 
       
         9 
       
         10 
       
         11 
       
         12 
       
         13 
       
        >>> 
        age 
        = 
        35 
       
        >>> 
        age 
        . 
        __class__ 
       
        < 
        type 
        'int' 
        > 
       
        >>> 
        name 
        = 
        'bob' 
       
        >>> 
        name 
        . 
        __class__ 
       
        < 
        type 
        'str' 
        > 
       
        >>> 
        def 
        foo 
        ( 
        ) 
        : 
        pass 
       
        >>> 
        foo 
        . 
        __class__ 
       
        < 
        type 
        'function' 
        > 
       
        >>> 
        class 
        Bar 
        ( 
        object 
        ) 
        : 
        pass 
       
        >>> 
        b 
        = 
        Bar 
        ( 
        ) 
       
        >>> 
        b 
        . 
        __class__ 
       
        < 
        class 
        '__main__.Bar' 
        >

如今，對於任何一個__class__的__class__屬性又是什麼呢？

所以，元類就是建立類這種對象的東西。若是你喜歡的話，能夠把元類稱爲「類工廠」（不要和工廠類搞混了:D） type就是Python的內建元類，固然了，你也能夠建立本身的元類。

__metaclass__屬性

你能夠在寫一個類的時候爲其添加__metaclass__屬性。

       
Python

         1 
       
         2 
       
         3 
       
        class 
        Foo 
        ( 
        object 
        ) 
        : 
       
        __metaclass__ 
        = 
        something… 
       
        [… 
        ]

若是你這麼作了，Python就會用元類來建立類Foo。當心點，這裏面有些技巧。你首先寫下class Foo(object)，可是類對象Foo尚未在內存中建立。Python會在類的定義中尋找__metaclass__屬性，若是找到了，Python就會用它來建立類Foo，若是沒有找到，就會用內建的type來建立這個類。把下面這段話反覆讀幾回。當你寫以下代碼時 :

Python作了以下的操做：

Foo中有__metaclass__這個屬性嗎？若是是，Python會在內存中經過__metaclass__建立一個名字爲Foo的類對象（我說的是類對象，請緊跟個人思路）。若是Python沒有找到__metaclass__，它會繼續在Bar（父類）中尋找__metaclass__屬性，並嘗試作和前面一樣的操做。若是Python在任何父類中都找不到__metaclass__，它就會在模塊層次中去尋找__metaclass__，並嘗試作一樣的操做。若是仍是找不到__metaclass__,Python就會用內置的type來建立這個類對象。

如今的問題就是，你能夠在__metaclass__中放置些什麼代碼呢？答案就是：能夠建立一個類的東西。那麼什麼能夠用來建立一個類呢？type，或者任何使用到type或者子類化type的東東均可以。

自定義元類

元類的主要目的就是爲了當建立類時可以自動地改變類。一般，你會爲API作這樣的事情，你但願能夠建立符合當前上下文的類。假想一個很傻的例子，你決定在你的模塊裏全部的類的屬性都應該是大寫形式。有好幾種方法能夠辦到，但其中一種就是經過在模塊級別設定__metaclass__。採用這種方法，這個模塊中的全部類都會經過這個元類來建立，咱們只須要告訴元類把全部的屬性都改爲大寫形式就萬事大吉了。

幸運的是，__metaclass__實際上能夠被任意調用，它並不須要是一個正式的類（我知道，某些名字裏帶有‘class’的東西並不須要是一個class，畫畫圖理解下，這頗有幫助）。因此，咱們這裏就先以一個簡單的函數做爲例子開始。

       
Python

         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
        # 元類會自動將你一般傳給‘type’的參數做爲本身的參數傳入 
       
        def 
        upper_attr 
        ( 
        future_class_name 
        , 
        future_class_parents 
        , 
        future_class_attr 
        ) 
        : 
       
        '''返回一個類對象，將屬性都轉爲大寫形式''' 
       
        #  選擇全部不以'__'開頭的屬性 
       
        attrs 
        = 
        ( 
        ( 
        name 
        , 
        value 
        ) 
        for 
        name 
        , 
        value  
        in 
        future_class_attr 
        . 
        items 
        ( 
        ) 
        if 
        not 
        name 
        . 
        startswith 
        ( 
        '__' 
        ) 
        )

       
Python

         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         6 
       
         7 
       
         8 
       
         9 
       
         10 
       
         11 
       
        # 將它們轉爲大寫形式 
       
        uppercase_attr 
        = 
        dict 
        ( 
        ( 
        name 
        . 
        upper 
        ( 
        ) 
        , 
        value 
        ) 
        for 
        name 
        , 
        value  
        in 
        attrs 
        ) 
       
        # 經過'type'來作類對象的建立 
       
        return 
        type 
        ( 
        future_class_name 
        , 
        future_class_parents 
        , 
        uppercase_attr 
        ) 
       
        __metaclass__ 
        = 
        upper_attr 
           
        #  這會做用到這個模塊中的全部類 
       
        class 
        Foo 
        ( 
        object 
        ) 
        : 
       
        # 咱們也能夠只在這裏定義__metaclass__，這樣就只會做用於這個類中 
       
        bar 
        = 
        'bip'

       
Python

         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         6 
       
         7 
       
         8 
       
        print 
        hasattr 
        ( 
        Foo 
        , 
        'bar' 
        ) 
       
        # 輸出: False 
       
        print 
        hasattr 
        ( 
        Foo 
        , 
        'BAR' 
        ) 
       
        # 輸出:True 
       
        f 
        = 
        Foo 
        ( 
        ) 
       
        print 
        f 
        . 
        BAR 
       
        # 輸出:'bip'

如今讓咱們再作一次，這一次用一個真正的class來當作元類。

       
Python

         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         6 
       
         7 
       
         8 
       
         9 
       
         10 
       
         11 
       
         12 
       
         13 
       
         14 
       
        # 請記住，'type'其實是一個類，就像'str'和'int'同樣 
       
        # 因此，你能夠從type繼承 
       
        class 
        UpperAttrMetaClass 
        ( 
        type 
        ) 
        : 
       
        # __new__ 是在__init__以前被調用的特殊方法 
       
        # __new__是用來建立對象並返回之的方法 
       
        # 而__init__只是用來將傳入的參數初始化給對象 
       
        # 你不多用到__new__，除非你但願可以控制對象的建立 
       
        # 這裏，建立的對象是類，咱們但願可以自定義它，因此咱們這裏改寫__new__ 
       
        # 若是你但願的話，你也能夠在__init__中作些事情 
       
        # 還有一些高級的用法會涉及到改寫__call__特殊方法，可是咱們這裏不用 
       
        def 
        __new__ 
        ( 
        upperattr_metaclass 
        , 
        future_class_name 
        , 
        future_class_parents 
        , 
        future_class_attr 
        ) 
        : 
       
        attrs 
        = 
        ( 
        ( 
        name 
        , 
        value 
        ) 
        for 
        name 
        , 
        value  
        in 
        future_class_attr 
        . 
        items 
        ( 
        ) 
        if 
        not 
        name 
        . 
        startswith 
        ( 
        '__' 
        ) 
        ) 
       
        uppercase_attr 
        = 
        dict 
        ( 
        ( 
        name 
        . 
        upper 
        ( 
        ) 
        , 
        value 
        ) 
        for 
        name 
        , 
        value  
        in 
        attrs 
        ) 
       
        return 
        type 
        ( 
        future_class_name 
        , 
        future_class_parents 
        , 
        uppercase_attr 
        )

可是，這種方式其實不是OOP。咱們直接調用了type，並且咱們沒有改寫父類的__new__方法。如今讓咱們這樣去處理:

       
Python

         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         6 
       
         7 
       
         8 
       
        class 
        UpperAttrMetaclass 
        ( 
        type 
        ) 
        : 
       
        def 
        __new__ 
        ( 
        upperattr_metaclass 
        , 
        future_class_name 
        , 
        future_class_parents 
        , 
        future_class_attr 
        ) 
        : 
       
        attrs 
        = 
        ( 
        ( 
        name 
        , 
        value 
        ) 
        for 
        name 
        , 
        value  
        in 
        future_class_attr 
        . 
        items 
        ( 
        ) 
        if 
        not 
        name 
        . 
        startswith 
        ( 
        '__' 
        ) 
        ) 
       
        uppercase_attr 
        = 
        dict 
        ( 
        ( 
        name 
        . 
        upper 
        ( 
        ) 
        , 
        value 
        ) 
        for 
        name 
        , 
        value  
        in 
        attrs 
        ) 
       
        # 複用type.__new__方法 
       
        # 這就是基本的OOP編程，沒什麼魔法 
       
        return 
        type 
        . 
        __new__ 
        ( 
        upperattr_metaclass 
        , 
        future_class_name 
        , 
        future_class_parents 
        , 
        uppercase_attr 
        )

你可能已經注意到了有個額外的參數upperattr_metaclass，這並無什麼特別的。類方法的第一個參數老是表示當前的實例，就像在普通的類方法中的self參數同樣。固然了，爲了清晰起見，這裏的名字我起的比較長。可是就像self同樣，全部的參數都有它們的傳統名稱。所以，在真實的產品代碼中一個元類應該是像這樣的：

       
   

       
   

       
   

       
   

       
   

       
   
Python

     
 
 
   
    
     
         1 
       

         2 
       

         3 
       

         4 
       

         5 
       
 
      
        class 
        UpperAttrMetaclass 
        ( 
        type 
        ) 
        : 
       
 
             
        def 
        __new__ 
        ( 
        cls 
        , 
        name 
        , 
        bases 
        , 
        dct 
        ) 
        : 
       
 
                 
        attrs 
        = 
        ( 
        ( 
        name 
        , 
        value 
        ) 
        for 
        name 
        , 
        value  
        in 
        dct 
        . 
        items 
        ( 
        ) 
        if 
        not 
        name 
        . 
        startswith 
        ( 
        '__' 
        ) 
       
 
                 
        uppercase_attr 
           
        = 
        dict 
        ( 
        ( 
        name 
        . 
        upper 
        ( 
        ) 
        , 
        value 
        ) 
        for 
        name 
        , 
        value  
        in 
        attrs 
        ) 
       
 
                 
        return 
        type 
        . 
        __new__ 
        ( 
        cls 
        , 
        name 
        , 
        bases 
        , 
        uppercase_attr 
        ) 
       
 
    
 
   
 

若是使用super方法的話，咱們還可使它變得更清晰一些，這會緩解繼承（是的，你能夠擁有元類，從元類繼承，從type繼承）

       
   

       
   

       
   

       
   

       
   

       
   
Python

     
 
 
   
    
     
         1 
       

         2 
       

         3 
       

         4 
       

         5 
       
 
      
        class 
        UpperAttrMetaclass 
        ( 
        type 
        ) 
        : 
       
 
             
        def 
        __new__ 
        ( 
        cls 
        , 
        name 
        , 
        bases 
        , 
        dct 
        ) 
        : 
       
 
                 
        attrs 
        = 
        ( 
        ( 
        name 
        , 
        value 
        ) 
        for 
        name 
        , 
        value  
        in 
        dct 
        . 
        items 
        ( 
        ) 
        if 
        not 
        name 
        . 
        startswith 
        ( 
        '__' 
        ) 
        ) 
       
 
                 
        uppercase_attr 
        = 
        dict 
        ( 
        ( 
        name 
        . 
        upper 
        ( 
        ) 
        , 
        value 
        ) 
        for 
        name 
        , 
        value  
        in 
        attrs 
        ) 
       
 
                 
        return 
        super 
        ( 
        UpperAttrMetaclass 
        , 
        cls 
        ) 
        . 
        __new__ 
        ( 
        cls 
        , 
        name 
        , 
        bases 
        , 
        uppercase_attr 
        ) 
       
 
    
 
   
 

就是這樣，除此以外，關於元類真的沒有別的可說的了。使用到元類的代碼比較複雜，這背後的緣由倒並非由於元類自己，而是由於你一般會使用元類去作一些晦澀的事情，依賴於自省，控制繼承等等。確實，用元類來搞些「黑暗魔法」是特別有用的，於是會搞出些複雜的東西來。但就元類自己而言，它們實際上是很簡單的：

1) 攔截類的建立

2) 修改類

3) 返回修改以後的類

爲何要用metaclass類而不是函數?

因爲__metaclass__能夠接受任何可調用的對象，那爲什麼還要使用類呢，由於很顯然使用類會更加複雜啊？這裏有好幾個緣由：

1）意圖會更加清晰。當你讀到UpperAttrMetaclass(type)時，你知道接下來要發生什麼。

2）你可使用OOP編程。元類能夠從元類中繼承而來，改寫父類的方法。元類甚至還可使用元類。

3）你能夠把代碼組織的更好。當你使用元類的時候確定不會是像我上面舉的這種簡單場景，一般都是針對比較複雜的問題。將多個方法歸總到一個類中會頗有幫助，也會使得代碼更容易閱讀。

4）你可使用__new__, __init__以及__call__這樣的特殊方法。它們能幫你處理不一樣的任務。就算一般你能夠把全部的東西都在__new__裏處理掉，有些人仍是以爲用__init__更舒服些。

5）哇哦，這東西的名字是metaclass，確定非善類，我要當心！

究竟爲何要使用元類？

如今回到咱們的大主題上來，到底是爲何你會去使用這樣一種容易出錯且晦澀的特性？好吧，通常來講，你根本就用不上它：

「元類就是深度的魔法，99%的用戶應該根本沒必要爲此操心。若是你想搞清楚到底是否須要用到元類，那麼你就不須要它。那些實際用到元類的人都很是清楚地知道他們須要作什麼，並且根本不須要解釋爲何要用元類。」 —— Python界的領袖 Tim Peters

元類的主要用途是建立API。一個典型的例子是Django ORM。它容許你像這樣定義：

       
Python

         1 
       
         2 
       
         3 
       
        class 
        Person 
        ( 
        models 
        . 
        Model 
        ) 
        : 
       
        name 
        = 
        models 
        . 
        CharField 
        ( 
        max_length 
        = 
        30 
        ) 
       
        age 
        = 
        models 
        . 
        IntegerField 
        ( 
        )

可是若是你像這樣作的話：

這並不會返回一個IntegerField對象，而是會返回一個int，甚至能夠直接從數據庫中取出數據。這是有可能的，由於models.Model定義了__metaclass__，而且使用了一些魔法可以將你剛剛定義的簡單的Person類轉變成對數據庫的一個複雜hook。Django框架將這些看起來很複雜的東西經過暴露出一個簡單的使用元類的API將其化簡，經過這個API從新建立代碼，在背後完成真正的工做。

結語

首先，你知道了類實際上是可以建立出類實例的對象。好吧，事實上，類自己也是實例，固然，它們是元類的實例。

Python中的一切都是對象，它們要麼是類的實例，要麼是元類的實例，除了type。type其實是它本身的元類，在純Python環境中這可不是你可以作到的，這是經過在實現層面耍一些小手段作到的。其次，元類是很複雜的。對於很是簡單的類，你可能不但願經過使用元類來對類作修改。你能夠經過其餘兩種技術來修改類：

1） Monkey patching

2) class decorators

當你須要動態修改類時，99%的時間裏你最好使用上面這兩種技術。固然了，其實在99%的時間裏你根本就不須要動態修改類 :D