譯注：這是一篇在Stack overflow上很熱的帖子顷帖。提問者自稱已經(jīng)掌握了有關(guān)Python OOP編程中的各種概念妄呕，但始終覺得元類(metaclass)難以理解唠粥。他知道這肯定和自省有關(guān)，但仍然覺得不太明白舅巷，希望大家可以給出一些實際的例子和代碼片段以幫助理解，以及在什么情況下需要進行元編程情屹。于是e-satis同學給出了神一般的回復(fù)喂很，該回復(fù)獲得了985點的贊同點數(shù)，更有人評論說這段回復(fù)應(yīng)該加入到Python的官方文檔中去痴怨。而e-satis同學本人在Stack Overflow中的聲望積分也高達64271分。以下就是這篇精彩的回復(fù)（提示：非常長）
1. 類也是對象
在理解元類之前反浓，你需要先掌握Python中的類萌丈。Python中類的概念借鑒于Smalltalk，這顯得有些奇特勾习。在大多數(shù)編程語言中浓瞪，類就是一組用來描述如何生成一個對象的代碼段。在Python中這一點仍然成立：
>>> class ObjectCreator(object):
… pass
…
>>> my_object = ObjectCreator()
>>> print my_object
<__main__.ObjectCreator object at 0x8974f2c>
但是巧婶，Python中的類還遠不止如此乾颁。類同樣也是一種對象。是的艺栈，沒錯英岭，就是對象。只要你使用關(guān)鍵字class湿右，Python解釋器在執(zhí)行的時候就會創(chuàng)建一個對象诅妹。下面的代碼段：
>>> class ObjectCreator(object):
… pass
…
將在內(nèi)存中創(chuàng)建一個對象，名字就是ObjectCreator毅人。這個對象（類）自身擁有創(chuàng)建對象（類實例）的能力吭狡，而這就是為什么它是一個類的原因。但是丈莺，它的本質(zhì)仍然是一個對象划煮，于是乎你可以對它做如下的操作：
你可以將它賦值給一個變量
你可以拷貝它
你可以為它增加屬性
你可以將它作為函數(shù)參數(shù)進行傳遞
下面是示例：
>>> print ObjectCreator # 你可以打印一個類，因為它其實也是一個對象
<class '__main__.ObjectCreator'>
>>> def echo(o):
… print o
…
>>> echo(ObjectCreator) # 你可以將類做為參數(shù)傳給函數(shù)
<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. 動態(tài)地創(chuàng)建類
因為類也是對象缔俄，你可以在運行時動態(tài)的創(chuàng)建它們弛秋，就像其他任何對象一樣。首先俐载，你可以在函數(shù)中創(chuàng)建類蟹略，使用class關(guān)鍵字即可。
>>> 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 # 函數(shù)返回的是類挖炬，不是類的實例
<class '__main__'.Foo>
>>> print MyClass() # 你可以通過這個類創(chuàng)建類實例，也就是對象
<__main__.Foo object at 0x89c6d4c>
但這還不夠動態(tài)贼急，因為你仍然需要自己編寫整個類的代碼茅茂。由于類也是對象捏萍，所以它們必須是通過什么東西來生成的才對。當你使用class關(guān)鍵字時空闲，Python解釋器自動創(chuàng)建這個對象令杈。但就和Python中的大多數(shù)事情一樣，Python仍然提供給你手動處理的方法碴倾。還記得內(nèi)建函數(shù)type嗎逗噩？這個古老但強大的函數(shù)能夠讓你知道一個對象的類型是什么，就像這樣：
>>> print type(1)
<type 'int'>
>>> print type("1")
<type 'str'>
>>> print type(ObjectCreator)
<type 'type'>
>>> print type(ObjectCreator())
<class '__main__.ObjectCreator'>
這里跌榔，type有一種完全不同的能力异雁，它也能動態(tài)的創(chuàng)建類。type可以接受一個類的描述作為參數(shù)僧须，然后返回一個類纲刀。（我知道，根據(jù)傳入?yún)?shù)的不同担平，同一個函數(shù)擁有兩種完全不同的用法是一件很傻的事情示绊，但這在Python中是為了保持向后兼容性）
type可以像這樣工作：
type(類名, 父類的元組（針對繼承的情況，可以為空）暂论，包含屬性的字典（名稱和值）)
比如下面的代碼：
>>> class MyShinyClass(object):
… pass
可以手動像這樣創(chuàng)建：
>>> MyShinyClass = type('MyShinyClass', (), {}) # 返回一個類對象
>>> print MyShinyClass
<class '__main__.MyShinyClass'>
>>> print MyShinyClass() # 創(chuàng)建一個該類的實例
<__main__.MyShinyClass object at 0x8997cec>
你會發(fā)現(xiàn)我們使用“MyShinyClass”作為類名面褐，并且也可以把它當做一個變量來作為類的引用。類和變量是不同的取胎，這里沒有任何理由把事情弄的復(fù)雜展哭。
type 接受一個字典來為類定義屬性，因此
>>> class Foo(object):
… bar = True
可以翻譯為：
>>> Foo = type('Foo', (), {'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
最終你會希望為你的類增加方法觉痛。只需要定義一個有著恰當簽名的函數(shù)并將其作為屬性賦值就可以了析恢。
>>> 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中秧饮，類也是對象，你可以動態(tài)的創(chuàng)建類泽篮。這就是當你使用關(guān)鍵字class時Python在幕后做的事情盗尸，而這就是通過元類來實現(xiàn)的。
3. 到底什么是元類（終于到主題了）
元類就是用來創(chuàng)建類的“東西”帽撑。你創(chuàng)建類就是為了創(chuàng)建類的實例對象泼各，不是嗎？但是我們已經(jīng)學習到了Python中的類也是對象亏拉。好吧扣蜻，元類就是用來創(chuàng)建這些類（對象）的逆巍，元類就是類的類，你可以這樣理解為：
MyClass = MetaClass()
MyObject = MyClass()
你已經(jīng)看到了type可以讓你像這樣做：
MyClass = type('MyClass', (), {})
這是因為函數(shù)type實際上是一個元類莽使。type就是Python在背后用來創(chuàng)建所有類的元類∪窦現(xiàn)在你想知道那為什么type會全部采用小寫形式而不是Type呢？好吧芳肌，我猜這是為了和str保持一致性灵再，str是用來創(chuàng)建字符串對象的類，而int是用來創(chuàng)建整數(shù)對象的類亿笤。type就是創(chuàng)建類對象的類翎迁。你可以通過檢查class屬性來看到這一點。Python中所有的東西净薛，注意汪榔，我是指所有的東西——都是對象。這包括整數(shù)肃拜、字符串痴腌、函數(shù)以及類。它們?nèi)慷际菍ο蟊啵宜鼈兌际菑囊粋€類創(chuàng)建而來衷掷。
>>> 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'>
現(xiàn)在，對于任何一個class的class屬性又是什么呢柿菩？
>>> a.__class__.__class__
<type 'type'>
>>> age.__class__.__class__
<type 'type'>
>>> foo.__class__.__class__
<type 'type'>
>>> b.__class__.__class__
<type 'type'>
因此戚嗅，元類就是創(chuàng)建類這種對象的東西。如果你喜歡的話枢舶，可以把元類稱為“類工廠”（不要和工廠類搞混了:D） type就是Python的內(nèi)建元類懦胞，當然了，你也可以創(chuàng)建自己的元類凉泄。
4. metaclass屬性
你可以在寫一個類的時候為其添加metaclass屬性躏尉。
class Foo(object):
__metaclass__ = something…
[…]
如果你這么做了，Python就會用元類來創(chuàng)建類Foo后众。小心點胀糜，這里面有些技巧。你首先寫下class Foo(object)蒂誉，但是類對象Foo還沒有在內(nèi)存中創(chuàng)建教藻。Python會在類的定義中尋找metaclass屬性，如果找到了右锨，Python就會用它來創(chuàng)建類Foo括堤，如果沒有找到，就會用內(nèi)建的type來創(chuàng)建這個類。把下面這段話反復(fù)讀幾次悄窃。當你寫如下代碼時 :
class Foo(Bar):
pass
Python做了如下的操作：
Foo中有metaclass這個屬性嗎授霸？如果是君仆，Python會在內(nèi)存中通過metaclass創(chuàng)建一個名字為Foo的類對象（我說的是類對象，請緊跟我的思路）。如果Python沒有找到metaclass指攒，它會繼續(xù)在Bar（父類）中尋找metaclass屬性劣欢，并嘗試做和前面同樣的操作忽洛。如果Python在任何父類中都找不到metaclass锭碳，它就會在模塊層次中去尋找metaclass，并嘗試做同樣的操作分唾。如果還是找不到metaclass,Python就會用內(nèi)置的type來創(chuàng)建這個類對象抗碰。
現(xiàn)在的問題就是，你可以在metaclass中放置些什么代碼呢绽乔？答案就是：可以創(chuàng)建一個類的東西弧蝇。那么什么可以用來創(chuàng)建一個類呢？type折砸，或者任何使用到type或者子類化type的東東都可以看疗。
5. 自定義元類
元類的主要目的就是為了當創(chuàng)建類時能夠自動地改變類。通常睦授，你會為API做這樣的事情两芳，你希望可以創(chuàng)建符合當前上下文的類。假想一個很傻的例子去枷，你決定在你的模塊里所有的類的屬性都應(yīng)該是大寫形式怖辆。有好幾種方法可以辦到，但其中一種就是通過在模塊級別設(shè)定metaclass删顶。采用這種方法竖螃，這個模塊中的所有類都會通過這個元類來創(chuàng)建，我們只需要告訴元類把所有的屬性都改成大寫形式就萬事大吉了逗余。
幸運的是特咆，metaclass實際上可以被任意調(diào)用，它并不需要是一個正式的類（我知道录粱，某些名字里帶有‘class’的東西并不需要是一個class腻格，畫畫圖理解下，這很有幫助）啥繁。所以荒叶，我們這里就先以一個簡單的函數(shù)作為例子開始。
# 元類會自動將你通常傳給‘type’的參數(shù)作為自己的參數(shù)傳入
def upper_attr(future_class_name, future_class_parents, future_class_attr):
'''返回一個類對象输虱，將屬性都轉(zhuǎn)為大寫形式'''
# 選擇所有不以'__'開頭的屬性
attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
# 將它們轉(zhuǎn)為大寫形式
uppercase_attr = dict((name.upper(), value) for name, value in attrs)
# 通過'type'來做類對象的創(chuàng)建
return type(future_class_name, future_class_parents, uppercase_attr)
__metaclass__ = upper_attr # 這會作用到這個模塊中的所有類
class Foo(object):
# 我們也可以只在這里定義__metaclass__，這樣就只會作用于這個類中
bar = 'bip'
print hasattr(Foo, 'bar')
# 輸出: False
print hasattr(Foo, 'BAR')
# 輸出:True
f = Foo()
print f.BAR
# 輸出:'bip'
現(xiàn)在讓我們再做一次脂凶，這一次用一個真正的class來當做元類宪睹。
# 請記住愁茁，'type'實際上是一個類，就像'str'和'int'一樣
# 所以亭病，你可以從type繼承
class UpperAttrMetaClass(type):
# __new__ 是在__init__之前被調(diào)用的特殊方法
# __new__是用來創(chuàng)建對象并返回之的方法
# 而__init__只是用來將傳入的參數(shù)初始化給對象
# 你很少用到__new__鹅很，除非你希望能夠控制對象的創(chuàng)建
# 這里，創(chuàng)建的對象是類罪帖，我們希望能夠自定義它促煮，所以我們這里改寫__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。我們直接調(diào)用了type坐昙，而且我們沒有改寫父類的new方法∩龋現(xiàn)在讓我們這樣去處理：
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)
# 復(fù)用type.__new__方法
# 這就是基本的OOP編程，沒什么魔法
return type.__new__(upperattr_metaclass, future_class_name, future_class_parents, uppercase_attr)
你可能已經(jīng)注意到了有個額外的參數(shù)upperattr_metaclass炸客，這并沒有什么特別的疾棵。類方法的第一個參數(shù)總是表示當前的實例，就像在普通的類方法中的self參數(shù)一樣痹仙。當然了是尔，為了清晰起見，這里的名字我起的比較長开仰。但是就像self一樣拟枚，所有的參數(shù)都有它們的傳統(tǒng)名稱。因此抖所，在真實的產(chǎn)品代碼中一個元類應(yīng)該是像這樣的：
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繼承）
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)
就是這樣傻粘，除此之外每窖，關(guān)于元類真的沒有別的可說的了。使用到元類的代碼比較復(fù)雜弦悉，這背后的原因倒并不是因為元類本身窒典，而是因為你通常會使用元類去做一些晦澀的事情，依賴于自省稽莉，控制繼承等等瀑志。確實，用元類來搞些“黑暗魔法”是特別有用的，因而會搞出些復(fù)雜的東西來劈猪。但就元類本身而言昧甘，它們其實是很簡單的：
攔截類的創(chuàng)建
修改類
返回修改之后的類
6. 為什么要用metaclass類而不是函數(shù)?
由于metaclass可以接受任何可調(diào)用的對象，那為何還要使用類呢战得，因為很顯然使用類會更加復(fù)雜俺浔摺？這里有好幾個原因：
1） 意圖會更加清晰常侦。當你讀到UpperAttrMetaclass(type)時浇冰，你知道接下來要發(fā)生什么。
2） 你可以使用OOP編程聋亡。元類可以從元類中繼承而來肘习，改寫父類的方法。元類甚至還可以使用元類杀捻。
3） 你可以把代碼組織的更好井厌。當你使用元類的時候肯定不會是像我上面舉的這種簡單場景，通常都是針對比較復(fù)雜的問題致讥。將多個方法歸總到一個類中會很有幫助仅仆，也會使得代碼更容易閱讀。
4） 你可以使用new, init以及call這樣的特殊方法垢袱。它們能幫你處理不同的任務(wù)墓拜。就算通常你可以把所有的東西都在new里處理掉，有些人還是覺得用init更舒服些请契。
5） 哇哦咳榜，這東西的名字是metaclass，肯定非善類爽锥，我要小心涌韩！
7. 究竟為什么要使用元類？
現(xiàn)在回到我們的大主題上來氯夷，究竟是為什么你會去使用這樣一種容易出錯且晦澀的特性臣樱？好吧，一般來說腮考，你根本就用不上它：
元類就是深度的魔法雇毫，99%的用戶應(yīng)該根本不必為此操心。如果你想搞清楚究竟是否需要用到元類踩蔚，那么你就不需要它棚放。那些實際用到元類的人都非常清楚地知道他們需要做什么，而且根本不需要解釋為什么要用元類馅闽。 —— Python界的領(lǐng)袖 Tim Peters
元類的主要用途是創(chuàng)建API飘蚯。一個典型的例子是Django ORM馍迄。它允許你像這樣定義：
class Person(models.Model):
name = models.CharField(max_length=30)
age = models.IntegerField()
但是如果你像這樣做的話：
guy = Person(name='bob', age='35')
print guy.age
這并不會返回一個IntegerField對象，而是會返回一個int孝冒，甚至可以直接從數(shù)據(jù)庫中取出數(shù)據(jù)柬姚。這是有可能的，因為models.Model定義了metaclass庄涡， 并且使用了一些魔法能夠?qū)⒛銊倓偠x的簡單的Person類轉(zhuǎn)變成對數(shù)據(jù)庫的一個復(fù)雜hook。Django框架將這些看起來很復(fù)雜的東西通過暴露出一個簡單的使用元類的API將其化簡搬设，通過這個API重新創(chuàng)建代碼穴店，在背后完成真正的工作。
8. 結(jié)語
首先拿穴，你知道了類其實是能夠創(chuàng)建出類實例的對象泣洞。好吧，事實上默色，類本身也是實例球凰，當然，它們是元類的實例腿宰。
>>>class Foo(object): pass
>>> id(Foo)
142630324
Python中的一切都是對象呕诉，它們要么是類的實例，要么是元類的實例吃度，除了type甩挫。type實際上是它自己的元類，在純Python環(huán)境中這可不是你能夠做到的椿每，這是通過在實現(xiàn)層面耍一些小手段做到的伊者。其次，元類是很復(fù)雜的间护。對于非常簡單的類亦渗，你可能不希望通過使用元類來對類做修改。你可以通過其他兩種技術(shù)來修改類：
- Monkey patching
- class decorators
當你需要動態(tài)修改類時汁尺，99%的時間里你最好使用上面這兩種技術(shù)法精。當然了，其實在99%的時間里你根本就不需要動態(tài)修改類 :D
轉(zhuǎn)自伯樂在線—深刻理解Python中的元類(metaclass)
