Python如何实现高效的数据结构操作？
- 内容介绍
- 文章标签
- 相关推荐
本文共计1787个文字，预计阅读时间需要8分钟。
目录背景什么是metaclass（元类）类与普通class与metaclass的关系自定义与使用metaclassmetaclass冲突（元类冲突）的澄清意义解决方案参考背景在Python中，类是对象的蓝图，而metaclass则是类的工厂，用于创建和定制类。理解metaclass对于深入探索Python的面向对象特性至关重要。
什么是metaclass（元类）metaclass是用于创建和修改类的类型的类。简单来说，它定义了类的行为。
类与普通class与metaclass的关系- 普通class：用于创建对象。- metaclass：用于创建class，即类本身的构造器。
自定义与使用metaclass自定义metaclass允许开发者定义如何创建类，从而可以控制类的创建过程。
metaclass冲突（元类冲突）的澄清意义当两个metaclass试图同时应用于一个类时，可能会发生冲突。理解这一点有助于避免不必要的错误。
解决方案避免使用多个冲突的metaclass，或使用合适的继承策略来处理。
参考- Python官方文档- 《Fluent Python》背景近期有一个需求，需要自定义一个多继承的类，这个类将继承自abc.ABC（抽象基类）和Django框架中的某个类。
目录
- 背景
- 什么是metaclass(元类)
- 类比普通class与metaclass
- 自定义与使用metaclass
- metaclass confict(元类冲突)的清晰含义
- 解决方案
- 参考
背景
最近有一个需求需要自定义一个多继承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'>
参考
www.liaoxuefeng.com/wiki/1016959663602400/1017592449371072
stackoverflow.com/questions/100003/what-are-metaclasses-in-python
www.cnblogs.com/JetpropelledSnake/p/9094103.html
www.phyast.pitt.edu/~micheles/python/metatype.html
到此这篇关于Python 多重继承时metaclass conflict问题解决与原理探究 的文章就介绍到这了,更多相关Python 多重继承内容请搜索自由互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持自由互联！
本文共计1787个文字，预计阅读时间需要8分钟。
目录背景什么是metaclass（元类）类与普通class与metaclass的关系自定义与使用metaclassmetaclass冲突（元类冲突）的澄清意义解决方案参考背景在Python中，类是对象的蓝图，而metaclass则是类的工厂，用于创建和定制类。理解metaclass对于深入探索Python的面向对象特性至关重要。
什么是metaclass（元类）metaclass是用于创建和修改类的类型的类。简单来说，它定义了类的行为。
类与普通class与metaclass的关系- 普通class：用于创建对象。- metaclass：用于创建class，即类本身的构造器。
自定义与使用metaclass自定义metaclass允许开发者定义如何创建类，从而可以控制类的创建过程。
metaclass冲突（元类冲突）的澄清意义当两个metaclass试图同时应用于一个类时，可能会发生冲突。理解这一点有助于避免不必要的错误。
解决方案避免使用多个冲突的metaclass，或使用合适的继承策略来处理。
参考- Python官方文档- 《Fluent Python》背景近期有一个需求，需要自定义一个多继承的类，这个类将继承自abc.ABC（抽象基类）和Django框架中的某个类。
目录
- 背景
- 什么是metaclass(元类)
- 类比普通class与metaclass
- 自定义与使用metaclass
- metaclass confict(元类冲突)的清晰含义
- 解决方案
- 参考
背景
最近有一个需求需要自定义一个多继承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'>
参考
www.liaoxuefeng.com/wiki/1016959663602400/1017592449371072
stackoverflow.com/questions/100003/what-are-metaclasses-in-python
www.cnblogs.com/JetpropelledSnake/p/9094103.html
www.phyast.pitt.edu/~micheles/python/metatype.html
到此这篇关于Python 多重继承时metaclass conflict问题解决与原理探究 的文章就介绍到这了,更多相关Python 多重继承内容请搜索自由互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持自由互联！