python中使用多继承问题和super()内置函数的使用

小鱼儿 2022-05-31 14:12 173阅读 0赞

**python中使用多继承问题和super()内置函数的使用**

**1、python中使用多继承问题**

python中使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承，也叫菱形继承问题）等  
1.1、MRO简介：  
MRO即方法解析顺序(method resolution order)，用于判断子类调用的属性来自于哪个父类。在Python2.3之前，MRO是基于深度优先算法的，自2.3开始使用C3算法，定义类时需要继承object，这样的类称为新式类，否则为旧式类  
![20180227102404224][]

从图中可以看出，旧式类查找属性时是深度优先搜索，新式类则是广度优先搜索

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

class X(object):
        def f(self):
            print 'x'
    
    class A(X):
        def f(self):
            print 'a'
        def extral(self):
            print 'extral a'
    
    class B(X):
        def f(self):
            print 'b'
        def extral(self):
            print 'extral b'
    
    class C(A,B,X):
        '''
        如果是class C(X,B,A):  class C(B,A,X):  则会报如下错误:
        TypeError: Error when calling the metaclass bases
        Cannot create a consistent method resolution
        order (MRO) for bases X, B, A
        '''
        def f(self):
            super(C, self).f()
            print 'c'
    
    
    print "调用顺序 ", C.mro()
    
    c = C()
    c.f()    # 指声明时父类的顺序，比如C(A,B)，如果访问C类对象属性时，应该根据声明顺序，优先查找A类，然后再查找B类
    c.extral()  # 指声明时父类的顺序，比如C(A,B)，如果访问C类对象属性时，应该根据声明顺序，优先查找A类，然后再查找B类

根据广度搜索原则最先搜索到A，所以结果很明显，如下所示：

/System/Library/Frameworks/Python.framework/Versions/2.7/bin/python2.7 /Users/a6/Downloads/PycharmProjects/Attempt_new/chat_mes_dm_sparkSql/test_use_super.py
    调用顺序  [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.X'>, <type 'object'>]
    a
    c
    extral a
    
    Process finished with exit code 0

**类C没有extral函数，调用的是子类的该函数。这种类的部分行为由父类来提供的行为，叫做抽象超类.**

**2、super函数介绍：**

2.1 描述

super() 函数是用于调用父类(超类)的一个方法。  
super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。  
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。  
2.2 语法  
以下是 super() 方法的语法:  
super(type\[, object-or-type\])  
参数  
type -- 类。  
object-or-type -- 类，一般是 self

Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :

2.3、\# 不使用super函数，而直接使用非绑定函数的例子

# -*- coding: utf-8 -*-
    # 不使用super函数，而直接使用非绑定函数的例子
    class A:
        def __init__(self):
            print "enter A"
            print "leave A"
    
    
    class B(A):
        def __init__(self):
            print "enter B"
            A.__init__(self)   # old method
            print "leave B"
    
    b = B()

输出结果:

/System/Library/Frameworks/Python.framework/Versions/2.7/bin/python2.7 /Users/a6/Downloads/PycharmProjects/Attempt_new/chat_mes_dm_sparkSql/test_use_super.py
    enter B
    enter A
    leave A
    leave B
    
    Process finished with exit code 0

2.4、\# 使用super()函数的例子

# -*- coding: utf-8 -*-
    # 使用super()函数的例子
    class A(object):    # A must be new-style class
        def __init__(self):
            print "enter A"
            print "leave A"
    class C(A):    # A must be new-style class
        def __init__(self):
            print "enter C"
            super(C,self).__init__()
            print "leave C"
    class B(C,A):
        def __init__(self):
            print "enter B"
            super(B, self).__init__()  # new method  只适用于新式类，定义形如class A(object)为新式类，形如class A()为经典(老式类)定义
            print "leave B"
    c=C()
    print "**********"
    b = B()

输出结果：

/System/Library/Frameworks/Python.framework/Versions/2.7/bin/python2.7 /Users/a6/Downloads/PycharmProjects/Attempt_new/chat_mes_dm_sparkSql/test_use_super.py
    enter C
    enter A
    leave A
    leave C
    **********
    enter B
    enter C
    enter A
    leave A
    leave C
    leave B
    
    Process finished with exit code 0

2.5、例子：

#!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    class FooParent(object):
        def __init__(self):
            self.parent = 'I\'m the parent.'
            print ('Parent')
            self.child_has="FooParent has variable"
    
        def bar(self, message):
            print ("%s from Parent" % message)
    
    class FooChild(FooParent):
        def __init__(self):
            # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类B的对象 FooChild 转换为类 FooParent 的对象
            super(FooChild, self).__init__()
            print ('Child')
            self.child_has="child_has variable"
    
        def bar(self, message):
            print ('Child bar fuction')
            super(FooChild, self).bar(message)
            print (self.parent)   # 子类没有，就向父类查找
            print self.child_has  # 首先查找子类，子类有，则输出子类的内容，子类没有，则按照MRO顺序查找其父类
    
    if __name__ == '__main__':
        fooChild = FooChild()
        print "************"
        fooChild.bar('HelloWorld')

输出结果:

/System/Library/Frameworks/Python.framework/Versions/2.7/bin/python2.7 /Users/a6/Downloads/PycharmProjects/Attempt_new/chat_mes_dm_sparkSql/test_use_super.py
    Parent
    Child
    ************
    Child bar fuction
    HelloWorld from Parent
    I'm the parent.
    child_has variable
    
    Process finished with exit code 0

参考:  [https://www.cnblogs.com/Vito2008/p/4987450.html][https_www.cnblogs.com_Vito2008_p_4987450.html]

[http://www.runoob.com/python/python-func-super.html][http_www.runoob.com_python_python-func-super.html]

[20180227102404224]: /images/20220531/efc91ca3200146468ec6e7c9d3654577.png
[https_www.cnblogs.com_Vito2008_p_4987450.html]: https://www.cnblogs.com/Vito2008/p/4987450.html
[http_www.runoob.com_python_python-func-super.html]: http://www.runoob.com/python/python-func-super.html