PYTHON3中 类的继承（转帖）

原帖地址：https://www.cnblogs.com/lx3822/p/8808845.html

 

继承

1：什么是继承

继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，也就是说在python中支持一个儿子继承多个爹。

新建的类成为子类或者派生类。

父类又可以成为基类或者超类。

子类会遗传父类的属性。

2：为什么要用继承

减少代码冗余（也就是重复写代码）。

3：怎么用继承：

我们定义两个类；
class parenclass1:
        pass

class parenclass2:
        pass


在定义两个类：

class subclass1:

    pass

class subclass2:
    pass

我想让 ：
class parenclass1:      作为    class  subclass1:     的父类。   
    pass                            pass


应该这样用： class subclass1（ parenclass1）:      这就表示subclass1是子类，parenclass 是subclass1 的父类
                 pass


两个父类的话怎么表达呢？如下：

class subclass2（parenclass1,parenclass2）:
    pass

这就表示subclass2的父类是parenclass1,parenclass2 这两个

 

想要查看子类的父类 应该怎样查看呢： 用__bases__  如下：

class ParentClass1:
    pass

class ParentClass2:
    pass

class Subclass1(ParentClass1):
    pass

class Subclass2(ParentClass1,ParentClass2):
    pass


print(Subclass1.__bases__) 
#打印结果：(<class '__main__.ParentClass1'>,)

print(Subclass2.__bases__)
#打印结果：
(<class '__main__.ParentClass1'>, 
 <class '__main__.ParentClass2'>)

经典类与新式类

1、只有在python2中才分新式类和经典类，python3中统一都是新式类
2、在python2中 没有显示继承的object类的类，以及该类的子类都是经典类
3、在python2中，显示的声明继承object的类，以及该类的子类都是新式类
4、在python3中，无论是否继承object，都默认 继承object，即python3中所有类均为新式类

至于经典类 与新式类的区别，后面会有讨论。

提示：如果没有指定基类， python的类会默认继承object类， object是所有python类的基类。

二、继承与抽象

继承描述的是子类与父类之间的关系，是一种什么的关系呢？ 要找出这种关系， 必须先抽象在继承。

抽象即抽取类似或者说比较像的部分。

抽象分成两个层次：

1.将奥巴马和梅西这俩对象比较像的部分抽取成类； 

2.将人，猪，狗这三个类比较像的部分抽取成父类。

抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）

继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象合格过程， 才能通过继承的方式去表达抽象的结构。

抽象只是分析和设计的过程，一个动作或者说一种技巧，通过抽象可以得到类

 例如：我们写一个老男孩的老师与学生的类，若是不涉及到继承的话  我们正常是这样写

class OldboyTeacher:
    school = 'oldboy'

    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def change_score(self):
        print('teacher %s is changing score ' %self.name)

class Oldboystudent:

    school = 'oldboy’

    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def choose(self):
        print('student %s choose course' %self.name)

tea1 = OldboyTeacher('egon', 18, 'male') #OldboyTeacher.__init__(...)
stu1=Oldboystudent('alex',73,'female')

print(tea1.name,tea1.age,tea1.sex) # egon 18 male

print(stu1.name) #alex

但是我们经过分析 发现里面里面有许多重复代码， 这时我们可以用到类的继承来写了。如下：

class OldboyPeople:
    school ='oldboy'

    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

class Oldboyteacher(OldboyPeople):
    def change_score(self):
        print('teacher %s is changing score ' %self.name)

class Oldboystudent(OldboyPeople):
    def choose(self):
        print('student %s choose course'%self.name)

tea1 = Oldboyteacher('egon', 18, 'male') 
stu1=Oldboystudent('alex',73,'female')


print(tea1.name,tea1.age,tea1.sex)#egon 18 male
print(stu1.name) #alex

 三、基于继承在看属性查找

我们先看一个列子

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

class Foo:     def f1(self):         print('Foo.f1')       def f2(self): #self=obj         print('Foo.f2')    #在父类中找到发 f2属性，第3步打印这一行         self.f1() #obj.f1()  第4步再去掉用self的f1属性   class Bar(Foo):     def f1(self):#第五步， 在回到object自身的名称空间找f1属性，找到后调用         print('Bar.f1') #第6步 执行   obj=Bar() #第一步 ：类的实例化， 先得到一个空对象，   obj.f2()  #第2步：空对象调用f2属性 在自身寻找f2属性， 没有找到就去父类中寻找<br><br>#结果

Foo.f2
Bar.f1

注意子类的属性查找，一定是优先查找子类自己本身的属性与特征， 在本身没有的情况下 在去父类中查找。

这个还是非常有意思的，当执行obj.f2时，自己没有该属性，寻找父类属性，当找到f2属性时，执行self.f1，又优先取寻找自己的self.f1属性了，确实够贱。

self很重要，哪个self进去，属性都是先找self身上自己的。

四、派生

派生：子类定义自己新的属性，如果与父类同名，以子类自己的为准。

class OldboyPeople:
    school = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def f1(self):
        print('爹的f1')
class OldboyTeacher(OldboyPeople):
    def change_score(self):
        print('teacher %s is changing score' %self.name)

    def f1(self):
        print('儿子的f1')

tea1 = OldboyTeacher('egon', 18, 'male')
tea1.f1()

#调用显示：儿子的f1
# 父类和子类中都有f1, 优先调用自己的属性，所以结果调用的是儿子的f1

五、在子类中派生出的新方法重用父类的功能

拿上一案例来举例 在oldboyteacher 这个类中要添加薪水与级别。 然后调用。 有两种方式。

方式一：指名道姓的调用（与继承没有什么关系）

class OldboyPeople:
    school ='oldboy'

    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def tell_info(self):
        print(
            '''
            ====个人信息====
           姓名：%s
           年龄：%s
           性别：%s
            '''%(self.name,self.age,self.sex))

class OldboyTeacher(OldboyPeople):

    def __init__(self,name,age,sex,level,salary):
        OldboyPeople.__init__(self,name,age,sex)  #在这里指明道姓来调用这一个函数里的属性

        self.level =level
        self.salary=salary

    def tell_info(self):
        OldboyPeople.tell_info(self)   #指名道姓的来调用这个函数里的属性
        print("""
        等级：%s
        薪资：%s
        """ %(self.level,self.salary))

tea1 = OldboyTeacher('egon', 18, 'male', 9, 3.1)
print(tea1.name, tea1.age, tea1.sex, tea1.level, tea1.salary)


tea1.tell_info()

#打印结果：
egon 18 male 9 3.1

            ====个人信息====
           姓名：egon
           年龄：18
           性别：male
            

        等级：9
        薪资：3.1

方法二、

用super()调用（严格依赖于继承）

super() 的返回值是一个特殊的对象，该对象专门用来调用父类中的属性， 一般在python2中，需要super(自己的类名,self)，  而python3中，括号里面一般不填类名

class OldboyPeople:
    school = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def tell_info(self):
        print("""
        ===========个人信息==========
        姓名：%s
        年龄：%s
        性别：%s
        """ %(self.name,self.age,self.sex))


class OldboyTeacher(OldboyPeople):

    def __init__(self, name, age, sex, level, salary):
        super().__init__(name,age,sex)

        self.level = level
        self.salary = salary

    def tell_info(self):
        super().tell_info()
        print("""
        等级：%s
        薪资：%s
        """ %(self.level,self.salary))

tea1 = OldboyTeacher('egon', 18, 'male', 9, 3.1)
print(tea1.name, tea1.age, tea1.sex, tea1.level, tea1.salary)
tea1.tell_info()

#调用结果：
egon 18 male 9 3.1

        ===========个人信息==========
        姓名：egon
        年龄：18
        性别：male
        

        等级：9
        薪资：3.1
        

六：经典类 与新式类

1新式类：

继承object的类，以及该类的子类，都是新式类

在python3中，如果一个类没有指定继承的父类，默认就继承object

所以说在python3中所有的类都是新式类

 

2经典类：（只有在python2才区分经典类和新式类）：

没有继承object的类，以及该类的子类 都是经典类

1 经典类：深度优先

2 新式类：广度优先

如果继承关系为非菱形结果吗则会按照先找B 这一条分支，然后在找c这一条分支，最后找D这一条分支的顺序，直到找到我们想要的属性

当继承关系为菱形结构时

经典类查找顺序：

若是在A 类里自己没找到， 则会先去B类里去找， B类里没找到，就会在E类里找， 然后在G类里找，

G类里没找到 会去C 类里找， 然后去F 类里找，最后去D 类里找。

新式类查找顺序： 

按照图中1 ，2 ， 3, 4,5,6的顺序查找， 这个为广度优先的查找方式

这个图 蛮好的，缺少了两个线，应该E(G)与F（G）也指向G（object），其实对于新式类的继承，基于广度与深度，我自己根本无法定论。

C3算法我没去仔细研究，但根据我自己的经验来看，会根据继承的类的顺序与深度相关。

下面上我自己写的测试代码：

class A(object):
    def ping(self):
        print('ping', self)


class B(A):
    def pong(self):
        print('pong', self)


class E(B):
    ...




class F(object):
    ...

class H(F):
    ...

class C(H):
    def pong(self):
        print('PONG', self)

class D(C, E):

    def ping(self):
        super(D, self).ping()
        print('post-ping', self)



if __name__ == '__main__':
    print(D.__mro__)

/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第十二章/diamond.py
(<class '__main__.D'>, <class '__main__.C'>, <class '__main__.H'>, <class '__main__.F'>, <class '__main__.E'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

Process finished with exit code 0

 从运行结果来看，C线继承到object之前，一致沿着C走，后面再沿着E走。

object是两个父类的相交的基类结合点。

class A(object):
    def ping(self):
        print('ping', self)


class B(A):
    def pong(self):
        print('pong', self)


class E(B):
    ...




class F(object):
    ...

class H(A):
    ...

class C(H):
    def pong(self):
        print('PONG', self)

class D(C, E):

    def ping(self):
        super(D, self).ping()
        print('post-ping', self)



if __name__ == '__main__':
    print(D.__mro__)

/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第十二章/diamond.py
(<class '__main__.D'>, <class '__main__.C'>, <class '__main__.H'>, <class '__main__.E'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

Process finished with exit code 0

 我把上面代码的H继承到了A，这样D的两个父类的基类相交点到A了，从继承来看，先寻找C线到A之前的类，然后再用E寻找到最后的object。

七:  super（）依赖继承

super（）会严格按照mro列表从当前查找到的位置继续往后查找

class A:
    def test(self):
        print('A.test') #2 执行这一步 打印
        super().f1 #3 然后在调用父类里的f1,   根据C.mro里的查找顺序执行到A 往后继续执行到B里去查找

class B:
    def f1(self): #4找到f1, 执行
        print('from B')  #5打印

class C(A,B):
    pass

c=C()
print(C.mro())  #调用属性的顺序  [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]

c.test() #1：C里没有 ，去A里调用

#打印结果

A.test

from B