本文轉(zhuǎn)自:（英文版）https://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python

　　　　? (翻譯版)?? http://python.jobbole.com/21351/

以下代碼測(cè)試環(huán)境為ptyon2.7

類也是對(duì)象

　　在理解元類之前，你需要先掌握Python中的類。Python中類的概念借鑒于Smalltalk，這顯得有些奇特。在大多數(shù)編程語(yǔ)言中，類就是一組用來描述如何生成一個(gè)對(duì)象的代碼段。在Python中這一點(diǎn)仍然成立：

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

　　但是，Python中的類還遠(yuǎn)不止如此。類同樣也是一種對(duì)象。是的，沒錯(cuò)，就是對(duì)象。只要你使用關(guān)鍵字class，Python解釋器在執(zhí)行的時(shí)候就會(huì)創(chuàng)建一個(gè)對(duì)象。下面的代碼段：

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

　　將在內(nèi)存中創(chuàng)建一個(gè)對(duì)象，名字就是ObjectCreator。這個(gè)對(duì)象（類）自身?yè)碛袆?chuàng)建對(duì)象（類實(shí)例）的能力，而這就是為什么它是一個(gè)類的原因。但是，它的本質(zhì)仍然是一個(gè)對(duì)象，于是乎你可以對(duì)它做如下的操作：

　　1) ??你可以將它賦值給一個(gè)變量

　　2) ??你可以拷貝它

　　3) ??你可以為它增加屬性

　　4) ??你可以將它作為函數(shù)參數(shù)進(jìn)行傳遞

　　下面是示例：

>>> print ObjectCreator # 你可以打印一個(gè)類，因?yàn)樗鋵?shí)也是一個(gè)對(duì)象 <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 # 你可以將類賦值給一個(gè)變量 >>> print ObjectCreatorMirror() <__main__.ObjectCreator object at 0x8997b4c>

　　動(dòng)態(tài)地創(chuàng)建類

因?yàn)轭愐彩菍?duì)象，你可以在運(yùn)行時(shí)動(dòng)態(tài)的創(chuàng)建它們，就像其他任何對(duì)象一樣。首先，你可以在函數(shù)中創(chuàng)建類，使用class關(guān)鍵字即可。

>>> def choose_class(name): … if name == 'foo': … class Foo(object): … pass … return Foo # 返回的是類，不是類的實(shí)例 … else: … class Bar(object): … pass … return Bar … >>> MyClass = choose_class('foo') >>> print MyClass # 函數(shù)返回的是類，不是類的實(shí)例 <class '__main__'.Foo> >>> print MyClass() # 你可以通過這個(gè)類創(chuàng)建類實(shí)例，也就是對(duì)象 <__main__.Foo object at 0x89c6d4c>

　　但這還不夠動(dòng)態(tài)，因?yàn)槟闳匀恍枰约壕帉懻麄€(gè)類的代碼。由于類也是對(duì)象，所以它們必須是通過什么東西來生成的才對(duì)。當(dāng)你使用class關(guān)鍵字時(shí)，Python解釋器自動(dòng)創(chuàng)建這個(gè)對(duì)象。但就和Python中的大多數(shù)事情一樣，Python仍然提供給你手動(dòng)處理的方法。還記得內(nèi)建函數(shù)type嗎？這個(gè)古老但強(qiáng)大的函數(shù)能夠讓你知道一個(gè)對(duì)象的類型是什么，就像這樣：

>>> print type(1) <type 'int'> >>> print type("1") <type 'str'> >>> print type(ObjectCreator) <type 'type'> >>> print type(ObjectCreator()) <class '__main__.ObjectCreator'>

　　這里，type有一種完全不同的能力，它也能動(dòng)態(tài)的創(chuàng)建類。type可以接受一個(gè)類的描述作為參數(shù)，然后返回一個(gè)類。（我知道，根據(jù)傳入?yún)?shù)的不同，同一個(gè)函數(shù)擁有兩種完全不同的用法是一件很傻的事情，但這在Python中是為了保持向后兼容性）

type可以像這樣工作：

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

　　比如下面的代碼：

>>> class MyShinyClass(object): … pass

　　可以手動(dòng)像這樣創(chuàng)建：

>>> MyShinyClass = type('MyShinyClass', (), {}) # 返回一個(gè)類對(duì)象 >>> print MyShinyClass <class '__main__.MyShinyClass'> >>> print MyShinyClass() # 創(chuàng)建一個(gè)該類的實(shí)例 <__main__.MyShinyClass object at 0x8997cec>　

　　你會(huì)發(fā)現(xiàn)我們使用“MyShinyClass”作為類名，并且也可以把它當(dāng)做一個(gè)變量來作為類的引用。類和變量是不同的，這里沒有任何理由把事情弄的復(fù)雜。

　　type 接受一個(gè)字典來為類定義屬性，因此:

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

　　可以翻譯為：

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

　　并且可以將Foo當(dāng)成一個(gè)普通的類一樣使用：

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

　　當(dāng)然，你可以向這個(gè)類繼承，所以，如下的代碼：

>>> class FooChild(Foo): … pass

　　就可以寫成：

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

　　最終你會(huì)希望為你的類增加方法。只需要定義一個(gè)有著恰當(dāng)簽名的函數(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中，類也是對(duì)象，你可以動(dòng)態(tài)的創(chuàng)建類。這就是當(dāng)你使用關(guān)鍵字class時(shí)Python在幕后做的事情，而這就是通過元類來實(shí)現(xiàn)的。

　　到底什么是元類（終于到主題了）

元類就是用來創(chuàng)建類的“東西”。你創(chuàng)建類就是為了創(chuàng)建類的實(shí)例對(duì)象，不是嗎？但是我們已經(jīng)學(xué)習(xí)到了Python中的類也是對(duì)象。好吧，元類就是用來創(chuàng)建這些類（對(duì)象）的，元類就是類的類，你可以這樣理解 為：

MyClass = MetaClass() MyObject = MyClass()

　　你已經(jīng)看到了type可以讓你像這樣做：

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

　　這是因?yàn)楹瘮?shù)type實(shí)際上是一個(gè)元類。type就是Python在背后用來創(chuàng)建所有類的元類。現(xiàn)在你想知道那為什么type會(huì)全部采用小寫形式而不是Type呢？好吧，我猜這是為了和str保持一致性，str是用來創(chuàng)建字符串對(duì)象的類，而int是用來創(chuàng)建整數(shù)對(duì)象的類。type就是創(chuàng)建類對(duì)象的類。你可以通過檢查__class__屬性來看到這一點(diǎn)。Python中所有的東西，注意，我是指所有的東西——都是對(duì)象。這包括整數(shù)、字符串、函數(shù)以及類。它們?nèi)慷际菍?duì)象，而且它們都是從一個(gè)類創(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)在，對(duì)于任何一個(gè)__class__的__class__屬性又是什么呢？

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

　　因此，元類就是創(chuàng)建類這種對(duì)象的東西。如果你喜歡的話，可以把元類稱為“類工廠”（不要和工廠類搞混了:D） type就是Python的內(nèi)建元類，當(dāng)然了，你也可以創(chuàng)建自己的元類。

　　__metaclass__屬性

你可以在寫一個(gè)類的時(shí)候?yàn)槠涮砑觃_metaclass__屬性。

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

　　如果你這么做了，Python就會(huì)用元類來創(chuàng)建類Foo。小心點(diǎn)，這里面有些技巧。你首先寫下class Foo(object)，但是類對(duì)象Foo還沒有在內(nèi)存中創(chuàng)建。Python會(huì)在類的定義中尋找__metaclass__屬性，如果找到了，Python就會(huì)用它來創(chuàng)建類Foo，如果沒有找到，就會(huì)用內(nèi)建的type來創(chuàng)建這個(gè)類。把下面這段話反復(fù)讀幾次。當(dāng)你寫如下代碼時(shí) :

class Foo(Bar):pass

　　

　　Python做了如下的操作：

　　Foo中有__metaclass__這個(gè)屬性嗎？如果是，Python會(huì)在內(nèi)存中通過__metaclass__創(chuàng)建一個(gè)名字為Foo的類對(duì)象（我說的是類對(duì)象，請(qǐng)緊跟我的思路）。如果Python沒有找到__metaclass__，它會(huì)繼續(xù)在Bar（父類）中尋找__metaclass__屬性，并嘗試做和前面同樣的操作。如果Python在任何父類中都找不到__metaclass__，它就會(huì)在模塊層次中去尋找__metaclass__，并嘗試做同樣的操作。如果還是找不到__metaclass__,Python就會(huì)用內(nèi)置的type來創(chuàng)建這個(gè)類對(duì)象。

現(xiàn)在的問題就是，你可以在__metaclass__中放置些什么代碼呢？答案就是：可以創(chuàng)建一個(gè)類的東西。那么什么可以用來創(chuàng)建一個(gè)類呢？type，或者任何使用到type或者子類化type的東東都可以。

?

自定義元類

　　元類的主要目的就是為了當(dāng)創(chuàng)建類時(shí)能夠自動(dòng)地改變類。通常，你會(huì)為API做這樣的事情，你希望可以創(chuàng)建符合當(dāng)前上下文的類。假想一個(gè)很傻的例子，你決定在你的模塊里所有的類的屬性都應(yīng)該是大寫形式。有好幾種方法可以辦到，但其中一種就是通過在模塊級(jí)別設(shè)定__metaclass__。采用這種方法，這個(gè)模塊中的所有類都會(huì)通過這個(gè)元類來創(chuàng)建，我們只需要告訴元類把所有的屬性都改成大寫形式就萬(wàn)事大吉了。

　　幸運(yùn)的是，__metaclass__實(shí)際上可以被任意調(diào)用，它并不需要是一個(gè)正式的類（我知道，某些名字里帶有‘class’的東西并不需要是一個(gè)class，畫畫圖理解下，這很有幫助）。所以，我們這里就先以一個(gè)簡(jiǎn)單的函數(shù)作為例子開始。

# 元類會(huì)自動(dòng)將你通常傳給‘type’的參數(shù)作為自己的參數(shù)傳入 def upper_attr(future_class_name, future_class_parents, future_class_attr):'''返回一個(gè)類對(duì)象，將屬性都轉(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'來做類對(duì)象的創(chuàng)建return type(future_class_name, future_class_parents, uppercase_attr)__metaclass__ = upper_attr # 這會(huì)作用到這個(gè)模塊中的所有類class Foo(object):# 我們也可以只在這里定義__metaclass__，這樣就只會(huì)作用于這個(gè)類中bar = 'bip'print hasattr(Foo, 'bar') # 輸出: False print hasattr(Foo, 'BAR') # 輸出:True f = Foo() print f.BAR # 輸出:'bip' 在用 class 語(yǔ)句自定義類時(shí)，默認(rèn) metaclass 是 type，我們也可以指定 metaclass 來創(chuàng)建類。 由于 python3 和 python2 在指定類的 metaclass 語(yǔ)法不兼容，下面分別示例 python2 和 python3 兩個(gè)版本。python2 版本：class Bar(object):__metaclass__ = MetaClassdef __init__(self, name):self.name = namedef print_name():print(self.name)python3 版本：class Bar(object, metaclass=MetaClass):def __init__(self, name):self.name = namedef print_name():print(self.name) Python3.x實(shí)現(xiàn)上述方式

?

　　現(xiàn)在讓我們?cè)僮鲆淮?#xff0c;這一次用一個(gè)真正的class來當(dāng)做元類。

# 請(qǐng)記住，'type'實(shí)際上是一個(gè)類，就像'str'和'int'一樣 # 所以，你可以從type繼承 class UpperAttrMetaClass(type):# __new__ 是在__init__之前被調(diào)用的特殊方法# __new__是用來創(chuàng)建對(duì)象并返回之的方法# 而__init__只是用來將傳入的參數(shù)初始化給對(duì)象# 你很少用到__new__，除非你希望能夠控制對(duì)象的創(chuàng)建# 這里，創(chuàng)建的對(duì)象是類，我們希望能夠自定義它，所以我們這里改寫__new__# 如果你希望的話，你也可以在__init__中做些事情# 還有一些高級(jí)的用法會(huì)涉及到改寫__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)

　　但是，這種方式其實(shí)不是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)注意到了有個(gè)額外的參數(shù)upperattr_metaclass，這并沒有什么特別的。類方法的第一個(gè)參數(shù)總是表示當(dāng)前的實(shí)例，就像在普通的類方法中的self參數(shù)一樣。當(dāng)然了，為了清晰起見，這里的名字我起的比較長(zhǎng)。但是就像self一樣，所有的參數(shù)都有它們的傳統(tǒng)名稱。因此，在真實(shí)的產(chǎn)品代碼中一個(gè)元類應(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方法的話，我們還可以使它變得更清晰一些，這會(huì)緩解繼承（是的，你可以擁有元類，從元類繼承，從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ù)雜，這背后的原因倒并不是因?yàn)樵惐旧?#xff0c;而是因?yàn)槟阃ǔ?huì)使用元類去做一些晦澀的事情，依賴于自省，控制繼承等等。確實(shí)，用元類來搞些“黑暗魔法”是特別有用的，因而會(huì)搞出些復(fù)雜的東西來。但就元類本身而言，它們其實(shí)是很簡(jiǎn)單的：

　　1) ??攔截類的創(chuàng)建

　　2) ? 修改類

　　3) ? 返回修改之后的類

?

為什么要用metaclass類而不是函數(shù)?

　　由于__metaclass__可以接受任何可調(diào)用的對(duì)象，那為何還要使用類呢，因?yàn)楹茱@然使用類會(huì)更加復(fù)雜啊？這里有好幾個(gè)原因：

　　1） ?意圖會(huì)更加清晰。當(dāng)你讀到UpperAttrMetaclass(type)時(shí)，你知道接下來要發(fā)生什么。

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

　　3） ?你可以把代碼組織的更好。當(dāng)你使用元類的時(shí)候肯定不會(huì)是像我上面舉的這種簡(jiǎn)單場(chǎng)景，通常都是針對(duì)比較復(fù)雜的問題。將多個(gè)方法歸總到一個(gè)類中會(huì)很有幫助，也會(huì)使得代碼更容易閱讀。

　　4） 你可以使用__new__, __init__以及__call__這樣的特殊方法。它們能幫你處理不同的任務(wù)。就算通常你可以把所有的東西都在__new__里處理掉，有些人還是覺得用__init__更舒服些。

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

?

究竟為什么要使用元類？

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

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

　　元類的主要用途是創(chuàng)建API。一個(gè)典型的例子是Django ORM。它允許你像這樣定義：

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

　　但是如果你像這樣做的話：

guy = Person(name='bob', age='35') print guy.age

　　這并不會(huì)返回一個(gè)IntegerField對(duì)象，而是會(huì)返回一個(gè)int，甚至可以直接從數(shù)據(jù)庫(kù)中取出數(shù)據(jù)。這是有可能的，因?yàn)閙odels.Model定義了__metaclass__， 并且使用了一些魔法能夠?qū)⒛銊倓偠x的簡(jiǎn)單的Person類轉(zhuǎn)變成對(duì)數(shù)據(jù)庫(kù)的一個(gè)復(fù)雜hook。Django框架將這些看起來很復(fù)雜的東西通過暴露出一個(gè)簡(jiǎn)單的使用元類的API將其化簡(jiǎn)，通過這個(gè)API重新創(chuàng)建代碼，在背后完成真正的工作。

?

結(jié)語(yǔ)

　　首先，你知道了類其實(shí)是能夠創(chuàng)建出類實(shí)例的對(duì)象。好吧，事實(shí)上，類本身也是實(shí)例，當(dāng)然，它們是元類的實(shí)例。

>>>class Foo(object): pass >>> id(Foo) 142630324

　　Python中的一切都是對(duì)象，它們要么是類的實(shí)例，要么是元類的實(shí)例，除了type。type實(shí)際上是它自己的元類，在純Python環(huán)境中這可不是你能夠做到的，這是通過在實(shí)現(xiàn)層面耍一些小手段做到的。其次，元類是很復(fù)雜的。對(duì)于非常簡(jiǎn)單的類，你可能不希望通過使用元類來對(duì)類做修改。你可以通過其他兩種技術(shù)來修改類：

　　1）?Monkey patching

　　2) ? class decorators

　　當(dāng)你需要?jiǎng)討B(tài)修改類時(shí)，99%的時(shí)間里你最好使用上面這兩種技術(shù)。當(dāng)然了，其實(shí)在99%的時(shí)間里你根本就不需要?jiǎng)討B(tài)修改類 :D

?

轉(zhuǎn)載于:https://www.cnblogs.com/vipchenwei/p/7239953.html

總結(jié)

以上是生活随笔為你收集整理的深度理解python中的元类的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。