【轉】Python 之 元類
原文鏈接: https://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python
http://python.jobbole.com/21351/
以下代碼測試環境為ptyon2.7
類也是對象
在理解元類之前,你需要先掌握Python中的類。Python中類的概念借鑒於Smalltalk,這顯得有些奇特。在大多數編程語言中,類就是一組用來描述如何生成一個對象的代碼段。在Python中這一點仍然成立:
>>> class ObjectCreator(object): ... pass ... >>> my_object = ObjectCreator() >>> print(my_object) <__main__.ObjectCreator object at 0x8974f2c>
但是,Python中的類還遠不止如此。類同樣也是一種對象。是的,沒錯,就是對象。只要你使用關鍵字class,Python解釋器在執行的時候就會創建一個對象。下面的代碼段:
>>> class ObjectCreator(object): ... pass ...
將在內存中創建一個對象,名字就是ObjectCreator。這個對象(類)自身擁有創建對象(類實例)的能力,而這就是為什麽它是一個類的原因。但是,它的本質仍然是一個對象,於是乎你可以對它做如下的操作:
1) 你可以將它賦值給一個變量
2) 你可以拷貝它
3) 你可以為它增加屬性
4) 你可以將它作為函數參數進行傳遞
下面是示例:
>>> 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關鍵字即可。
>>> 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) <type ‘type‘> >>> print type(ObjectCreator()) <class ‘__main__.ObjectCreator‘>
這裏,type有一種完全不同的能力,它也能動態的創建類。type可以接受一個類的描述作為參數,然後返回一個類。(我知道,根據傳入參數的不同,同一個函數擁有兩種完全不同的用法是一件很傻的事情,但這在Python中是為了保持向後兼容性)
type可以像這樣工作:
type(類名, 父類的元組(針對繼承的情況,可以為空),包含屬性的字典(名稱和值))
比如下面的代碼:
>>> class MyShinyClass(object): … pass
可以手動像這樣創建:
>>> MyShinyClass = type(‘MyShinyClass‘, (), {}) # 返回一個類對象 >>> print MyShinyClass <class ‘__main__.MyShinyClass‘> >>> print MyShinyClass() # 創建一個該類的實例 <__main__.MyShinyClass object at 0x8997cec>
你會發現我們使用“MyShinyClass”作為類名,並且也可以把它當做一個變量來作為類的引用。類和變量是不同的,這裏沒有任何理由把事情弄的復雜。
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
最終你會希望為你的類增加方法。只需要定義一個有著恰當簽名的函數並將其作為屬性賦值就可以了。
>>> 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中的類也是對象。好吧,元類就是用來創建這些類(對象)的,元類就是類的類,你可以這樣理解 為:
MyClass = MetaClass() MyObject = MyClass()
你已經看到了type可以讓你像這樣做:
MyClass = type(‘MyClass‘, (), {})
這是因為函數type實際上是一個元類。type就是Python在背後用來創建所有類的元類。現在你想知道那為什麽type會全部采用小寫形式而不是Type呢?好吧,我猜這是為了和str保持一致性,str是用來創建字符串對象的類,而int是用來創建整數對象的類。type就是創建類對象的類。你可以通過檢查__class__屬性來看到這一點。Python中所有的東西,註意,我是指所有的東西——都是對象。這包括整數、字符串、函數以及類。它們全部都是對象,而且它們都是從一個類創建而來。
>>> 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‘>
因此,元類就是創建類這種對象的東西。如果你喜歡的話,可以把元類稱為“類工廠”(不要和工廠類搞混了:D) type就是Python的內建元類,當然了,你也可以創建自己的元類。
__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的東東都可以。
自定義元類
元類的主要目的就是為了當創建類時能夠自動地改變類。通常,你會為API做這樣的事情,你希望可以創建符合當前上下文的類。假想一個很傻的例子,你決定在你的模塊裏所有的類的屬性都應該是大寫形式。有好幾種方法可以辦到,但其中一種就是通過在模塊級別設定__metaclass__。采用這種方法,這個模塊中的所有類都會通過這個元類來創建,我們只需要告訴元類把所有的屬性都改成大寫形式就萬事大吉了。
幸運的是,__metaclass__實際上可以被任意調用,它並不需要是一個正式的類(我知道,某些名字裏帶有‘class’的東西並不需要是一個class,畫畫圖理解下,這很有幫助)。所以,我們這裏就先以一個簡單的函數作為例子開始。
# 元類會自動將你通常傳給‘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(‘__‘)) # 將它們轉為大寫形式 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‘ print hasattr(Foo, ‘bar‘) # 輸出: False print hasattr(Foo, ‘BAR‘) # 輸出:True f = Foo() print f.BAR # 輸出:‘bip‘
# 在用 class 語句自定義類時,默認 metaclass 是 type,我們也可以指定 metaclass 來創建類。 由於 python3 和 python2 在指定類的 metaclass 語法不兼容,下面分別示例 python2 和 python3 兩個版本。 python2 版本: class Bar(object): __metaclass__ = MetaClass def __init__(self, name): self.name = name def print_name(): print(self.name) python3 版本: class Bar(object, metaclass=MetaClass): def __init__(self, name): self.name = name def print_name(): print(self.name)
現在讓我們再做一次,這一次用一個真正的class來當做元類。
# 請記住,‘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__方法。現在讓我們這樣去處理:
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一樣,所有的參數都有它們的傳統名稱。因此,在真實的產品代碼中一個元類應該是像這樣的:
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)
就是這樣,除此之外,關於元類真的沒有別的可說的了。使用到元類的代碼比較復雜,這背後的原因倒並不是因為元類本身,而是因為你通常會使用元類去做一些晦澀的事情,依賴於自省,控制繼承等等。確實,用元類來搞些“黑暗魔法”是特別有用的,因而會搞出些復雜的東西來。但就元類本身而言,它們其實是很簡單的:
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。它允許你像這樣定義:
class Person(models.Model): name = models.CharField(max_length=30) age = models.IntegerField()
但是如果你像這樣做的話:
guy = Person(name=‘bob‘, age=‘35‘) print guy.age
這並不會返回一個IntegerField對象,而是會返回一個int,甚至可以直接從數據庫中取出數據。這是有可能的,因為models.Model定義了__metaclass__, 並且使用了一些魔法能夠將你剛剛定義的簡單的Person類轉變成對數據庫的一個復雜hook。Django框架將這些看起來很復雜的東西通過暴露出一個簡單的使用元類的API將其化簡,通過這個API重新創建代碼,在背後完成真正的工作。
結語
首先,你知道了類其實是能夠創建出類實例的對象。好吧,事實上,類本身也是實例,當然,它們是元類的實例。
>>>class Foo(object): pass >>> id(Foo) 142630324
Python中的一切都是對象,它們要麽是類的實例,要麽是元類的實例,除了type。type實際上是它自己的元類,在純Python環境中這可不是你能夠做到的,這是通過在實現層面耍一些小手段做到的。其次,元類是很復雜的。對於非常簡單的類,你可能不希望通過使用元類來對類做修改。你可以通過其他兩種技術來修改類:
1) Monkey patching
2) class decorators
當你需要動態修改類時,99%的時間裏你最好使用上面這兩種技術。當然了,其實在99%的時間裏你根本就不需要動態修改類 :D
【轉】Python 之 元類