笔记-python-语法-super

笔记-python-语法-super

  

1.      super

1.1.    super起源

首先要理解类的继承和多继承，子类有时需要调用父类的方法，

非绑定方法：

class C(B):

       def method(self, arg):

              B.method()

无疑这样的写法是非常死板，如果有多个父类，或是去爷爷类调用就很不太好维护代码了。

需要把引用父类方法的功能抽象和独立出来，这个想法的实现就是super函数。

使用super：

class C(B):

    def method(self, arg):

        super().method(arg)    # This does the same thing as:

                               # super(C, self).method(arg)

 

1.2.    super()语法

语法：super（[ type [，object-or-type ] ] ）

官方解释：Return a proxy object that delegates method calls to a parent or sibling class of type. This is useful for accessing inherited methods that have been overridden in a class. The search order is same as that used by getattr() except that the type itself is skipped.

返回一个代理对象，这个对象负责将方法调用分配给第一个参数的一个父类或者同辈的类去完成。

type：类

object-or-type：类，一般是self

实际上，super返回的代理对象是一个builtin class super，在单继承中，super代理的类只能是唯一父类，但是在多继承关系中，还有可能代理子类的兄弟类。

 

1.3.    多继承

有了super，问题似乎解决了，但是新的问题是在多继承中，子类与父类之间的关系可能非常复杂，不仅仅是树，而是图。

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

上例中类A继承层次结构如下：

  object

    |

    D

   / \

  B   C

   \ /

    A

会出现继承的二义性和重复性问题，上面这种菱形继承问题也叫钻石继承问题，如果现在要求在类A中调用“父类”的test方法，那么就需要一种对test方法的搜索解析顺序，来决定到底是调用B,C或D的test方法。

 

2.      MRO

MRO(Methods Resolution Order)：方法解析顺序

为解决多重继承的问题，python的方法是为类生成mro成员保存解析顺序。可以通过cls.__mro__或者cls.mro()查看。

 

>>> E.mro()

[<class '__main__.E'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

>>> A.mro()

[<class '__main__.A'>, <class 'object'>]

可以看到mro()返回的是一个祖先类的列表。

 

mro机制解决了两个问题，一是重复调用问题，类的父类只会在表中出现一次；二是给定了一个调用顺序。

案例代码：

class Base():

    def __init__(self, value):

        self.value = value

        print('base')

 

class One(Base):

    def __init__(self, value):

        super(One, self).__init__(value)

        self.value *= 2

        print('one')

 

class Two(Base):

    def __init__(self, value):

        super(Two, self).__init__(value)

        self.value = 7

        print('two')

 

class Ways(One, Two):

    def __init__(self, value):

        super().__init__(value)

 

print(Ways.mro())

foo = Ways(5)

print(foo.value)

输出：

[<class '__main__.Ways'>, <class '__main__.One'>, <class '__main__.Two'>, <class '__main__.Base'>, <class 'object'>]

base

two

one

14

 

2.1.    MRO算法

生成mro列表的算法有三种：

1. DFS：经典类的MRO算法;
2. BFS ：新式类的MRO算法；
3. C3：BFS只在python2.2中使用，在其后的版本中使用C3算法替代；

在章节4中会讲解c3算法细节。

 

3.      super工作原理

再回到super上，super工作原理如下：

def super(cls, inst):

    mro = inst.__class__.mro()

    return mro[mro.index(cls) + 1]

其中，cls 代表类，inst 代表实例，上面的代码做了两件事：

1. 获取 inst 的 MRO 列表
2. 查找 cls 在当前 MRO 列表中的 index, 并返回它的下一个类，即 mro[index + 1]

 

4.      C3算法

C3算法最早被提出是用于Lisp的，应用在Python中是为了解决原来基于深度优先搜索算法不满足本地优先级，和单调性的问题。

本地优先级：指声明时父类的顺序，比如C(A,B)，如果访问C类对象属性时，应该根据声明顺序，优先查找A类，然后再查找B类。

单调性：如果在C的解析顺序中，A排在B的前面，那么在C的所有子类里，也必须满足这个顺序。

 

算法的目的是生成一个线性序列。

1. 继承至一个基类：

class B(A)

B的mro为[B,A]

1. 继承至多个基类：

class B(A1, A2, A3,...)

这时B的mro序列为mro(B)=[B]+merge(mro(A1), mro(A2), mro(A3)…,[A1, A2, A3])

merge操作就是C3算法的核心。

遍历执行merge操作的序列，如果一个序列的第一个元素，是其他序列中的第一个元素，或不在其他序列出现，则从所有执行merge操作序列中删除这个元素，合并到当前的mro中。

merge操作后的序列，继续执行merge操作，直到merge操作的序列为空。

如果merge操作的序列无法为空，则说明不合法。

 

例子：

class A():pass

class B():pass

class C():pass

class E(A,B):pass

class F(B,C):pass

class G(E,F):pass

 

A、B、C都继承至一个基类，所以mro序列依次为[A,O]、[B,O]、[C,O]

mro(E) = [E] + merge(mro(A), mro(B), [A,B])

       = [E] + merge([A,O], [B,O], [A,B])

执行merge操作的序列为[A,O]、[B,O]、[A,B]

A是序列[A,O]中的第一个元素，在序列[B,O]中不出现，在序列[A,B]中也是第一个元素，所以从执行merge操作的序列([A,O]、[B,O]、[A,B])中删除A，合并到当前mro，[E]中。

mro(E) = [E,A] + merge([O], [B,O], [B])

再执行merge操作，O是序列[O]中的第一个元素，但O在序列[B,O]中出现并且不是其中第一个元素。继续查看[B,O]的第一个元素B，B满足条件，所以从执行merge操作的序列中删除B，合并到[E, A]中。

mro(E) = [E,A,B] + merge([O], [O])

       = [E,A,B,O]

依此类推，F的MRO为[F,B,C,O]，G的MRO为[G,E,A,F,B,C,O]

 

验证如下：print(G.mro())

输出：[<class '__main__.G'>, <class '__main__.E'>, <class '__main__.A'>, <class '__main__.F'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>]

 

4.1.    C3算法代码

#-*- encoding:GBK -*-# 

def mro_C3(*cls): 

        if len(cls)==1: 

            if not cls[0].__bases__: 

                return  cls 

            else: 

                return cls+ mro_C3(*cls[0].__bases__) 

        else: 

            seqs = [list(mro_C3(C)) for C in cls ] +[list(cls)] 

            res = [] 

            while True: 

              non_empty = list(filter(None, seqs)) 

              if not non_empty: 

                  return tuple(res) 

              for seq in non_empty: 

                  candidate = seq[0] 

                  not_head = [s for s in non_empty if candidate in s[1:]] 

                  if not_head: 

                      candidate = None 

                  else: 

                      break 

              if not candidate: 

                  raise TypeError("inconsistent hierarchy, no C3 MRO is possible") 

              res.append(candidate) 

              for seq in non_empty: 

                  if seq[0] == candidate: 

                      del seq[0]