詳解python metaclass（元類）
超程式設計，一個聽起來特別酷的詞，強大的Lisp在這方面是好手，對於Python，儘管沒有完善的超程式設計正規化，一些天才的開發者還是創作了很多超程式設計的魔法。Django的ORM就是超程式設計的一個很好的例子。
本篇的概念和例子皆在Python3.6環境下
一切都是物件
Python裡一切都是物件（object），基本資料型別，如數字，字串，函式都是物件。物件可以由類（class）進行建立。既然一切都是物件，那麼類是物件嗎？
是的，類也是物件，那麼又是誰創造了類呢？答案也很簡單，也是類，一個能創作類的類，就像上帝一樣，開啟了萬物之始。這樣的類，稱之為元類（classmeta）。
類的定義
物件是通過類建立的，這個很好理解。例如下面的程式碼：
class Bar(object): pass bar = Bar() print(bar,bar.__class__) # <__main__.Bar object at 0x101eb4630> <class '__main__.Bar'> print(Bar,Bar.__class__) # <class '__main__.Bar'> <class 'type'>
可以看見物件 bar 是類 Bar 建立的例項。然而 Bar，看起來卻是由一個叫 type 的類建立的例項。即 bar <-- Bar < -- type
上面的例子，物件是動態建立的，類則是通過關鍵字 class 宣告定義的。class關鍵字背後的玄機是什麼呢？
實際上，class Bar(object) 這樣的程式碼，等價於 Bar = type('Bar',(objects,),{})
即類 type 通過例項化建立了它的物件 Bar，而這個 Bar 恰恰是一個類。這樣能建立類的類，就是 Python 的元類。
從建立 Bar 的程式碼上來看，元類 type 的 __init__ 方法有3個引數，
- 第一個是建立的類的名字
- 第二個是其繼承父類的元類列表，
- 最後就是一個屬性字典，即該類所具有的屬性。
type 元類
type是小寫，因而很容易誤以為它是一個函式。通過help(type)可以看到它的定義如下：
class type(object):
"""
type(object_or_name,bases,dict)
type(object) -> the object's type
type(name,dict) -> a new type
"""
def __init__(cls,what,bases=None,dict=None): # known special case of type.__init__
"""
type(object_or_name,dict)
type(object) -> the object's type
type(name,dict) -> a new type
# (copied from class doc)
"""
pass
@staticmethod # known case of __new__
def __new__(*args,**kwargs): # real signature unknown
""" Create and return a new object. See help(type) for accurate signature. """
pass
如前所述，__init__方法接受三個引數，type 例項化的過程，會建立一個新的類。建立類的程式碼來自 __new__ 方法，它的引數其實和 __init__，一樣。至於它們之間有什麼關係，後面再做介紹。目前只要知道，當呼叫 type 進行例項化的時候，會先自動呼叫 __new__ 方法，然後再接著呼叫 __init__方法，在類外面來看，最終會例項化一個物件，這個物件是一個類。
從 type 的定義來看，它繼承 object，Python3的所有類，都繼承來著 object，類type 也是 object 的例項，令人奇怪的是，object 既是類也是物件，它也是由 type例項化而來。有一種雞生蛋，蛋生雞的悖論。暫且先不管，只要知道所有類的頂級繼承來自 object 就好。
自定義元類
既然元類可以建立類，那麼自定義元類就很簡單了，直接繼承類 type 即可。先看下面一個例子：
class MyType(type): pass class Bar(object,metaclass=MyType): pass print(MyType,MyType.__class__) # <class '__main__.MyType'> <class 'type'> print(Bar,Bar.__class__) # <class '__main__.Bar'> <class '__main__.MyType'>
可以看到，Bar在宣告的時候，指定了其元類，此時的類 Bar 的__class__屬性不再是 type，而是 MyType。即之前定義 Bar 的程式碼不再是 Bar = type('Bar',{}),而是 Bar = MyType('Bar',{})。建立的元類的程式碼是MyType = type('MyType',{})。
如果一個類沒有顯示的指定其元類，那麼會沿著繼承鏈尋找父類的元類，如果一直找不到，那麼就使用預設的 type 元類。
元類衝突
每個類都可以指定元類，但是父類和子類的元類要是一條繼承關係上的，否則會出現元類衝突。並且這個繼承關係中，以繼承最後面的元類為其元類。
元類的查詢順序大致為，先檢視其繼承的父類，找到父類的元類即停止。若直接父類沒有元類，直到頂級父類 object ，此時父類（object）的元類是 type（basemetaclass），再看其自身有沒有指定元類（submetaclass），如果指定了元類（submetaclass），再對比這個子元類（submetaclass）和父元類（basemetaclass），如果它們毫無繼承關係，那麼將會丟擲元類衝突的錯誤。如果指定的子元類是父元類的父類，那麼將會使用父元類，否則將使用期指定的子元類。
即 submetaclass <- basemetaclass使用 submetaclass 作為最終元類，
若 basemetaclass <- submetaclass,使用 basemetaclass 作為最終元類,
兩者無繼承關係，丟擲衝突。
有點像繞口令，且看程式碼例子
class MyType(type):
pass
# 等價於 MyType = type('MyType',(object,{})
class Bar(object,metaclass=MyType):
pass
# 等價於 Bar = MyType('Bar',{})
class Foo(Bar):
pass
# 等價於 Foo = MyType('Foo',(Foo,object,{})
print(Bar,Bar.__class__) # <class '__main__.Bar'> <class '__main__.MyType'>
print(Foo,Foo.__class__) # <class '__main__.Foo'> <class '__main__.MyType'>
Bar的父元類（basemetaclass）type，指定子元類（submetaclass）是 MyType， MyType 繼承自 type，所以Bar的元類是 MyType。
又如：
class MyType(type): pass class Bar(object,metaclass=MyType): pass class Foo(Bar,metaclass=type): pass print(Bar,Foo.__class__) # <class '__main__.Foo'> <class '__main__.MyType'>
儘管 Foo 也指定了元類(submetaclass) type，可是其父類的元類（basemetaclass）是 MyType， MyType
是 type的子類，因此 Foo的元類拋棄了指定的(submetaclass) type，而是沿用了其父類的MyType。
當 submetaclass 和 basemetaclass 沒有繼承關係的時候，將會元類衝突
class MyType(type): pass class MyOtherType(type): pass class Bar(object,metaclass=MyOtherType): pass
執行程式碼，當定義的時候就會出現TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict)元類衝突的錯誤。
修改程式碼如下：
class MyType(type): pass class MyOtherType(MyType): pass class Bar(object,metaclass=MyOtherType): pass print(Bar,Bar.__class__) # <class '__main__.Bar'> <class '__main__.MyType'> print(Foo,Foo.__class__) # <class '__main__.Foo'> <class '__main__.MyOtherType'>
可以看到 Bar 和 Foo 分別有自己的元類，並且都符合繼承關係中尋找。再調換一下元類看看：
class MyType(type): pass class MyOtherType(MyType): pass class Bar(object,metaclass=MyOtherType): pass class Foo(Bar,metaclass=MyType): pass print(Bar,Bar.__class__) # <class '__main__.Bar'> <class '__main__.MyOtherType'> print(Foo,Foo.__class__) # <class '__main__.Foo'> <class '__main__.MyOtherType'>
都使用了Foo還是使用了元子類作為元類。究其原因，其實也很好理解。定義父類的時候，使用了元類MyOtherType 。定義子類的時候，通過繼承，找到了建立父類的元類，那麼父類就是 MyOtherType 的例項。
如果使用 MyType 做為元類，那麼他就是 MyType 的例項，MyType的例項會比MyOtherType具有的屬性少，那麼在繼承鏈上，它又是 Bar的子類，這樣看就是子類比父類還狹窄了，顯然不是一個好的關係。即變成了下面的關係
Bar <- MyOtherType
| ↑
| |
↓ |Foo <- MyType
因此當 MyType 是 MyOtherType的父類的時候，即使 Foo 指定了 MyType作為元類，還是會被忽略，使用其父元類MyOtherType。
上面的線的箭頭要一直，才能使用各自指定的元類，否則使用箭頭指向的那個類作為元類。元類沒有繼承關係，元類衝突。
物件（類）例項化
目前為止，我們瞭解了類的定義，即類是如何被元類創建出來的，但是建立的細節尚未涉及。即元類是如何通過例項化建立類的過程。這也是物件建立的過程。
前文介紹了一個物件是通過類建立的，類物件是通過元類建立的。建立類中，會先呼叫元類的__new__方法，設定其名稱，繼承關係和屬性，返回一個例項。然後再呼叫例項的__init__方法進行初始化例項物件。
class MyType(type):
def __init__(self,*args,**kwargs):
print('init ',id(self),args,kwargs)
def __new__(cls,**kwargs):
print('new',id(cls),kwargs)
instance = super(MyType,cls).__new__(cls,**kwargs)
print(id(instance))
return instance
class Bar(object,metaclass=MyType):
pass
執行程式碼可以看見輸出：
new 4323381304 ('Bar',(<class 'object'>,{'__module__': '__main__','__qualname__': 'Bar'}) {}
4323382232
init 4323382232 ('Bar','__qualname__': 'Bar'}) {}
注意，上面程式碼僅關注 Bar 類的建立，即 Bar =MyType('Bar',{})這個定義程式碼。MyType進行例項化建立 Bar的過程中，會先用 其 __new__ 方法，後者呼叫了父類 type的 __new__方法，並返回了元類的例項,同時呼叫這個例項的__init__方法，後者對改例項物件進行初始化。這也就是為什麼方法名為 __init__。
通常我們會在 __init__方法初始化一些例項物件的屬性如果 __new__ 方法什麼也不返回，那麼 __init__ 方法是不會被呼叫的。
instance = super(MyType,**kwargs)， 有的地方也喜歡寫成type.__new__或者type，前者是python中如何呼叫父類方法的問題，後者是直接使用type建立類的過程。比較推薦的寫法還是使用 super 呼叫其父類的方法的方式。
類是元類的物件，普通類建立物件的過程，也是一樣。因此，只要重寫 __new__方法，還可以實現一個類還可以建立另外一個類的例項的魔法。
移花接木
重寫 __new__ 方法，讓其建立另外一個類的例項。
class Bar:
def __init__(self,name):
self.name = name
print('Bar init')
def say(self):
print('say: Bar {}'.format(self.name))
class Foo(object):
def __init__(self):
print('self {}'.format(self))
def __new__(cls,**kwargs):
instance = super(Foo,cls).__new__(Bar,**kwargs)
print('instance {}'.format(instance))
instance.__init__('a class')
return instance
def say(self):
print('say: Foo')
m = Foo()
print('m {}'.format(m))
m.say()
輸出
instance <__main__.Bar object at 0x104033240>
Bar init
m <__main__.Bar object at 0x104033240>
say: Bar a class
在類 Foo 中，通過重寫 __new__返回了一個 Bar 類的例項物件，然後呼叫 Bar 例項的 __inti__ 方法初始化，由於返回了 bar 例項，因此 Foo 的例項沒有被建立，因此也不會呼叫它的例項方法 __inti__ 。這樣就把 移花（Bar）接木（Foo）上了。
也許有人會覺得這樣的詭異魔法有什麼用呢？實際上，Tornado框架使用了這樣的技術實現了一個叫 Configurable 的工廠類，用於建立不同網路IO下的epoll還是select模型。有興趣可以參考其實現方式。
元類的應用
討論了那麼多原理的東西，最後肯定是要應用到實際中才有意義。既然類可以被動態的建立，那麼很多定義在類的方法，豈不是也可以被動態的建立了呢。這樣就省去了很多重複工作，也能實現酷酷的超程式設計。
元類可以建立單例模式，也可以用來實現 ORM，下面介紹的是Django使用元類實現的查詢方式。更經典的model定義網上有很多例子，就不再介紹了。下面介紹一個model通過manger管理器實現查詢方法的例子
import inspect
class QuerySet:
def get(self,**kwargs):
print('get method')
return self
def filter(self,**kwargs):
print('filter method')
return self
class BaseManager:
def __init__(self):
pass
@classmethod
def from_queryset(cls,queryset_class,class_name=None):
if class_name is None:
class_name = '%sFrom%s' % (cls.__name__,queryset_class.__name__)
class_dict = {
'_queryset_class': queryset_class,}
class_dict.update(cls._get_queryset_methods(queryset_class))
return type(class_name,(cls,class_dict)
def get_queryset(self):
return self._queryset_class()
@classmethod
def _get_queryset_methods(cls,queryset_class):
def create_method(name,method):
def manager_method(self,**kwargs):
return getattr(self.get_queryset(),name)(*args,**kwargs)
manager_method.__name__ = method.__name__
manager_method.__doc__ = method.__doc__
return manager_method
new_methods = {}
for name,method in inspect.getmembers(queryset_class,predicate=inspect.isfunction):
if hasattr(cls,name):
continue
queryset_only = getattr(method,'queryset_only',None)
if queryset_only or (queryset_only is None and name.startswith('_')):
continue
new_methods[name] = create_method(name,method)
return new_methods
class Manager(BaseManager.from_queryset(QuerySet)):
pass
class ModelMetaClass(type):
def __new__(cls,**kwargs):
name,attrs = args
attrs['objects'] = Manager()
return super(ModelMetaClass,name,attrs)
class Model(object,metaclass=ModelMetaClass):
pass
class User(Model):
pass
User.objects.get()
User.objects.filter()
User.objects.filter().get()
這樣model就用使用期管理器Manger 下的方法了。通過model的元類ModelMetaClass，定義model的時候，就初始化了一個 Manger物件掛載到Model下面，而定義Manger的時候，也通過元類將QuerySet下的查詢方法掛載到Manger下了。
總結
Python裡一切都是物件，物件都是由類進行建立例項化而來。既然一切是物件，那麼類也是物件，而類這種物件又是由一種更高階類建立而來，即所謂的元類。
元類可以建立類，Python預設的元類是 type。通過繼承type，可以自定義元類，在自定義元類的時候定義或者過載 __new__，可以建立該類的例項物件，同時也可以修改類建立物件的行為。類通過 __new__建立例項物件，然後呼叫例項物件的 __init__初始化例項物件。
在使用自定義元類的時候，子類的的元類和父類的元類有關係，前者指定的元類必須和父類的元類是一個繼承關係上的，否則會出現元類衝突。子類選取元類的取決於指定的元類和父元類的繼承關係，子元類若是父元類的子類，則指定的元類為子元類，否則將會被忽略，使用父元類為其元類。
元類是超程式設計的一種技術手段，常用於實現工廠模式的策略。通過定義元類動態建立類和展開，可以實現很多設計精妙的應用。ORM 正式其中一種常用的方法。
以上就是詳解python metaclass（元類）的詳細內容，更多關於python metaclass（元類）的資料請關注我們其它相關文章！