快捷導(dǎo)航

關(guān)于Python 多重繼承時(shí)metaclass conflict問題解決與原理探究

更新時(shí)間：2022年10月30日 09:53:00 作者：及時(shí)

這篇文章主要介紹了Python 多重繼承時(shí)metaclass conflict問題解決與原理探究 ,需要的朋友可以參考下

背景

最近有一個(gè)需求需要自定義一個(gè)多繼承abc.ABC與django.contrib.admin.ModelAdmin兩個(gè)父類的抽象子類，方便不同模塊復(fù)用大部分代碼，同時(shí)強(qiáng)制必須實(shí)現(xiàn)所有抽象方法，沒想按想當(dāng)然的寫法實(shí)現(xiàn)多繼承時(shí)，居然報(bào)錯(cuò)metaclass conflict：

In [1]: import abc
In [2]: from django.contrib import admin
In [3]: class MyAdmin(abc.ABC, admin.ModelAdmin):
   ...:     pass
   ...:
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-3-b159bc04ec1b> in <module>
----> 1 class MyAdmin(abc.ABC, admin.ModelAdmin):
      2     pass
      3
TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases

一時(shí)之間疑惑滿滿，先是通過搜索快速找到了一個(gè)解決方案，但是卻并沒有弄明白問題的根本原因與解決方案的原理，最近終于有些時(shí)間可以深入探究一番，這里記錄一下。
PS: 本文所有討論均基于Python3，不考慮Python2的部分差異之處。

什么是metaclass(元類)

首先要弄清楚什么是metaclass，才可能明白metaclass conflict的真正含義。

類比普通class與metaclass

這里采用class(類)和instance(實(shí)例)的關(guān)系來類比解釋，如果要?jiǎng)?chuàng)建一個(gè)自定義class A，然后創(chuàng)建其實(shí)例，一般我們會這么寫：

In [1]: class A:
    ...:     def test(self):
    ...:         print('call test')
In [2]: a = A()
In [3]: print(a, type(a))
<__main__.A object at 0x7f9f95414970> <class '__main__.A'>

如上我們自定義了class A，并且生成了class A的實(shí)例對象a，print語句的輸出可以看出實(shí)例a的類型正是class A，此時(shí)如果我們進(jìn)一步探究A的類型會發(fā)現(xiàn):

In [10]: print(type(A))
<class 'type'>

A類型是 class type。
我們會說a是class A的實(shí)例，那以此類推可以說class A是class type的實(shí)例，或者換一種說法：class A的實(shí)例是a，class type的實(shí)例是A。
現(xiàn)在我們嘗試定義metaclass：
在python中class不僅能創(chuàng)建實(shí)例對象，其本身也是一個(gè)對象，普通class創(chuàng)建實(shí)例普通對象，metaclass(元類)則創(chuàng)建實(shí)例class對象。
PS: 嚴(yán)格來說metaclass本身不一定要是一個(gè)class，它可以是任意可以返回class的callable對象，這里我們不做深入探討。

自定義與使用metaclass

在python中應(yīng)該怎么定義一個(gè)metaclass呢，其實(shí)type就是一個(gè)metaclass，type是所有class的默認(rèn)metaclass，而且所有自定義的metaclass 最終也都會使用到type來執(zhí)行最后創(chuàng)建class的工作。
事實(shí)上上面使用class A... 的語法定義類A時(shí)，Python解釋器最終也是調(diào)用type來創(chuàng)建的class A，其等價(jià)于以下代碼：

In [23]: def fn(self):
    ...:     print('call test')
    ...:
In [24]: A = type('A', (object, ), dict(test=fn))

type創(chuàng)建class的簽名如下：

type(name, bases, attrs)
name: 要?jiǎng)?chuàng)建的class名稱
bases: 要繼承的父類tuple(可以為空,但python3自定義class一般都默認(rèn)繼承object)
attrs: 包含class定義屬性名稱和值的dict

絕大多數(shù)情況下我們并不需要用到metaclass，極少數(shù)需要?jiǎng)討B(tài)創(chuàng)建/修改class的復(fù)雜場景比如Django的ORM才需要用到這一技術(shù)。這里舉一個(gè)metaclass簡單使用示例，比如我們可以簡單創(chuàng)建一個(gè)給class統(tǒng)一加上其創(chuàng)建時(shí)間的metaclass，以滿足需要時(shí)可以查看對應(yīng)class首次創(chuàng)建時(shí)間的這個(gè)偽需求(僅為舉本例而提的需求_)，如下AddCTimeMetaclass定義:

In [30]: from datetime import datetime
In [31]: class AddCTimeMetaclass(type):
    ...:     def __new__(cls, name, bases, attrs):
    ...:         attrs['ctime'] = datetime.now()
    ...:         return super().__new__(cls, name, bases, attrs)
    ...:

In [32]: class B(metaclass=AddCTimeMetaclass):
    ...:     pass
    ...:
In [33]: B.ctime
Out[33]: datetime.datetime(2022, 10, 29, 1, 22, 46, 750176)

在定義class B的時(shí)候，通過指定metaclass參數(shù)告訴解釋器創(chuàng)建class B時(shí)不使用默認(rèn)的type而是使用自定義的元類AddCTimeMetaclass。

metaclass confict(元類沖突)的清晰含義

初步定義了metaclass并了解簡單使用之后，我們開始正式探究metaclass conflict，一個(gè)最簡單觸發(fā)metaclass conflict的例子如下：

In [42]: class M0(type):
    ...:     pass
    ...:
In [43]: class M1(type):
    ...:     pass
    ...:
In [44]: class A(metaclass=M0):
    ...:     pass
    ...:
In [45]: class B(metaclass=M1):
    ...:     pass
    ...:
In [46]: class C(A, B):
    ...:     pass
    ...:
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-46-9900d594feda> in <module>
----> 1 class C(A, B):
      2     pass
      3

TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases

如上M0與M1為自定義metaclass，分別作為A、B的metaclass，當(dāng)class C試圖多繼承A、B時(shí)就會出問題，從字面意思理解：子類的metaclass必須是其所有基類metaclass的(非嚴(yán)格)子類，看起來普通class的多繼承和metaclass的多繼承之間發(fā)生了什么問題。
這段話具體怎么理解？我們已經(jīng)知道A、B都分別具有自己的metaclass M0、M1，那么當(dāng)C多繼承A、B的時(shí)候C的metaclass應(yīng)該是M0還是M1呢？由于M0、M1兩者之間并沒有繼承關(guān)系，用哪個(gè)都不行，Python不知道怎么辦，只能告訴你出問題了。

解決方案

那理想情況下C的metaclass到底應(yīng)該是什么呢？理想情況應(yīng)該如下所示：

M0     M1
 : \   / :
 :  \ /  :
 A  M2  B
  \  :  /
   \ : /
     C

即采用多繼承了M0、M1的M2作為C的metaclass，這也是解決這個(gè)問題的最終方案，具體代碼如下：

In [58]: class M2(M0, M1):
    ...:     pass
    ...:
In [59]: class C(A, B, metaclass=M2):
    ...:     pass
    ...:

如上我們通過手動(dòng)定義M2，并手動(dòng)明確指定class C的metaclass為M2，如此解決metaclass conflict問題。
這時(shí)再回到開頭碰到的多繼承abc.ABC與admin.ModelAdmin時(shí)遇到的問題就很容易理解了：因?yàn)閍bc.ABC有自己的metaclass abc.ABCMeta，同時(shí)modelAdmin也有自己的metaclass django.forms.widgets.MediaDefiningClass，并且這兩者之間沒有繼承關(guān)系，因而 class MyAdmin(abc.ABC, admin.ModelAdmin) 多繼承時(shí)解釋器無法推斷出滿足條件的metaclass，自然也就報(bào)錯(cuò)了，解決辦法和上面的方案一樣，定義一個(gè)兩者metaclass的子類并將其指定為MyAdmin的metaclass即可，代碼如下：

In [112]: print(type(abc.ABC), type(admin.ModelAdmin))
<class 'abc.ABCMeta'> <class 'django.forms.widgets.MediaDefiningClass'>
In [113]: class MyMeta(type(abc.ABC), type(admin.ModelAdmin)):
     ...:     pass
     ...:
In [114]: class MyAdmin(abc.ABC, admin.ModelAdmin, metaclass=MyMeta):
     ...:     pass
     ...:
In [115]: print(type(MyAdmin))
<class '__main__.MyMeta'>