Python——子类对象如何访问父类的同名方法

1. 为什么只说方法不说属性

关于“子类对象如何访问父类的同名属性“是没有意义的。因为父类的属性子类都有，子类还有父类没有的属性，在初始化时，给子类对象具体化所有的给定属性，完全没必要访问父类的属性，因为是一样的。而访问同名方法就不一样了，因为子类会重写父类的同名函数。

2、子类访问父类的两种方法

• 假设Base为基类

class Base(object):
 
    def __init__(self):
 
        print ("Base init")

2.1 普通方法(调用父类的未绑定的构造方法)

在调用一个对象的方法时，该方法的self参数会被自动绑定到对象上（称为绑定方法）。但如果直接调用类的方法（比如A.__init），那么就没有实例会被绑定。这样就可以自由的提供需要的self参数，这种方法称为未绑定方法。

class Leaf(Base):
 
    def __init__(self):
 
        Base.__init__(self)
 
        print ("Leaf init")

2.2 super方法

class Leaf(Base):
 
    def __init__(self):
 
        super(Leaf, self).__init__() # 在单继承中等价于super().__init__()
 
        print ("Leaf init")

2.3 上述两个方法的结果

>>>leaf = Leaf()
"Base init"
"Leaf init"

在Python3中的类都是新式类，广度优先的查找顺序，在定义一个类时就会生成一个MRO列表（经典类没有MRO列表，深度优先），查找顺序就是按照这个列表中的类的顺序从左到右进行的。

3、钻石继承中的问题

”钻石继承“指的是一个子类继承自多个父类，成钻石形状。

3.1 如何解决钻石继承中父类被多次初始化

C++使用虚拟继承来解决钻石继承问题；Java禁止使用多继承；Ruby禁止使用多继承；Python和C++一样，支持多继承的语法。但Python的解决思路和C++完全不一样，Python用的就是super。所以，我们有必要来详细探讨super的机制。

• 我把第二章的代码用super重写一下,使用如下的继承关系
  

class Base(object):
 
    def __init__(self):
 
        print ("Base init")
 
 
class Medium1(Base):
 
    def __init__(self):
 
        super(Medium1, self).__init__()
 
        print ("Medium1 init")
 
 
class Medium2(Base):
 
    def __init__(self):
 
        super(Medium2, self).__init__()
 
        print ("Medium2 init")
 
 
class Leaf(Medium1, Medium2):
 
    def __init__(self):
 
        super(Leaf, self).__init__()
 
        print ("Leaf init")

>>> leaf = Leaf()

"Base init"

"Medium2 init"

"Medium1 init"

"Leaf init"

可以看到整个初始化过程符合我们的预期，Base只被初始化了1次。而且重要的是，相比原来的普通写法，super方法并没有写额外的代码，也没有引入额外的概念.

3.2 super的内核：MRO

要理解super的原理，就要先了解mro。mro是method resolution order的缩写，表示了类继承体系中的成员解析顺序。

在python中，每个类都有一个mro的类方法。我们来看一下钻石继承中，Leaf类的mro是什么样子的：

>>>Leaf.mro()
[Leaf, Medium1, Medium2, Base]

可以看到mro方法返回的是一个祖先类的列表。Leaf的每个祖先都在其中出现一次，这也是super在父类中查找成员的顺序。

通过mro，python巧妙地将多继承的图结构，转变为list的顺序结构。super在继承体系中向上的查找过程，变成了在mro中向右的线性查找过程，任何类都只会被处理一次。

通过这个方法，python解决了多继承中的2大难题：

1. 查找顺序问题。从Leaf的mro顺序可以看出，如果Leaf类通过super来访问父类成员，那么Medium1的成员会在Medium2之前被首先访问到。如果Medium1和Medium2都没有找到，最后再到Base中查找。
2. 钻石继承的多次初始化问题。在mro的list中，Base类只出现了一次。事实上任何类都只会在mro list中出现一次。这就确保了super向上调用的过程中，任何祖先类的方法都只会被执行一次。
3. 至于mro的生成算法，可以参考这篇wiki:C3算法

3.3 super的具体用法

• 首先看一下super的官方文档，重点讲第一种和第三种的用法，因为第二种用处不大

Help on class super in module __builtin__:
 
class super(object)
|  super(type, obj) -> bound super object; requires isinstance(obj, type)
|  super(type) -> unbound super object
|  super(type, type2) -> bound super object; requires issubclass(type2, type)

3.2.1 super(type,obj)

这种写法要从右往左的分析参数：obj告诉我们self绑定的对象所属类的MRO顺序，type告诉我们从MRO顺序的哪个位置开始找

当我们在Leaf的init中这样写super时，super(Leaf, self).init()的意思是说：

1. 获取self所属类的mro, 也就是[Leaf, Medium1, Medium2, Base]
2. 从mro中Leaf右边的一个类开始，依次寻找__init__函数。这里是从Medium1开始寻找
3. 一旦找到，就把找到的__init__函数绑定到self对象，并返回

class Leaf(Medium1, Medium2):
 
    def __init__(self):
 
        super(Leaf, self).__init__()
 
        print “Leaf init”

从这个执行流程可以看到，如果我们不想调用Medium1的__init__，而想要调用Medium2的__init__，那么super应该写成：super(Medium1, self).__ init __()

3.2.2 super(type,type2)

当我们在Leaf中写类方法的super时：

class Leaf(Medium1, Medium2):
       def __new__(cls):
              obj = super(Leaf, cls).__new__(cls)
              print ("Leaf new")
              return obj

super(Leaf, cls).new(cls)的意思是说：

1. 获取cls这个类的mro，这里也是[Leaf, Medium1, Medium2, Base]
2. 从mro中Leaf右边的一个类开始，依次寻找__new__函数
3. 一旦找到，就返回“非绑定”的__new__函数

3.2.3 super一些补充的知识点

1. super实现原理：通过c3算法，生成mro（method resolution order）列表，根据列表中元素顺序查询调用。新式类调用顺序为广度优先，旧式类为深度优先，可以通过__mro__来查看。
2. python2没有默认继承object；python3默认全部继承自object类，都是新式类
3. 如果子类继承了多个父类，它只需要使用一次super函数就可以

4. 子类如何访问父类的同名方法

讲了这么多，把上面的知识点综合起来，我们就可以解决子类如何访问父类的同名方法。
看下面的代码：

class A:
    def f_a(self):
        print('--------A--------')
class B:
    def f_a(self):
        print('-------B-------')
class C(A,B):
    def f_a(self):
        print('--------C--------')
c = C()
c.f_a()
》》》--------C--------

如果我们想在C类中的f_a方法里面使用父类A或者父类B的方法该如何操作呢
方法有两种：

4.1 方法一：调用父类的未绑定方法

class C(A,B):
    def f_a(self):
        A.f_a(self)
        B.f_a(self)
        print('--------C--------')
c = C()
c.f_a()
》》》--------A--------
》》》-------B-------
》》》--------C--------

这里调用父类的f_a方法时括号里面要写self，表明这是一个类调用。
缺点：比如说如果修改了父类的名称，那么在子类中会涉及多出修改，并且python是允许多继承的语言，上述方法在多继承时就要重复写多次，显得累赘，为了解决这些问题，python引进了super()机制。

4.2 super机制

class C(A,B):
    def f_a(self):
        super().f_a()
        print('--------C--------')
c = C()
c.f_a()
》》》--------A--------
》》》--------C--------

这里直接使用super()方法会调用A类的f_a方法，因为它会默认多继承中从左到右的顺序来调用，那么有人就会问了，假如我想调用B类中的f_a方法是不是把A和B对调下呢，这种方法也行，不过这不算的上是一种较为巧妙的方法。
我们还可以使用super()方法，但要对其修改下：

class C(A,B):
    def f_a(self):
        super(C,self).f_a()
        super(A,self).f_a()
        print('--------C--------')
c = C()
c.f_a()
》》》--------A--------
》》》-------B-------
》》》--------C--------

super(C,self).f_a()会调用最左边的（即A类）的f_a方法，而super(A,self).f_a()会调用A类后面那个类的f_a()方法，若果继承的不止两个类，如果要调用某个类方法，只要知道前一个类名就可以调用。