第38讲：类和对象——继承

一  继承

1 继承的基本概念

• 定义：继承是一种创建新类的方式，新建的类可以继承一个或多个父类（python支持多继承），父类又可称为基类或超类，新建的类称为派生类或子类。
• 分类：python中类的继承分为：单继承和多继承
• 语法：

  1 class 类名(父类1, 父类2, ...)：
  2     #类定义部分

• 特点：
  • 如果该类没有显式指定继承自哪个类，则默认继承 object 类（object 类是 Python 中所有类的父类/基类，即要么是直接父类，要么是间接父类）。
  • Python 的继承是多继承机制（和 C++ 一样），即一个子类可以同时拥有多个直接父类。
• 查看：
  • 类名.__base__：只查看从左到右继承的第一个子类
  • 类名.__bases__：查看所有继承的父类
• 经典类与新式类：
  • 只有在python2中才分新式类和经典类，python3中统一都是新式类
  • 在python2中，没有显式的继承object类的类，以及该类的子类，都是经典类
  • 在python2中，显式地声明继承object的类，以及该类的子类，都是新式类
  • 在python3中，无论是否继承object，都默认继承object，即python3中所有类均为新式类

2 继承与抽象（先抽象再继承）

• 抽象：
  • 即抽取类似或者说比较像的部分。
  • 抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）
  • 抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类
• 继承：
  • 是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。
  • 继承描述的是子类与父类之间的关系，是一种什么是什么的关系。要找出这种关系，必须先抽象再继承

3 继承与重用性

• 代码重用：通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用
• 开发过程中，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大.

4 派生

• 定义：它和继承是一个意思，只是观察角度不同而已。换句话说，继承是相对子类来说的，即子类继承自父类；而派生是相对于父类来说的，即父类派生出子类。
• python父类方法的重写：
  • 适用情况：对于父类中的一些方法，子类对象不能直接使用时，必须将这些方法在子类中重新定义一遍，即重写
  • 定义：重写，有时又称覆盖，是一个意思，指的是对类中已有方法的内部实现进行修改。
  • 举例：

    class Bird:
        #鸟有翅膀
        def isWing(self):
            print("鸟有翅膀")
        #鸟会飞
        def fly(self):
            print("鸟会飞")
    class Ostrich(Bird):
        # 重写Bird类的fly()方法
        def fly(self):
             print("鸵鸟不会飞")
    
    # 创建Ostrich对象
    ostrich = Ostrich()
    #调用 Ostrich 类中重写的 fly() 类方法
    ostrich.fly()

  • 调用重写之后的方法：子类对象名.重写后的方法，例如"ostrich.fly()"语句
  • 调用被重写方法：父类名.被重写的方法名（子类对象名）

    •  # 创建Ostrich对象
       ostrich = Ostrich()
       #调用 Bird 类中的 fly() 方法
       Bird.fly(ostrich)

    • Python 中的类可以看做是一个独立空间，而类方法其实就是出于该空间中的一个函数。
    • 而如果想要全局空间中，调用类空间中的函数，只需要在调用该函数时备注类名即可。
    • 使用类名调用其类方法，Python 不会为该方法的第一个 self 参数自定绑定值，因此采用这种调用方法，需要手动为 self 参数赋值。

5 关于python的多继承

• 大部分面向对象的编程语言，都只支持单继承，即子类有且只能有一个父类。而Python 却支持多继承（C++也支持多继承）
• 和单继承相比，多继承容易让代码逻辑复杂、思路混乱，一般较少使用
• 使用多继承经常需要面临的问题是，多个父类中包含同名的类方法
  • 对于这种情况，Python 的处置措施是：根据子类继承多个父类时这些父类的前后次序决定，即排在前面父类中的类方法会覆盖排在后面父类中的同名类方法。
  • 代码：
  • 多个父类中包含同名类方法解决办法
  • 运行结果：

  • 1 People类 张三

6 继承的实现原理

• 继承顺序问题（继承了多个类）：
  • Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先
  • 
• 经典类和新式类的区别：
  • 语法区分：是否继承了object类
    • 
  • 多继承查找方式区分：
    • 当类是经典类时，多继承情况下，会按照深度优先方式查找

      • 1 class D:
         2 
         3     def bar(self):
         4         print 'D.bar'
         5 
         6 
         7 class C(D):
         8 
         9     def bar(self):
        10         print 'C.bar'
        11 
        12 
        13 class B(D):
        14 
        15     def bar(self):
        16         print 'B.bar'
        17 
        18 
        19 class A(B, C):
        20 
        21     def bar(self):
        22         print 'A.bar'
        23 
        24 a = A()
        25 # 执行bar方法时
        26 # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
        27 # 所以，查找顺序：A --> B --> D --> C
        28 # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
        29 a.bar()
        30 
        31 经典类多继承
        
        经典类多继承

      • 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
    • 当类是新式类时，多继承情况下，会按照广度优先方式查找

      • 1 class D(object):
         2 
         3     def bar(self):
         4         print 'D.bar'
         5 
         6 
         7 class C(D):
         8 
         9     def bar(self):
        10         print 'C.bar'
        11 
        12 
        13 class B(D):
        14 
        15     def bar(self):
        16         print 'B.bar'
        17 
        18 
        19 class A(B, C):
        20 
        21     def bar(self):
        22         print 'A.bar'
        23 
        24 a = A()
        25 # 执行bar方法时
        26 # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
        27 # 所以，查找顺序：A --> B --> C --> D
        28 # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
        29 a.bar()
        30 
        31 新式类多继承
        
        新式类多继承

        首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错

• 继承原理（python如何实现继承）
  • 原理：
    • python到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表——F.mro() #等同于F.__mro__
    • 为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
  • MRO列表
    • 构造：通过一个C3线性化算法来实现
    • 实质：它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
      • 子类会先于父类被检查
      • 多个父类会根据它们在列表中的顺序被检查
      • 如果对下一个类存在两个合法的选择,选择第一个父类

7 子类中调用父类的方法

• 问题：
  • 当一个子类继承多个类时，在创建子类的对象后，程序运行可能会出错；
  • 因为不同父类的构造方法之间会被覆盖，导致有些父类的构造方法没有得到正确的参数；
  • 为解决该问题，正确的做法是在子类中定义自己的构造方法（等同于重写第一个直接父类的构造方法），并且必须在该方法中调用第一个直接父类的构造方法
• 调用第一个父类的构造方法：
  • 方法一：父类名.父类构造方法()
  • 方法二：super()
    • Python 2.x 语法：

      1 super(Class, obj).__init__(self,...)

    • python 3.x 语法：

      1 super().__init__(self,...)

• 上述两种方式也可用于调用父类中的其它方法：
  • 方法一：父类名.父类方法()

    • 1 #_*_coding:utf-8_*_
       2 __author__ = 'Linhaifeng'
       3 
       4 class Vehicle: #定义交通工具类
       5      Country='China'
       6      def __init__(self,name,speed,load,power):
       7          self.name=name
       8          self.speed=speed
       9          self.load=load
      10          self.power=power
      11 
      12      def run(self):
      13          print('开动啦...')
      14 
      15 class Subway(Vehicle): #地铁
      16     def __init__(self,name,speed,load,power,line):
      17         Vehicle.__init__(self,name,speed,load,power)
      18         self.line=line
      19 
      20     def run(self):
      21         print('地铁%s号线欢迎您' %self.line)
      22         Vehicle.run(self)
      23 
      24 line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
      25 line13.run()

  • 方法二：super()

    • 1 class Vehicle: #定义交通工具类
       2      Country='China'
       3      def __init__(self,name,speed,load,power):
       4          self.name=name
       5          self.speed=speed
       6          self.load=load
       7          self.power=power
       8 
       9      def run(self):
      10          print('开动啦...')
      11 
      12 class Subway(Vehicle): #地铁
      13     def __init__(self,name,speed,load,power,line):
      14         #super(Subway,self) 就相当于实例本身 在python3中super()等同于super(Subway,self)
      15         super().__init__(name,speed,load,power)
      16         self.line=line
      17 
      18     def run(self):
      19         print('地铁%s号线欢迎您' %self.line)
      20         super(Subway,self).run()
      21 
      22 class Mobike(Vehicle):#摩拜单车
      23     pass
      24 
      25 line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
      26 line13.run()

有关多重继承的问题：https://fishc.com.cn/thread-48759-1-1.html

二 课后作业

测试题部分：

 0. 继承机制给程序猿带来最明显的好处是？
答：可以偷懒，据说这是每一个优秀程序猿的梦想！
如果一个类 A 继承自另一个类 B，就把这个 A 称为 B 的子类，把 B 称为 A 的父类、基类或超类。继承可以使得子类具有父类的各种属性和方法，而不需要再次编写相同的代码（偷懒）。
在子类继承父类的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类的原有属性和方法，使其获得与父类不同的功能。另外，为子类追加新的属性和方法也是常见的做法。

1. 如果按以下方式重写魔法方法 __init__，结果会怎样？

class MyClass:
    def __init__(self):
        return "I love FishC.com!" 

答：会报错，因为 __init__ 特殊方法不应当返回除了 None 以外的任何对象。

>>> myClass = MyClass()
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    myClass = MyClass()
TypeError: __init__() should return None, not 'str'

2. 当子类定义了与相同名字的属性或方法时，Python 是否会自动删除父类的相关属性或方法？
答：不会删除！Python 的做法跟其他大部分面向对象编程语言一样，都是将父类属性或方法覆盖，子类对象调用的时候会调用到覆盖后的新属性或方法，但父类的仍然还在，只是子类对象“看不到”。

3. 假设已经有鸟类的定义，现在我要定义企鹅类继承于鸟类，但我们都知道企鹅是不会飞的，我们应该如何屏蔽父类（鸟类）中飞的方法？
答：覆盖父类方法，例如将函数体内容写 pass，这样调用 fly 方法就没有任何反应了。

class Bird:
    def fly(self):
        print("Fly away!")
class Penguin(Bird):
    def fly(self):
        pass
>>> bird = Bird()
>>> penguin = Penguin()
>>> bird.fly()
Fly away!
>>> penguin.fly()

4. super 函数有什么“超级”的地方？
答：super 函数超级之处在于你不需要明确给出任何基类的名字，它会自动帮您找出所有基类以及对应的方法。由于你不用给出基类的名字，这就意味着你如果需要改变了类继承关系，你只要改变 class 语句里的父类即可，而不必在大量代码中去修改所有被继承的方法。

5. 多重继承使用不当会导致重复调用（也叫钻石继承、菱形继承）的问题，请分析以下代码在实际编程中有可能导致什么问题？

class A():
    def __init__(self):
        print("进入A…")
        print("离开A…")
class B(A):
    def __init__(self):
        print("进入B…")
        A.__init__(self)
        print("离开B…")
        
class C(A):
    def __init__(self):
        print("进入C…")
        A.__init__(self)
        print("离开C…")
class D(B, C):
    def __init__(self):
        print("进入D…")
        B.__init__(self)
        C.__init__(self)
        print("离开D…")

答：多重继承容易导致重复调用问题，下边实例化 D 类后我们发现 A 被前后进入了两次。
这有什么危害？我举个例子，假设 A 的初始化方法里有一个计数器，那这样 D 一实例化，A 的计数器就跑两次（如果遭遇多个钻石结构重叠还要更多），很明显是不符合程序设计的初衷的（程序应该可控，而不能受到继承关系影响）。

>>> d = D()
进入D…
进入B…
进入A…
离开A…
离开B…
进入C…
进入A…
离开A…
离开C…
离开D…

为了让大家都明白，这里只是举例最简单的钻石继承问题，在实际编程中，如果不注意多重继承的使用，会导致比这个复杂N倍的现象，调试起来不是一般的痛苦……所以一定要尽量避免使用多重继承。
想更多的了解，阅读 -> 多重继承的陷阱：钻石继承（菱形继承）问题uf^F&2aJ

6. 如何解决上一题中出现的问题？
答：super 函数再次大显神威。

class A():
    def __init__(self):
        print("进入A…")
        print("离开A…")
class B(A):
    def __init__(self):
        print("进入B…")
        super().__init__()
        print("离开B…")
        
class C(A):
    def __init__(self):
        print("进入C…")
        super().__init__()
        print("离开C…")
class D(B, C):
    def __init__(self):
        print("进入D…")
        super().__init__()
        print("离开D…")
>>> d = D()
进入D…
进入B…
进入C…
进入A…
离开A…
离开C…
离开B…
离开D…

动动手部分：

0. 定义一个点（Point）类和直线（Line）类，使用 getLen 方法可以获得直线的长度。

提示：
设点 A(X1,Y1)、点 B(X2,Y2)，则两点构成的直线长度 |AB| = √((x1-x2)2+(y1-y2)2)
Python 中计算开根号可使用 math 模块中的 sqrt 函数
直线需有两点构成，因此初始化时需有两个点（Point）对象作为参数

代码：

import math

class Point(object):
    def __init__(self,x=0,y=0):
        self.x = x
        self.y = y 
    
    def getX(self):
        return self.x 
    
    def getY(self):
        return self.y 

class Line(object):
    def __init__(self,p1,p2):
        self.x = p1.getX() - p2.getX()
        self.y = p1.getY() - p2.getY()
        self.len = math.sqrt(self.x * self.x + self.y * self.y)
    
    def getLen(self):
        return self.len 

p1 = Point(1,1)
p2 = Point(4,5)
line = Line(p1,p2)
print(line.getLen())