Python 多重继承时metaclass conflict问题解决与原理探究

乎语百科 109 0

背景

最近有一个需求需要自定义一个多继承abc.ABC与django.contrib.admin.ModelAdmin两个父类的抽象子类,方便不同模块复用大部分代码,同时强制必须实现所有抽象方法,没想按想当然的写法实现多继承时,居然报错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

一时之间疑惑满满,先是通过搜索快速找到了一个解决方案,但是却并没有弄明白问题的根本原因与解决方案的原理,最近终于有些时间可以深入探究一番,这里记录一下。 PS: 本文所有讨论均基于Python3,不考虑Python2的部分差异之处。

什么是metaclass(元类)

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

类比普通class与metaclass

这里采用class(类)和instance(实例)的关系来类比解释,如果要创建一个自定义class A,然后创建其实例,一般我们会这么写:

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的实例对象a,print语句的输出可以看出实例a的类型正是class A,此时如果我们进一步探究A的类型会发现:

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

A类型是 class type。 我们会说a是class A的实例,那以此类推可以说class A是class type的实例,或者换一种说法:class A的实例是a,class type的实例是A。 现在我们尝试定义metaclass: 在python中class不仅能创建实例对象,其本身也是一个对象,普通class创建实例普通对象,metaclass(元类)则创建实例class对象。 PS: 严格来说metaclass本身不一定要是一个class,它可以是任意可以返回class的callable对象,这里我们不做深入探讨。

自定义与使用metaclass

python中应该怎么定义一个metaclass呢,其实type就是一个metaclass,type是所有class的默认metaclass,而且所有自定义的metaclass 最终也都会使用到type来执行最后创建class的工作。 事实上上面使用class A... 的语法定义类A时,Python解释器最终也是调用type来创建的class A,其等价于以下代码:

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

type创建class的签名如下:

type(name, bases, attrs)
name: 要创建的class名称
bases: 要继承的父类tuple(可以为空,但python3自定义class一般都默认继承object)
attrs: 包含class定义属性名称和值的dict

绝大多数情况下我们并不需要用到metaclass,极少数需要动态创建/修改class的复杂场景比如Django的ORM才需要用到这一技术。这里举一个metaclass简单使用示例,比如我们可以简单创建一个给class统一加上其创建时间的metaclass,以满足需要时可以查看对应class首次创建时间的这个伪需求(仅为举本例而提的需求_),如下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的时候,通过指定metaclass参数告诉解释器创建class B时不使用默认的type而是使用自定义的元类AddCTimeMetaclass。

metaclass confict(元类冲突)的清晰含义

初步定义了metaclass并了解简单使用之后,我们开始正式探究metaclass conflict,一个最简单触发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,当class C试图多继承A、B时就会出问题,从字面意思理解:子类的metaclass必须是其所有基类metaclass的(非严格)子类,看起来普通class的多继承和metaclass的多继承之间发生了什么问题。 这段话具体怎么理解?我们已经知道A、B都分别具有自己的metaclass M0、M1,那么当C多继承A、B的时候C的metaclass应该是M0还是M1呢?由于M0、M1两者之间并没有继承关系,用哪个都不行,Python不知道怎么办,只能告诉你出问题了。

解决方案

那理想情况下C的metaclass到底应该是什么呢?理想情况应该如下所示:

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

即采用多继承了M0、M1的M2作为C的metaclass,这也是解决这个问题的最终方案,具体代码如下:

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

如上我们通过手动定义M2,并手动明确指定class C的metaclass为M2,如此解决metaclass conflict问题。 这时再回到开头碰到的多继承abc.ABC与admin.ModelAdmin时遇到的问题就很容易理解了:因为abc.ABC有自己的metaclass abc.ABCMeta,同时modelAdmin也有自己的metaclass django.forms.widgets.MediaDefiningClass,并且这两者之间没有继承关系,因而 class MyAdmin(abc.ABC, admin.ModelAdmin) 多继承时解释器无法推断出满足条件的metaclass,自然也就报错了,解决办法和上面的方案一样,定义一个两者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'>

转载请注明出处,原文地址:python_metaclass_conflict_study.html" rel="external nofollow noreferrer">https://www.cnblogs.com/AcAc-t/p/python_metaclass_conflict_study.html

参考

https://www.liaoxuefeng.com/wiki/1016959663602400/1017592449371072 python" rel="external nofollow noreferrer">https://stackoverflow.com/questions/100003/what-are-metaclasses-in-python https://www.cnblogs.com/JetpropelledSnake/p/9094103.html python/metatype.html" rel="external nofollow noreferrer">http://www.phyast.pitt.edu/~micheles/python/metatype.html

标签:

留言评论

  • 这篇文章还没有收到评论,赶紧来抢沙发吧~