PYTHON3中 类的继承

Posted 2020-10-30 C3的脚印

继承

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

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

我们先看一个列子

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属性， 没有找到就去父类中寻找

#结果

Foo.f2
Bar.f1

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

四、派生

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

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的顺序查找， 这个为广度优先的查找方式

 

七:  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