譯注：這是一篇在Stack overflow上 很熱的帖子。提問者自稱已經掌握了有關Python OOP編程中的各種概念，但始終覺得元類(metaclass)難以理解。他知道這肯定和自省有關，但仍然覺得不太明白，希望大家可以給出一些實際的例子 和代碼片段以幫助理解，以及在什么情況下需要進行元編程。於是e-satis同學給出了神一般的回復，該回復獲得了985點的贊同點數，更有人評論說這段 回復應該加入到Python的官方文檔中去。而e-satis同學本人在Stack Overflow中的聲望積分也高達64271分。以下就是這篇精彩的回復（提示：非常長）
類也是對象
在理解元類之前，你需要先掌握Python中的類。Python中類的概念借鑒於Smalltalk，這顯得有些奇特。在大多數編程語言中，類就是一組用來描述如何生成一個對象的代碼段。在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解釋器在執行的時候就會創建一個對象。下面的代碼段：
|
1
2
3
|
>>>
class
ObjectCreator(
object
):
…
pass
…
|
將在內存中創建一個對象，名字就是ObjectCreator。這個對象（類）自身擁有創建對象（類實例）的能力，而這就是為什么它是一個類的原因。但是，它的本質仍然是一個對象，於是乎你可以對它做如下的操作：
1) 你可以將它賦值給一個變量
2) 你可以拷貝它
3) 你可以為它增加屬性
4) 你可以將它作為函數參數進行傳遞
下面是示例：
|
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關鍵字即可。
|
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嗎？ 這個古老但強大的函數能夠讓你知道一個對象的類型是什么，就像這樣：
|
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可以像這樣工作：
|
1
|
type
(類名, 父類的元組（針對繼承的情況，可以為空），包含屬性的字典（名稱和值）)
|
比如下面的代碼：
|
1
2
|
>>>
class
MyShinyClass(
object
):
…
pass
|
可以手動像這樣創建：
|
1
2
3
4
5
|
>>> MyShinyClass
=
type
(
'MyShinyClass'
, (), {})
# 返回一個類對象
>>>
print
MyShinyClass
<
class
'__main__.MyShinyClass'
>
>>>
print
MyShinyClass()
# 創建一個該類的實例
<__main__.MyShinyClass
object
at
0x8997cec
>
|
你會發現我們使用“MyShinyClass”作為類名，並且也可以把它當做一個變量來作為類的引用。類和變量是不同的，這里沒有任何理由把事情弄的復雜。
type 接受一個字典來為類定義屬性，因此
|
1
2
|
>>>
class
Foo(
object
):
… bar
=
True
|
可以翻譯為：
|
1
|
>>> Foo
=
type
(
'Foo'
, (), {
'bar'
:
True
})
|
並且可以將Foo當成一個普通的類一樣使用：
|
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
|
當然，你可以向這個類繼承，所以，如下的代碼：
|
1
2
|
>>>
class
FooChild(Foo):
…
pass
|
就可以寫成：
|
1
2
3
4
5
|
>>> FooChild
=
type
(
'FooChild'
, (Foo,),{})
>>>
print
FooChild
<
class
'__main__.FooChild'
>
>>>
print
FooChild.bar
# bar屬性是由Foo繼承而來
True
|
最終你會希望為你的類增加方法。只需要定義一個有着恰當簽名的函數並將其作為屬性賦值就可以了。
|
1
2
3
4
5
6
7
8
9
10
11
|
>>>
def
echo_bar(
self
):
…
print
self
.bar
…
>>> FooChild
=
type
(
'FooChild'
, (Foo,), {
'echo_bar'
: echo_bar})
>>>
hasattr
(Foo,
'echo_bar'
)
False
>>>
hasattr
(FooChild,
'echo_bar'
)
True
>>> my_foo
=
FooChild()
>>> my_foo.echo_bar()
True
|
你可以看到，在Python中，類也是對象，你可以動態的創建類。這就是當你使用關鍵字class時Python在幕后做的事情，而這就是通過元類來實現的。
到底什么是元類（終於到主題了）
元類就是用來創建類的“東西”。你創建類就是為了創建類的實例對象，不是嗎？但是我們已經學習到了Python中的類也是對象。好吧，元類就是用來創建這些類（對象）的，元類就是類的類，你可以這樣理解 為：
|
1
2
|
MyClass
=
MetaClass()
MyObject
=
MyClass()
|
你已經看到了type可以讓你像這樣做：
|
1
|
MyClass
=
type
(
'MyClass'
, (), {})
|
這是因為函數type實際上是一個元類。type就是Python在背 后用來創建所有類的元類。現在你想知道那為什么type會全部采用小寫形式而不是Type呢？好吧，我猜這是為了和str保持一致性，str是用來創建字 符串對象的類，而int是用來創建整數對象的類。type就是創建類對象的類。你可以通過檢查__class__屬性來看到這一點。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__屬性又是什么呢？
|
1
2
3
4
5
6
7
8
|
>>> a.__class__.__class__
<
type
'type'
>
>>> age.__class__.__class__
<
type
'type'
>
>>> foo.__class__.__class__
<
type
'type'
>
>>> b.__class__.__class__
<
type
'type'
>
|
因此，元類就是創建類這種對象的東西。如果你喜歡的話，可以把元類稱為“類工廠”（不要和工廠類搞混了:D） type就是Python的內建元類，當然了，你也可以創建自己的元類。
__metaclass__屬性
你可以在寫一個類的時候為其添加__metaclass__屬性。
|
1
2
3
|
class
Foo(
object
):
__metaclass__
=
something…
[…]
|
如果你這么做了，Python就會用元類來創建類Foo。小心點，這里面有些技巧。你首先寫下class Foo(object)，但是類對象Foo還沒有在內存中創建。Python會在類的定義中尋找__metaclass__屬性，如果找到 了，Python就會用它來創建類Foo，如果沒有找到，就會用內建的type來創建這個類。把下面這段話反復讀幾次。當你寫如下代碼時 :
|
1
2
|
class
Foo(Bar):
pass
|
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，畫畫圖理解下，這很有幫助）。所以，我們這里就先以一個簡單的函數作為例子開始。
|
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(
'__'
))
|
|
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'
|
|
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來當做元類。
|
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__方法。現在讓我們這樣去處理:
|
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一樣，所有的參數都有它們的傳統名稱。因此，在真實的 產品代碼中一個元類應該是像這樣的：
|
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繼承）
|
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。它允許你像這樣定義：
|
1
2
3
|
class
Person(models.Model):
name
=
models.CharField(max_length
=
30
)
age
=
models.IntegerField()
|
但是如果你像這樣做的話：
|
1
2
|
guy
=
Person(name
=
'bob'
, age
=
'35'
)
print
guy.age
|
這並不會返回一個IntegerField對象，而是會返回一個int，甚至可以直接從數據庫中取出數據。這是有可能的，因為 models.Model定義了__metaclass__， 並且使用了一些魔法能夠將你剛剛定義的簡單的Person類轉變成對數據庫的一個復雜hook。Django框架將這些看起來很復雜的東西通過暴露出一個 簡單的使用元類的API將其化簡，通過這個API重新創建代碼，在背后完成真正的工作。
結語
首先，你知道了類其實是能夠創建出類實例的對象。好吧，事實上，類本身也是實例，當然，它們是元類的實例。
|
1
2
3
|
>>>
class
Foo(
object
):
pass
>>>
id
(Foo)
142630324
|
Python中的一切都是對象，它們要么是類的實例，要么是元類的實例，除了type。type實際上是它自己的元類，在純Python環境中這可 不是你能夠做到的，這是通過在實現層面耍一些小手段做到的。其次，元類是很復雜的。對於非常簡單的類，你可能不希望通過使用元類來對類做修改。你可以通過 其他兩種技術來修改類：
2) class decorators
當你需要動態修改類時，99%的時間里你最好使用上面這兩種技術。當然了，其實在99%的時間里你根本就不需要動態修改類 :D