day19 MRO C3算法 super()

1. MRO（Method Resolution Order）：方法解析顺序,主要用于在多继承时判断调的属性的路径(来自于哪个类).

  1.Python语言包含了很多优秀的特性，其中多重继承就是其中之一，
       但是多重继承会引发很多问题，比如二义性，Python中一切皆引用，
       这使得他不会像C++一样使用虚基类处理基类对象重复的问题，
       但是如果父类存在同名函数的时候还是会产生二义性，
        Python中处理这种问题的方法就是MRO

  2. C3算法最早被提出是用于Lisp的，应用在Python中是为了解决原来基于深度优先搜索算法不满足本地优先级，
         和单调性的问题。
         本地优先级：指声明时父类的顺序，比如C(A,B)，如果访问C类对象属性时，应该根据声明顺序，优先查找A类，然后再查找B类。
        单调性：如果在C的解析顺序中，A排在B的前面，那么在C的所有子类里，也必须满足这个顺序

3. C3算法

    判断mro要先确定一个线性序列，然后查找路径由由序列中类的顺序决定。所以C3算法就是生成一个线性序列。
     1. 如果继承至一个基类:
        class B(A)
        这时B的mro序列为[B,A]

     2. 如果继承至多个基类
　　　　 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操作的序列无法为空，则说明不合法.

4.C3算法规则

C3算法的本质就是Merge，不断地把mro+()函数返回的序列进行Merge，规则如下：

1. 如果第一个序列的第一个元素，是后续序列的第一个元素，或者不再后续序列中再次出现，
   则将这个元素合并到最终的方法解析顺序序列中，并从当前操作的全部序列中删除。

2. 如果不符合，则跳过此元素，查找下一个列表的第一个元素，重复1的判断规则

例 1.

class A(O):pass
class B(O):pass
class C(O):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]

例 2.

class A:
　　pass
class B(A):
　　pass
class C(A):
　　pass
class D(B, C):
　　pass
class E(C, A):
　　pass
class F(D, E):
　　pass
class M(F, E):
　　pass
class N:
　　pass
class P(M,N):
　　pass
class G(P):
　　pass
class O:
　　pass
class X(O):
　　pass
class H(G, X, F):
pass
print(H.__mro__)

'''
L(H) = H + L(G) + L(X) + L(F) + GXF HGPMXFDBECANO

L(G) = G + L(P) + P # GPMFDBECAN
L(X) = X + L(O) + O # XO
L(F) = F + L(D) + L(E) + DE # FDBECA

L(P) = P + L(M) + L(N) + MN # PMFDBECAN
L(D) = D + L(B) + L(C) + BC # DBCA
L(E) = E + L(C) + L(A) + CA # ECA

L(M) = M + L(F) + L(E) + FE # ECA ECA E MFDBECA

'''

算完了.  那这个算完了. 如何验证呢? 其实python早就给你准备好
了. 我们可以使用类名.__mro__获取到类的MRO信息.

print(H.__mro__)
或者print(H.mro())
结果:
(<class '__main__.H'>, <class '__main__.G'>, <class '__main__.F'>, <class
'__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class'__main__.C'>,<class '__main__.A'>, <class 'object'>)

2.关于 经典MRO

3.关于super()

　　super()可以帮我们执行MRO中下一个父类的方法. 通常super()有两个使用的地方:

　　　　1. 可以访问父类的构造方法
                2. 当子类方法想调用父类(MRO)中的方法

class Foo:
　　def __init__(self, a, b, c):
　　　　self.a = a
　　　　self.b = b
　　　　self.c = c
class Bar(Foo):
　　def __init__(self, a, b, c, d):
　　　　super().__init__(a, b, c) # 访问父类的构造方法
　　　　self.d = d
b = Bar(, , , )
print(b.__dict__)
结果:
{'a': , 'b': , 'c': , 'd': }

这样就方便了子类. 不需要写那么多了. 直接用父类的构造帮我们完成一部分代码

第二种

class Foo:
　　def func1(self):
　　　　super().func1() # 此时找的是MRO顺序中下一个类的func1()方法
　　　　print("我的家. 就住在这个屯")
class Bar:
　　def func1(self):
　　　　print("你的家. 不在这个屯")
class Ku(Foo, Bar):
　　def func1(self):
　　　　super().func1() # 此时super找的是Foo
　　　　print("他的家. 不知道在哪个屯")
k = Ku() # 先看MRO . KU, FOO, BAR object
k.func1()
k2 = Foo() # 此时的MRO. Foo object
k2.func1() # 报错

# super是查找mro顺序中的下一个
# 单继承中我们可以认为super是对父类中的属性或方法的引入

class ShengWu:
    def dong(self): # 实例方法
        print(self)
        print("我是生物")

class Animal(ShengWu):
   pass

class Cat(Animal):
    def dong(self): # 子类中出现了和父类重名的内容. 表示对父类的方法的覆盖(重写). 半盖(java)
        super(Animal, self).dong() # 定位到Animal. 找Animal的下一个
        # super(类, 对象).方法()  找到MRO中的类. 找这个类的下一个. 去执行方法
        print("我的猫也会动")

# 找MRO中的下一个
# Cat -> Animal -> ShengWu

c = Cat()
print(c)
c.dong()

结论: 不管super()写在哪里. 在哪执行. 一定先找到MRO列表. 根据
MRO列表的顺序往下找. 否则一切都是错的