day21 继承

day21 继承

目录

• day21 继承
  • 今日内容
  • 昨日回顾
  • 今日内容详细
    • 一对多的组合关系
    • 继承（实现）关系

今日内容

1. 一对多的组合关系
2. 继承（实现）关系
   • 单继承
   • 多继承
   • super

昨日回顾

1. OOA、OOD和OOP
2. 类之间的关系
   1. 依赖（关联）关系
   2. 组合（聚合）关系
   3. 继承（实现）关系
3. 依赖（关联）关系
   • 将一个类的对象或类名传给另一个类的方法使用
4. 删除示例属性的方法
   • delattr
   • del 对象名.属性名
5. 组合（聚合）关系
   • 将一个类的对象整体作为另一个类的属性

今日内容详细

一对多的组合关系

同一对一的组合关系类似，我们可以将多个类的对象封装为另一个类的属性，具体示例为：

# 有一个男孩类和一个女孩类，男孩类中包含多个女孩类的对象
class Boy:
    def __init__(self, name):
        self.name = name
        self.girl_f = []
    def ba_mei(self, girl):
        self.girl_f.append(girl)
    def happy(self):
        for i in self.girl_f:
            i.play()
class Girl:
    def __init__(self, name):
        self.name = name
    def play(self):
        print(f'{self.name}陪你一起玩~o(=•ェ•=)m')
        
xiaoqiang = Boy('小强')

xiaohong = Girl('小红')
xiaoli = Girl('小丽')
xiaofei = Girl('小菲')

xiaoqiang.ba_mei(xiaohong)
xiaoqiang.ba_mei(xiaoli)
xiaoqiang.ba_mei(xiaofei)

xiaoqiang.happy()

输出的结果为：
小红陪你一起玩~o(=•ェ•=)m
小丽陪你一起玩~o(=•ェ•=)m
小菲陪你一起玩~o(=•ェ•=)m

组合关系与依赖关系的区别在于，组合关系是将类对象封装为新类的属性来使用，而依赖关系则是将类对象作为参数传给新类的方法使用。

一对多练习：

创建教师类和学生类
• 教师类有姓名和学生列表两个属性
• 教师类有添加学生的方法（添加的学生是具体对象）
• 教师类有显示对应学生姓名和学号的方法
• 学生类有学号/姓名/教师姓名三个属性
• 创建多个学生，并添加到某位教师的学生列表中
• 打印该教师的学生

参考代码如下：

class Teacher:
    def __init__(self, name):
        self.name = name
        self.student_list = []
    def add_student(self, *student):    # student前加了*，为了能一次性接收多个实例对象，方便后续使用
        self.student_list.extend(student)
        for j in student:
            j.teacher = self.name
    def show_student(self):
        for i in self.student_list:
            print(f'姓名：{i.name}，学号：{i.student_id}')


class Student:
    def __init__(self, name, student_id):
        self.name = name
        self.student_id = student_id
        self.teacher = None

alex = Teacher('Alex')
bigB = Teacher('宝元')

xiaoming = Student('小明', 123)
xiaoqiang = Student('小强', 234)
xiaohong = Student('小红', 345)
xiaoli = Student('小丽', 456)
xiaohu = Student('小虎', 135)

alex.add_student(xiaoming ,xiaoli)
bigB.add_student(xiaoqiang, xiaohong, xiaohu)

alex.show_student()
bigB.show_student()

print(xiaoming.teacher)
print(xiaoqiang.teacher)

需要注意，使用组合关系时，要尽量避免两个或多个类之间混合使用彼此的类对象作为自己的类属性，这样会陷入循环调用的麻烦中，容易引发混乱。

继承（实现）关系

面向对象思想有三大要素：

1. 继承
2. 封装
3. 多态

面向对象编程（OOP）语言的一个重要功能就是“继承”：

• 它可以使用现有类的所有功能，并在无需重新编写原来类的情况下，对这些功能进行扩展
• 通过继承创建的新类被称为“子类”或“派生类”，被继承的类被称为“基类”、“父类”或“超类”
• 在Python中，同时支持单继承与多继承

举个例子，我们现在像创建猪、狗和猫三个类，它们都有名字和年龄属性，也都有一个叫的方法。不同的是，猪有吃的方法、狗有看家的方法、猫有抓老鼠的方法。按照之前的学习，我们会将代码写成这样：

class Pig:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def bark(self):
        print('叫')
    def eat(self):
        print('吃')

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def bark(self):
        print('叫')
    def guarding(self):
        print('看家')
        
class Cat:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def bark(self):
        print('叫')
    def catch(self):
        print('抓老鼠')

我们发现，虽然实现了需求，但是我们看到，这里面出现了大量的重复代码。如果我们能将这些重复代码封装起来，比如封装到一个动物类中，然后猪、狗和猫分别都继承这个动物类，就可以让代码更加简洁。

具体的实现方法为：

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def bark(self):
        print('叫')
class Pig(Animal):
    def eat(self):
        print('吃')
class Dog(Animal):
    def guarding(self):
        print('看家')
class Cat(Animal):
    def catch(self):
        print('抓老鼠')
mimi = Cat('咪咪', 3)
print(mimi.name, mimi.age)
mimi.bark()
mimi.catch()

输出的结果为：
咪咪 3
叫
抓老鼠

实现继承之后，子类将继承父类的属性和方法

不难看出，继承关系的特点为：

• 增加了类的耦合性（耦合性不宜多，宜精）
• 减少了重复代码
• 使得代码更加规范化，合理化

组合与继承的对比：

• 组合
  • 组合是指在新类里面创建原有类的对象，重复利用已有类的功能，是has-a的关系
  • 原来类的对象作为整体，以新类的属性的形式存在
• 继承
  • 继承允许设计人员根据其他类的实现来定义一个类的实现，是is-a的关系
  • 子类可以直接使用父类中的属性和方法，就好像父类的属性和方法已经存在于子类中了一样

Python 3中使用的都是新式类，如果一个类谁都不继承，那么它默认继承object类。

继承虽然很好用，但是不能滥用，像之前说的，耦合程度不宜过高，否则逻辑会十分混乱：

• 不要轻易地使用继承，除非两个类之间是is-a关系
• 不要单纯地为了实现代码的重用而使用继承，因为过多的继承会破坏代码的可维护性，当父类被修改的时候，会影响到所有继承自它的子类，从而增加程序的维护难度与成本
• 总结起来就是：组装的时候使用组合，扩展的时候使用继承

回到我们刚才的例子，猪、狗、猫三各类都只有动物一个父类，这种只有一个父类的继承方式，我们称作为单继承。在单继承中，子类可以继承父类的属性和方法，修改父类，所有子类都会受到影响。

isinstance和issubclass：

• isinstance：
  • 用于检查实例类型
  • isinstance(对象, 类)，用来判断对象是不是该类的实例对象
• issubclass：
  • 用于检查类继承
  • issubclass(类1, 类2)，用来判断类1是否是类2的子类

Python与其他编程语言不同，当我们定义一个class的时候，我们实际上就定义了一个数据类型。我们定义的数据类型和Python自带的数据类型，比如str、list、dict没什么两样：

print(isinstance(10, int))

输出的结果为;True

如果父类中的方法在子类中不适用，我们可以对其进行重写：

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def bark(self):
        print('叫')

class Dog(Animal):
    def bark(self):    # 重写叫的方法
        print('汪汪汪！')
    def guarding(self):
        print('看家')
  
wangwang = Dog('汪汪', 3)
print(wangwang.name)
wangwang.bark()

输出的结果为：
汪汪
汪汪汪！

重写父类方法的原理是，当示例调用方法时，会先在自己的类方法中查找，如果找不到，才会去父类中查找是否有相应的方法。如果在自己的类方法中找到了需要的方法，就不会去父类中查找，也就调用不到父类的同名方法，从而实现对父类中方法的重写

但是有些时候，我们不得已会写一些重名的方法，比如父类和子类都会有__init__构造方法。但是我们在调用子类方法的同时，也希望调用到父类中相应的方法。我们可以通过父类的类名直接调用：

class Father:
    eye_num = 2
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def live_like_yemen(self):
        print('打儿子')
class Son(Father):
    hair_color = '蓝色'
    def __init__(self, name, age, sex):
        Father.__init__(self, name, age)
        self.sex = sex
    def live_like_yemen(self):
        print('打弟弟')

xiaoming = Son('小明', 16, '男')
xiaoming.live_like_yemen()
print(xiaoming.name)

输出的结果为：
打弟弟
小明

需要注意的是，在类中，self永远指的是调用类的实例化对象。

在上面的例子中，如果没有Father.__init__(self, name, age)这行代码，在子类中就无法调用父类的构造方法，因为子类已经重写了构造方法。上面的方法虽然实现了预期的功能，但是并不符合开发规范。

从子类中，调用父类中方法的关键字是super，上述例子可修改为：

class Father:
    eye_num = 2
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def live_like_yemen(self):
        print('打儿子')
class Son(Father):
    hair_color = '蓝色'
    def __init__(self, name, age, sex):
        super().__init__(name, age)    # 也可以写为super(Son, self).__init__(name, age)
        self.sex = sex
    def live_like_yemen(self):
        print('打弟弟')

xiaoming = Son('小明', 16, '男')
xiaoming.live_like_yemen()
print(xiaoming.name)

super关键字：

• 子类如果编写了自己的构造方法，但是没有声明要调用父类的构造方法，而还需要父类的构造函数中初始化的一些属性，就会出现问题
• 如果子类和父类都有构造函数，子类的构造函数其实是对父类的构造函数的重写。如果不显示调用父类构造函数，父类的构造函数便不会被执行
• 解决方法：直接使用超类的类名调用超类构造方法，或者使用super函数super(当前类名, self).__init__()

子类方法重写：

• 子类可以重写父类中的方法
• 通过super关键字可以调用父类中的方法

多重继承和多继承

• 多重继承：包含多个间接父类

  class A(object): pass
  class B(A): pass
  class C(B): pass
  

• 多继承：有多个直接父类

  class X(object): pass
  class Y(object): pass
  class Z(object): pass
  class M(X, Y, Z): pass
  

Python中的多继承

• 大部分面向对象的编程语言（除了C++）都只支持单继承，而不支持多继承

  • 多继承不仅增加了编程的复杂度，而且很容易导致一些莫名的错误^[1]

• Python虽然在语法上明确支持多继承，但通常推荐如果不是很有必要，尽量不要使用多继承，而是使用单继承

  • 这样可以保证编程思路更清晰，而且可以避免很多麻烦

• 如果多个直接父类中包含了同名的方法

  • 排在前面的父类中的方法会“遮蔽“排在后面的父类中的同名方法

  class A:
      def method(self):
          print('A_method')
  class B:
      def method(self):
          print('B_method')
  class C(A, B):
      pass
  
  c = C()
  c.method()
  
  输出的结果为：
  A_method
  

我们刚刚谈到，即便不使用super方法，直接使用父类的类名，同样可以实现对父类方法的调用。那为什么更推荐使用super方法呢？

这是因为当涉及到比较复杂得多继承关系，比如钻石继承关系时，会出现间接父类会被初始化多次的情况。

比如，我们来看下面这个钻石继承的例子，如果我们使用父类的类名调用构造方法：

class YeYe:
    def __init__(self):
        print('初始化爷爷类')
class QinBa(YeYe):
    def __init__(self):
        print('进入化亲爸类')
        YeYe.__init__(self)
        print('初始化亲爸类')
class GanDie(YeYe):
    def __init__(self):
        print('进入化干爹类')
        YeYe.__init__(self)
        print('初始化干爹类')
class ErZi(QinBa, GanDie):
    def __init__(self):
        print('进入化儿子类')
        QinBa.__init__(self)
        GanDie.__init__(self)
        print('初始化儿子类')
erzi = ErZi()

我们看到，程序运行后，爷爷类被初始化了两次。

这是因为，当创建儿子对象时，会执行它的构造函数。首先打印的是儿子类中初始化方法的代码，然后执行秦霸的构造方法。在亲爸的构造方法中，也是先打印代码，然后执行爷爷的构造方法。执行完爷爷的构造方法之后，程序继续执行亲爸中剩余的代码，然后回到儿子类中，执行干爹的构造方法。在干爹的构造方法中，又要调用爷爷的构造方法。然后打印剩余代码，直至结束。

我们看到，第五步和第十步都是要调用爷爷的构造方法，爷爷类被初始化了两次。这种情况一来没有必要，会占用很大空间，二来，多次初始化也会带来程序逻辑的混乱。

如果我们改用super函数来进行这样的操作，就不会有这些麻烦：

class YeYe:
    def __init__(self):
        print('初始化爷爷类')
        
class QinBa(YeYe):
    def __init__(self):
        print('进入亲爸类')
        super().__init__()
        print('初始化亲爸类')
        
class GanDie(YeYe):
    def __init__(self):
        print('进入干爹类')
        super().__init__()
        print('初始化干爹类')
        
class ErZi(QinBa, GanDie):
    def __init__(self):
        print('进入儿子类')
        super().__init__()
        print('初始化儿子类')
        
erzi = ErZi()

首先，我们发现，在儿子类中，我们只用一行代码指代调用两个直接父类的构造方法。然后，从结果上看，此时，爷爷类只被初始化一次。

而且我们发现，代码的运行情况与多个装饰器装饰一个函数的情况很类似，子类的代码包含着父类的代码，一层套一层的形式。

要解释这个现象，就要引入super方法的查找方法：方法解析顺序列表，MRO^[2]。这个列表是super在父类查找成员的顺序，通过C3算法实现。

查看mro的方法有两种：

类名.mro()
对象名.__class__.mro()

前面例子中的mro为：

[<class '__main__.ErZi'>, <class '__main__.QinBa'>, <class '__main__.GanDie'>, <class '__main__.YeYe'>, <class 'object'>]

我们说过，super后面什么都不写，默认和super(当前类名, self)的写法一样。但事实上，super的参数除了可以写当前类名外，还可以写它的父类^[3]的类名。此时，会执行在方法解析顺序列表中，改类下一个类的方法。

补充了这些知识，我们就可以解释上面的程序运行的顺序了。

super关键字详解：

• 基本结构：super(class[, object or class])
• Python 3可以直接使用super().xxx代替super(class, self).xxx
• 使用多继承时，会涉及到查找顺序（MRO）、钻石继承等问题
  • 单继承时，类名.__init__()的方式和super().__init__()的方式调用父类中的方法没有什么差别
  • 使用类名.__init__()的方式在钻石继承时，会遇到初始化混乱的问题

super内核的mro方法：返回的是一个类的方法解析顺序表（顺序结构）

• 我们定义的每一个类，Python都会计算出一个方法解析顺序（MRO^[2:1]）列表这也是super在父类中查找成员的顺序，它是通过C3线性算法来实现的

• 每个父类^[3:1]都在且只在其中出现一次

• 我们可以通过下面两种方式获得某个类的mro列表：

  类名.mro()
  对象名.__class__.mro()
  

• 当使用super(cls, obj)时，Python会在obj的mro列表上搜索cls的下一个类

• 事实上，super和父类没有实质性的关联，我们也不一定非要把super后面的参数写成自己类的名字和self。我们甚至可以很灵活地给super传参数

  • super(cls, obj)获得的时cls在obj的MRO列表中的下一个类，cls可以是任何一个类，obj可以是任何一个对象，只要合理即可

    class class ErZi(Qinba,GanDie):
        def __init__(self):
            super(ErZi, self).__init__()
            print('初始化儿子')
    

  • 在前面我们定义儿子类的时候，如果我们不想调用秦霸的__init__()，而是要调用干爹的__init__()，只需把super写成super(Qinba, self).__init__()，也就是这样：

    class YeYe:
        def __init__(self):
            print('初始化爷爷类')
    
    class QinBa(YeYe):
        def __init__(self):
            print('进入亲爸类')
            super().__init__()
            print('初始化亲爸类')
    
    class GanDie(YeYe):
        def __init__(self):
            print('进入干爹类')
            super().__init__()
            print('初始化干爹类')
    
    class ErZi(QinBa, GanDie):
        def __init__(self):
            print('进入儿子类')
            super(QinBa, self).__init__()
            print('初始化儿子类')
    
    erzi = ErZi()
    

    其执行顺序为：

    

---

1. 在编程时，莫名其妙的错误最为可怕，因为不可预测，难以排除。 ↩︎

2. Method Resolution Order ↩︎ ↩︎

3. 包括直接父类和间接父类 ↩︎ ↩︎