python高级编程之访问超类中的方法:super()

# -*- coding: utf-8 -*-

# python:2.x

__author__ = 'Administrator'

#超类01

#它是一个内建类型，用于访问属于某个对象超类特性

print super#<type 'super'>

#如果已习惯于通过直接调用父类将self作为第一参数来访问的特性，可能会出现混乱

#经典方法

class M(object):

def s(self):

print u'不是超类方法'

class S(M):

def s(self):

M.s(self)

print u'只是在继承而已'

a=S()

a.s()

"""

不是超类方法

只是在继承而已

"""

#看下M.s(self)这一行，使用刚刚描述的方法调用超类（M类）中的s方法，将self作为第一参数传入，这意味着属于M的s()方法将被调用，但是调用它的实例将返回self

#super使用如下:

class S1(M):

def s(self):

super(S1,self).s()

print u'使用超类super()'

#注意:当多继承模式时，super()将会变得难以使用，应该理解方法解析顺序(MRO)

#理解python方法解析顺序(MRO)

"""

在2.3中添加了基于为dylan构建的mro(http://www.opendylan.org),即c3新的mro

michele simionato所编写的参考文档在www.python.org/download/releases/2.3/mro 上面可以找，它描述C3构建一个类的线性化（优先级，即祖先的一个排序列表）

这个列表被用于特性的查找

mro的变化用于解决创建公用基本类型(object)所引入的问题,在变成C3线性方法之前，如果一个类有2个祖先,mro计算将很简单，如下:

图片:

"""

class C1:pass

class C2:

def m(self):

print 'C1+C2'

class C3(C1,C2):pass

c3=C3()

c3.m()#C1+C2

#当c3.m被调用时，解释程序将查找C3的方法，然后在C1中查找，最后在C2查找

"""

在2个基类之上引用BaseBase类(C1,C2都从其继承，如图:)

结果是，根据《从左到右深度优先》的规则的旧MRO，在C2中查找将通过C1类返回到顶部

看下面的代码将出现一种古怪的情况

"""

class BaseBase:

def methond(self):

print 'BaseBase'

class B1(BaseBase):

pass

class B2(BaseBase):

def methond(self):

print 'B2'

class MB(B1,B2):

pass

a=MB()

a.methond()#BaseBase

"""

这样的继承很少见，所以这更多是一个理论问题而不是实践问题，标准程序库不会构建这样的继承层次结构，但是由于在类型层次顶部引入了object，语言C边（C side）突然出现了多重继承性问题，从而导致了在进行子类型化时冲突

，因为使用已有的MRO使他正常的工作要花费更多精力，所以提出一个新的MRO

"""

#新的

class A(object):

def m(self):

print 'A'

class A1(A):

pass

class A2(A):

def m(self):

print 'A2'

class A3(A1,A2):

pass

a=A3()

a.m()#A2

#(object)新的mro基于一个基类之上的递归调用，如下:**(重点:L[A3(A1,A2)]=A3+merge(L[A1],L[A2],A1,A2))

"""

L[A3]是A3类的线性化，而merge是合并多个线性化结果的具体算法

C的线性化是C加上父类的线性化和父类列表合并的总和

merge算法负责删除重复项并保持正确的顺序，其在文章中描述为

取第一个列表的头，也就是L[A1][0]，如果这个头不在任何表的尾部，那么将它加到A3线性化中，并且从合并中列表删除，否则查找下一个列表的头，如果是个好的表头

则取用它

然后重复该操作，直到所有类被删除或者不能找到好的表头，上面的例子中，构建合并是不可能的，2.3将拒绝创建A3关类将抛出一个异常

a（表头）是列表的第一个元素，而tail(表尾)则包含其余元素，比如在（A1，A2,AN...）中，A1是表头，（A2,....,AN）则是表尾

换句话说，C3在每个父类上进行递归尝试查找以获得列表顺序，然后当一个类涉及多个列表时，计算一个从左到右的规则使用层次二义性消除来合并所有的列表

如下:

"""

def L(K):

return [K.__name__ for K  in K.__mro__]

print L(A3)#['A3', 'A1', 'A2', 'A', 'object']

#注意：

"""

类的_mro_的特（只读）用来存储线性化计算结果，计算将在类定义载入时完成

还可能调用A3.mro()来计算并获取结果

提醒：这个只对新风格类起作用，所以在代码库中混杂新旧形式的类并不是好方法，MRO表现将会差异

"""