python 中的元類

阿新 • • 發佈：2018-12-03

1. 類也是物件

在大多數程式語言中，類就是一組用來描述如何生成一個物件的程式碼段。在Python中這一點仍然成立：

>>> class ObjectCreator(object):
…       pass
…
>>> my_object = ObjectCreator()
>>> print(my_object)
<__main__.ObjectCreator object at 0x8974f2c>

但是，Python中的類還遠不止如此。類同樣也是一種物件。是的，沒錯，就是物件。只要你使用關鍵字class，Python直譯器在執行的時候就會建立一個物件。

下面的程式碼段：

>>> class ObjectCreator(object):
…       pass
…

將在記憶體中建立一個物件，名字就是ObjectCreator。這個物件（類物件ObjectCreator）擁有建立物件（例項物件）的能力。但是，它的本質仍然是一個物件，於是乎你可以對它做如下的操作：

你可以將它賦值給一個變數
你可以拷貝它
你可以為它增加屬性
你可以將它作為函式引數進行傳遞

下面是示例：


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

2. 動態地建立類

因為類也是物件，你可以在執行時動態的建立它們，就像其他任何物件一樣。首先，你可以在函式中建立類，使用class關鍵字即可。

>>> 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嗎？這個古老但強大的函式能夠讓你知道一個物件的型別是什麼，就像這樣：

>>> print(type(1))  # 數值的型別
<type 'int'>
>>> print(type("1"))  # 字串的型別
<type 'str'>
>>> print(type(ObjectCreator()))  # 例項物件的型別
<class '__main__.ObjectCreator'>
>>> print(type(ObjectCreator))  # 類的型別
<type 'type'>

仔細觀察上面的執行結果，發現使用type對ObjectCreator檢視型別是，答案為type，是不是有些驚訝。。。看下面

3. 使用type建立類

type還有一種完全不同的功能，動態的建立類。

type可以接受一個類的描述作為引數，然後返回一個類。（要知道，根據傳入引數的不同，同一個函式擁有兩種完全不同的用法是一件很傻的事情，但這在Python中是為了保持向後相容性）

type可以像這樣工作：

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

比如下面的程式碼：

In [2]: class Test: #定義了一個Test類
   ...:     pass
   ...:
In [3]: Test() # 建立了一個Test類的例項物件
Out[3]: <__main__.Test at 0x10d3f8438>

可以手動像這樣建立：

Test2 = type("Test2", (), {}) # 定了一個Test2類
In [5]: Test2() # 建立了一個Test2類的例項物件
Out[5]: <__main__.Test2 at 0x10d406b38>

我們使用"Test2"作為類名，並且也可以把它當做一個變數來作為類的引用。類和變數是不同的，這裡沒有任何理由把事情弄的複雜。即type函式中第1個實參，也可以叫做其他的名字，這個名字表示類的名字

In [23]: MyDogClass = type('MyDog', (), {})

In [24]: print(MyDogClass)
<class '__main__.MyDog'>

使用help來測試這2個類


In [10]: help(Test) # 用help檢視Test類

Help on class Test in module __main__:

class Test(builtins.object)
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables (if defined)
 |
 |  __weakref__
 |      list of weak references to the object (if defined)

In [8]: help(Test2) #用help檢視Test2類

Help on class Test2 in module __main__:

class Test2(builtins.object)
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables (if defined)
 |
 |  __weakref__
 |      list of weak references to the object (if defined)

4. 使用type建立帶有屬性的類

type 接受一個字典來為類定義屬性，因此

>>> Foo = type('Foo', (), {'bar': True})

可以翻譯為：

>>> class Foo(object):
…       bar = True

並且可以將Foo當成一個普通的類一樣使用：

>>> print(Foo)
<class '__main__.Foo'>
>>> print(Foo.bar)
True
>>> f = Foo()
>>> print(f)
<__main__.Foo object at 0x8a9b84c>
>>> print(f.bar)
True

當然，你可以繼承這個類，程式碼如下：

>>> class FooChild(Foo):
…       pass

就可以寫成：

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

注意：

type的第2個引數，元組中是父類的名字，而不是字串
新增的屬性是類屬性，並不是例項屬性

5. 使用type建立帶有方法的類

最終你會希望為你的類增加方法。只需要定義一個有著恰當簽名的函式並將其作為屬性賦值就可以了。

新增例項方法

In [46]: def echo_bar(self):  # 定義了一個普通的函式
    ...:     print(self.bar)
    ...:

In [47]: FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})  # 讓FooChild類中的echo_bar屬性，指向了上面定義的函式

In [48]: hasattr(Foo, 'echo_bar')  # 判斷Foo類中 是否有echo_bar這個屬性
Out[48]: False

In [49]:

In [49]: hasattr(FooChild, 'echo_bar')  # 判斷FooChild類中 是否有echo_bar這個屬性
Out[49]: True

In [50]: my_foo = FooChild()

In [51]: my_foo.echo_bar()
True

新增靜態方法

In [36]: @staticmethod
    ...: def test_static():
    ...:     print("static method ....")
    ...:

In [37]: Foochild = type('Foochild', (Foo,), {"echo_bar": echo_bar, "test_static": test_static})

In [38]: fooclid = Foochild()

In [39]: fooclid.test_static
Out[39]: <function __main__.test_static>

In [40]: fooclid.test_static()
static method ....

In [41]: fooclid.echo_bar()
True

新增類方法

In [42]: @classmethod
    ...: def test_class(cls):
    ...:     print(cls.bar)
    ...:

In [43]:

In [43]: Foochild = type('Foochild', (Foo,), {"echo_bar":echo_bar, "test_static": test_static, "test_class": test_class})

In [44]:

In [44]: fooclid = Foochild()

In [45]: fooclid.test_class()
True

你可以看到，在Python中，類也是物件，你可以動態的建立類。這就是當你使用關鍵字class時Python在幕後做的事情，而這就是通過元類來實現的。

較為完整的使用type建立類的方式:


class A(object):
    num = 100

def print_b(self):
    print(self.num)

@staticmethod
def print_static():
    print("----haha-----")

@classmethod
def print_class(cls):
    print(cls.num)

B = type("B", (A,), {"print_b": print_b, "print_static": print_static, "print_class": print_class})
b = B()
b.print_b()
b.print_static()
b.print_class()
# 結果
# 100
# ----haha-----
# 100

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

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

元類就是用來建立這些類（物件）的，元類就是類的類，你可以這樣理解為：

MyClass = MetaClass() # 使用元類創建出一個物件，這個物件稱為“類”
my_object = MyClass() # 使用“類”來創建出例項物件

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

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

這是因為函式type實際上是一個元類。type就是Python在背後用來建立所有類的元類。現在你想知道那為什麼type會全部採用小寫形式而不是Type呢？好吧，我猜這是為了和str保持一致性，str是用來建立字串物件的類，而int是用來建立整數物件的類。type就是建立類物件的類。你可以通過檢查__class__屬性來看到這一點。Python中所有的東西，注意，我是指所有的東西——都是物件。這包括整數、字串、函式以及類。它們全部都是物件，而且它們都是從一個類建立而來，這個類就是type。

>>> 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__屬性又是什麼呢？

>>> a.__class__.__class__
<type 'type'>
>>> age.__class__.__class__
<type 'type'>
>>> foo.__class__.__class__
<type 'type'>
>>> b.__class__.__class__
<type 'type'>

因此，元類就是建立類這種物件的東西。type就是Python的內建元類，當然了，你也可以建立自己的元類。

7. metaclass屬性

你可以在定義一個類的時候為其新增__metaclass__屬性。

class Foo(object):
    __metaclass__ = something…
    ...省略...

如果你這麼做了，Python就會用元類來建立類Foo。小心點，這裡面有些技巧。你首先寫下class Foo(object)，但是類Foo還沒有在記憶體中建立。Python會在類的定義中尋找__metaclass__屬性，如果找到了，Python就會用它來建立類Foo，如果沒有找到，就會用內建的type來建立這個類。把下面這段話反覆讀幾次。當你寫如下程式碼時 :

class Foo(Bar):
    pass

Python做了如下的操作：

Foo中有__metaclass__這個屬性嗎？如果是，Python會通過__metaclass__建立一個名字為Foo的類(物件)
如果Python沒有找到__metaclass__，它會繼續在Bar（父類）中尋找__metaclass__屬性，並嘗試做和前面同樣的操作。
如果Python在任何父類中都找不到__metaclass__，它就會在模組層次中去尋找__metaclass__，並嘗試做同樣的操作。
如果還是找不到__metaclass__,Python就會用內建的type來建立這個類物件。

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

8. 自定義元類

元類的主要目的就是為了當建立類時能夠自動地改變類。

假想一個很傻的例子，你決定在你的模組裡所有的類的屬性都應該是大寫形式。有好幾種方法可以辦到，但其中一種就是通過在模組級別設定__metaclass__。採用這種方法，這個模組中的所有類都會通過這個元類來建立，我們只需要告訴元類把所有的屬性都改成大寫形式就萬事大吉了。

幸運的是，__metaclass__實際上可以被任意呼叫，它並不需要是一個正式的類。所以，我們這裡就先以一個簡單的函式作為例子開始。

python2中

#-*- coding:utf-8 -*-
def upper_attr(class_name, class_parents, class_attr):

    # class_name 會儲存類的名字 Foo
    # class_parents 會儲存類的父類 object
    # class_attr 會以字典的方式儲存所有的類屬性

    # 遍歷屬性字典，把不是__開頭的屬性名字變為大寫
    new_attr = {}
    for name, value in class_attr.items():
        if not name.startswith("__"):
            new_attr[name.upper()] = value

    # 呼叫type來建立一個類
    return type(class_name, class_parents, new_attr)

class Foo(object):
    __metaclass__ = upper_attr # 設定Foo類的元類為upper_attr
    bar = 'bip'

print(hasattr(Foo, 'bar'))
print(hasattr(Foo, 'BAR'))

f = Foo()
print(f.BAR)

python3中

#-*- coding:utf-8 -*-
def upper_attr(class_name, class_parents, class_attr):

    #遍歷屬性字典，把不是__開頭的屬性名字變為大寫
    new_attr = {}
    for name,value in class_attr.items():
        if not name.startswith("__"):
            new_attr[name.upper()] = value

    #呼叫type來建立一個類
    return type(class_name, class_parents, new_attr)

class Foo(object, metaclass=upper_attr):
    bar = 'bip'

print(hasattr(Foo, 'bar'))
print(hasattr(Foo, 'BAR'))

f = Foo()
print(f.BAR)

現在讓我們再做一次，這一次用一個真正的class來當做元類。

#coding=utf-8

class UpperAttrMetaClass(type):
    # __new__ 是在__init__之前被呼叫的特殊方法
    # __new__是用來建立物件並返回之的方法
    # 而__init__只是用來將傳入的引數初始化給物件
    # 你很少用到__new__，除非你希望能夠控制物件的建立
    # 這裡，建立的物件是類，我們希望能夠自定義它，所以我們這裡改寫__new__
    # 如果你希望的話，你也可以在__init__中做些事情
    # 還有一些高階的用法會涉及到改寫__call__特殊方法，但是我們這裡不用
    def __new__(cls, class_name, class_parents, class_attr):
        # 遍歷屬性字典，把不是__開頭的屬性名字變為大寫
        new_attr = {}
        for name, value in class_attr.items():
            if not name.startswith("__"):
                new_attr[name.upper()] = value

        # 方法1：通過'type'來做類物件的建立
        return type(class_name, class_parents, new_attr)

        # 方法2：複用type.__new__方法
        # 這就是基本的OOP程式設計，沒什麼魔法
        # return type.__new__(cls, class_name, class_parents, new_attr)

# python3的用法
class Foo(object, metaclass=UpperAttrMetaClass):
    bar = 'bip'

# python2的用法
# class Foo(object):
#     __metaclass__ = UpperAttrMetaClass
#     bar = 'bip'


print(hasattr(Foo, 'bar'))
# 輸出: False
print(hasattr(Foo, 'BAR'))
# 輸出:True

f = Foo()
print(f.BAR)
# 輸出:'bip'

就是這樣，除此之外，關於元類真的沒有別的可說的了。但就元類本身而言，它們其實是很簡單的：

攔截類的建立
修改類
返回修改之後的類

究竟為什麼要使用元類？

現在回到我們的大主題上來，究竟是為什麼你會去使用這樣一種容易出錯且晦澀的特性？好吧，一般來說，你根本就用不上它：

“元類就是深度的魔法，99%的使用者應該根本不必為此操心。如果你想搞清楚究竟是否需要用到元類，那麼你就不需要它。那些實際用到元類的人都非常清楚地知道他們需要做什麼，而且根本不需要解釋為什麼要用元類。” —— Python界的領袖 Tim Peters

python 中的元類

1. 類也是物件

2. 動態地建立類

3. 使用type建立類

4. 使用type建立帶有屬性的類

5. 使用type建立帶有方法的類

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

7. metaclass屬性

8. 自定義元類

python中元類

python中元類的作用

【原創】Python 對象創建過程中元類, new, call, init 的處理

python的元類（metaclass）中attrs的使用

Python中的類和元類（metaclass）以及黑魔法（metaclass）

23.python中的類屬性和實例屬性

python中元組與小括號的關系

python中基本類型的連接組合和互相轉換

五 Python中元祖，列表，字典的區別

Python之Metaclass詳解，Python之元類

python中列表類型常用操作

python中的類和對象

python 中的類

Python之元類ORM

python中，類屬性為只讀屬性

python中int類型、bool類型補充，及字符串的部分常用方法

python中利用類創建的對象來保存信息

python中的類方法、靜態方法、對象方法

python中定義類

Python中抽象類的實現

python 中的元類

1. 類也是物件

2. 動態地建立類

3. 使用type建立類

4. 使用type建立帶有屬性的類

5. 使用type建立帶有方法的類

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

7. __metaclass__屬性

8. 自定義元類

相關推薦

7. metaclass屬性