Python Advanced - MRO et Super in Inheritance
Écrit devant
Sauf indication contraire, ce qui suit est basé sur Python3
Résumé
Cet article décrit comment appeler la méthode "classe parent" via Python dans la relation d'héritage super(), et super(Type, CurrentClass) renvoie le proxy de la classe suivante dans CurrentClass de MRO ;Et comment concevoir la classe Type pour qu'elle s'initialise correctement. Python
1. Appel des méthodes de la classe parent en héritage simple
En héritage, il est nécessaire d'appeler les méthodes de la classe parent. Il existe de nombreux scénarios pour appeler les méthodes de la classe parent :
L'héritage unique est la relation d'héritage la plus simple. L'héritage multiple est trop compliqué et sujet aux erreurs à utiliser. Par conséquent, certains langages de haut niveau abandonnent complètement l'héritage multiple et ne prennent en charge que l'héritage unique ; bien que certains langages de haut niveau prennent en charge l'héritage multiple, l'héritage multiple n'est pas recommandé.
La même chose est vraie. Lorsque vous ne pouvez pas pleinement comprendre l'héritage multiple, il est préférable de ne pas l'utiliser. L'héritage unique peut répondre à la plupart des besoins. Python
1.1 Appel en mode non contraignant
La différence et la connexion entre les méthodes liées et les méthodes non contraignantes voir : Python Basics - Classes
S'il existe deux classes avec le relation d'héritage suivante :
class D(object):def test(self):print('test in D')class C(D):def test(self):print('test in C')
D.test(self)Copier après la connexion
nécessite désormais d'appeler l'
implémentation de la classe parent C dans la fonction test de la sous-classe D. La méthode la plus directe à laquelle nous pouvons penser est probablement de référencer directement le membre de la fonction test de l'objet de classe D : test
class D(object):def test(self):print('test in D')class C(D):def test(self):print('test in C')
Copier après la connexion
Essayez de le tester :
c = C()
c.test()
Copier après la connexion
sortie :
test in C
test in D
Copier après la connexion
Il semble que la méthode non contraignante réponde aux besoins actuels d'appel des méthodes de classe parent.
1.2 fonction intégrée super
Reportez-vous à la description de super dans le didacticiel Python :
super([type[, object-or-type]])
Renvoyer un objet proxy qui délègue les appels de méthode à un parent ou un frère ou une sœur. classe de type. Ceci est utile pour accéder aux méthodes héritées qui ont été remplacées dans une classe. L'ordre de recherche est le même que celui utilisé par getattr() sauf que le type lui-même est ignoré.
La fonction renvoie l'objet proxy appelé par la méthode de classe parent ou de classe frère de la classe déléguée super. typeUtilisé pour appeler les méthodes de classe parent qui ont été remplacées dans les sous-classes. L'ordre de recherche des méthodes est le même que pour les fonctions super, sauf que la classe de paramètres getattr() elle-même est ignorée. type
1.3 Appel en mode liaison
Lors de l'appel de la méthode de classe parent en mode liaison, naturellement le paramètre objet actuel (
) ne peut pas être transmis explicitement. Maintenant, la fonction self peut définir le proxy de la classe parent, car dans l'héritage simple, la sous-classe a et n'a qu'une seule classe parent, donc la classe parent est claire et nous savons parfaitement quelle méthode de classe parent est appelée : super
class D(object):def test(self):print('test in D')class C(D):def test(self):print('test in C')super().test() # super(C, self).test()的省略形式
Copier après la connexion
2. Aller plus loin dans super
En fait, l'objet proxy renvoyé par la fonction
est un super, comme son nom l'indique, le class bultin class super proxy La classe parent de la sous-classe. Dans une relation d'héritage unique, est-il facile de trouver la classe que super représente ? C'est la seule classe parent de la sous-classe, mais dans une relation d'héritage multiple, en plus de la classe parent de la sous-classe, super peut représente également la sous-classe. Un frère de la classe. super
2.1 Héritage multiple complexe
Dans les relations d'héritage multiples, la relation d'héritage peut être assez complexe. La hiérarchie d'héritage de
class D(object): def test(self):print('test in D')class C(D): def test(self):print('test in C')class B(D): def test(self):print('test in B')class A(B, C):pass
Copier après la connexion
Classe
est la suivante : A
object
|
D
/ \
B C
\ /
ACopier après la connexion
Il existe une structure en diamant dans la relation d'héritage de classe
, qui c'est-à-dire que plusieurs lignes peuvent être transmises. Le chemin va de la classe A à une classe parent, dans ce cas A. D
Si vous devez maintenant appeler la méthode
de "Aclasse parent " dans la classe , vous avez besoin d'un ordre de recherche et d'analyse pour le Méthode test , pour décider d'appeler ou non la méthode test de B,C或D. test
2.2 Ordre de résolution des méthodes (MRO)
L'ordre de recherche des méthodes de
proposé ci-dessus est l'ordre de résolution des méthodes. test
Profondeur d'abord
Dans les classes à l'ancienne, l'ordre de résolution des méthodes est la profondeur d'abord, avec plusieurs classes parents de gauche à droite. Python
En largeur d'abord
Dans les classes de nouveau style, l'ordre de résolution des méthodes est en largeur d'abord, avec plusieurs classes parents de gauche à droite. Python
L'ordre d'analyse ci-dessus est donc :
. Dans A -> B -> C -> D -> object
, l'attribut Python de la classe affiche l'ordre de recherche de la méthode. Vous pouvez appeler la méthode __mro__ ou citer directement mro() pour obtenir l'ordre de recherche : __mro__<🎜. >
output:
[<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>]
(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>)
Copier après la connexion
所以
a = A()
a.test() # output: test in B
Copier après la connexion
变化的MRO
即使是同一个类，在不同的MRO中位置的前后关系都是不同的。如以下类：
class D(object): def test(self):print('test in D')class C(D): def test(self):print('test in C')class B(D): def test(self):print('test in B')
Copier après la connexion
类B的继承层次结构为：
object
|
D
/ \
C BCopier après la connexion
类B的MRO：B -> D -> object
对比类A的MRO：A -> B -> C -> D -> object
同样的类B，在两个不同的MRO中位置关系也是不同的。可以说，在已有的继承关系中加入新的子类，会在MRO中引入新的类，并且改变解析顺序。
那么可以想象，同样在类B的test中通过super调用父类方法，在不同的MRO中实际调用的方法是不同的。
如下：
class D(object): def test(self):print('test in D')class C(D): def test(self):print('test in C')super().test()class B(D): def test(self):print('test in B')super().test()class A(B, C):passb = B()
b.test()print('==========')
a = A()
a.test()
Copier après la connexion
output:
test in B
test in D==========test in B
test in C
test in D
Copier après la connexion
因为在原有的类关系中加入B和C的子类A，使得在B的test方法中调用super的test方法发生了改变，原来调用的是其父类D的test方法，现在调用的是其兄弟类C的test方法。
从这里可以看出super不总是代理子类的父类，还有可能代理其兄弟类。
因此在设计多继承关系的类体系时，要特别注意这一点。
2.3 再看super方法
方法super([type[, object-or-type]])，返回的是对type的父类或兄弟类的代理。
如果第二个参数省略，返回的super对象是未绑定到确定的MRO上的：
如果第二个参数是对象，那么isinstance(obj, type)必须为True；
如果第二个参数是类型，那么issubclass(type2, type)必须为True，即第二个参数类型是第一个参数类型的子类。
在super函数的第二个参数存在时，其实现大概如以下：
def super(cls, inst):
mro = inst.__class__.mro() # Always the most derived classreturn mro[mro.index(cls) + 1]Copier après la connexion
很明显，super返回在第二个参数对应类的MRO列表中，第一个参数type的下一个类的代理。因此，要求第一个参数type存在于第二个参数类的MRO是必要的，只有第一个参数类是第二个参数所对应类的父类，才能保证。
super()
super函数是要求有参数的，不存在无参的super函数。在类定义中以super()方式调用，是一种省略写法，由解释器填充必要参数。填充的第一个参数是当前类，第二个参数是self：
super() => super(current_class, self)
Copier après la connexion
所以，super()这种写法注定只能在类定义中使用。
现在再来看上面的继承关系：
class D(object):def test(self):print('test in D')class C(D):def test(self):print('test in C')# super().test() # 与下面的写法等价super(C, self).test() # 返回self对应类的MRO中，类C的下一个类的代理class B(D):def test(self):print('test in B')# super().test() # 与下面的写法等价super(B, self).test() # 返回self对应类的MRO中，类B的下一个类的代理class A(B, C):passCopier après la connexion
因此：
b = B()
b.test() # 基于类B的MRO(B->D->object)，类B中的super()代理Dprint('==========')
a = A()
a.test() # 基于类A的MRO(A->B->C->D->object)，类B中的super()代理C
Copier après la connexion
以上就是在继承关系中引入新类，改变方法解析顺序的实例。
super([type[, object-or-type]])的第二个参数，对象和类还有一点区别：使用对象返回的是代理使用绑定方法，使用类返回的代理使用非绑定方法。
如：
b = B()super(B, b).test()super(B, B).test(b)
Copier après la connexion
这两种方式得到的结果是相同的，区别在于非绑定调用与绑定调用。
3. 最佳实践
3.1 不可预测的调用
普通的函数或者方法调用中，调用者肯定事先知道被调用者所需的参数，然后可以轻松的组织参数调用。但是在多继承关系中，情况有些尴尬，使用super代理调用方法，编写类的作者并不知道最终会调用哪个类的方法，这个类都可能尚未存在。
如现在一作者编写了以下类：
class D(object):def test(self):print('test in D')
class B(D):def test(self):print('test in B')super().test()
Copier après la connexion
在定义类D时，作者完全不可能知道test方法中的super().test()最终会调用到哪个类。
因为如果后来有人在这个类体系的基础上，引入了如下类：
class C(D):def test(self):print('test in C')super().test()
class A(B, C):passa = A()
a.test()
Copier après la connexion
此时会发现类B的test方法中super().test()调用了非原作者编写的类的方法。
这里test方法的参数都是确定的，但是在实际生产中，可能各个类的test方法都是不同的，如果新引入的类C需要不同的参数：
class C(D):def test(self, param_c):print('test in C, param is', param_c)super().test()
class A(B, C):passa = A()
a.test()
Copier après la connexion
类B的调用方式调用类C的test方法肯定会失败，因为没有提供任何参数。类C的作者是不可能去修改类B的实现。那么，如何适应这种参数变换的需求，是在设计Python类中需要考虑的问题。
3.2 实践建议
事实上，这种参数的变换在构造方法上能体现得淋漓尽致，如果子类没有正确初始化父类，那么子类甚至不能从父类继承到需要的实例属性。
所以，Python的类必须设计友好，才能拓展，有以下三条指导原则：
通过super()调用的方法必须存在；
调用者和被调用者参数必须匹配；
所有对父类方法的调用都必须使用super()
3.3 参数匹配
super()代理的类是不可预测的，需要匹配调用者和可能未知的调用者的参数。
固定参数
一种方法是使用位置参数固定函数签名。就像以上使用的test()一样，其签名是固定的，只要要传递固定的参数，总是不会出错。
关键字参数
每个类的构造方法可能需要不同的参数，这时固定参数满足不了这种需求了。幸好，Python中的关键字参数可以满足不定参数的需求。设计函数参数时，参数由关键字参数和关键字参数字典组成，在调用链中，每一个函数获取其所需的关键字参数，保留不需要的参数到**kwargs中，传递到调用链的下一个函数，最终**kwargs为空时，调用调用链中的最后一个函数。
示例：
class Shape(object):def __init__(self, shapename, **kwargs):self.shapename = shapenamesuper().__init__(**kwargs)class ColoredShape(Shape):def __init__(self, color, **kwargs):self.color = colorsuper().__init__(**kwargs)
cs = ColoredShape(color='red', shapename='circle')
Copier après la connexion
参数的剥落步骤为：
使用cs = ColoredShape(color='red', shapename='circle')初始化ColoredShape；
ColoredShape的__init__方法获取其需要的关键字参数color，此时的kwargs为{shapename:'circle'};
调用调用链中Shape的__init__方法，该方法获取所需关键字参数shapename，此时kwargs为{};
最后调用调用链末端objet.__init__，此时因为kwargs已经为空。
初始化子类传递的关键字参数尤为重要，如果少传或多传，都会导致初始化不成功。只有MRO中每个类的方法都是用super()来调用“父类”方法时，才能保证super()调用链不会断掉。
3.4 保证方法存在
上面的例子中，由于顶层父类object总是存在__init__方法，在任何MRO链中也总是最后一个，因此任意的super().__init__调用总能保证是object.__init__结束。
但是其他自定义的方法得不到这样的保证。这时需要手动创建类似object的顶层父类：
class Root:def draw(self):# the delegation chain stops hereassert not hasattr(super(), 'draw')class Shape(Root):def __init__(self, shapename, **kwds):self.shapename = shapenamesuper().__init__(**kwds)def draw(self):print('Drawing. Setting shape to:', self.shapename)super().draw()class ColoredShape(Shape):def __init__(self, color, **kwds):self.color = colorsuper().__init__(**kwds)def draw(self):print('Drawing. Setting color to:', self.color)super().draw()
cs = ColoredShape(color='blue', shapename='square')
cs.draw()
Copier après la connexion
如果有新的类要加入到这个MRO体系，新的子类也要继承Root，这样，所有的对draw()的调用都会经过Root，而不会到达没有draw方法的object了。这种对于子类的扩展要求，应当详细注明在文档中，便于使用者阅读。这种限制与Python所有异常都必须继承自BaseException一样。
3.5 组合不友好的类
对于那些不友好的类:
class Moveable:def __init__(self, x, y):self.x = xself.y = ydef draw(self):print('Drawing at position:', self.x, self.y)
Copier après la connexion
如果希望使用它的功能，直接将其加入到我们友好的继承体系中，会破坏原有类的友好性。
除了通过继承获得第三方功能外，还有一种称之为组合的方式，即把第三方类作为组件的方式揉入类中，使得类具有第三方的功能：
class MoveableAdapter(Root):def __init__(self, x, y, **kwds):self.movable = Moveable(x, y)super().__init__(**kwds)def draw(self):self.movable.draw()super().draw()
Copier après la connexion
Moveable被作为组件整合到适配类MoveableAdapter中，适配类拥有了Moveable的功能，而且是友好实现的。完全可以通过继承适配类的方式，将Moveable的功能加入到友好的继承体系中：
class MovableColoredShape(ColoredShape, MoveableAdapter):passMovableColoredShape(color='red', shapename='triangle',
x=10, y=20).draw()Copier après la connexion
参考
Python’s super() considered super!
Python tutorial#super
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
