《零基础入门学习Python》第038讲：类和对象：继承

浅浅的花香味﹌ 2022-04-14 07:08 247阅读 0赞

**目录**

0. 请写下这一节课你学习到的内容：格式不限，回忆并复述是加强记忆的好方式！

测试题

0. 继承机制给程序猿带来最明显的好处是？

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

2. 当子类定义了与相同名字的属性或方法时，Python 是否会自动删除父类的相关属性或方法？

3. 假设已经有鸟类的定义，现在我要定义企鹅类继承于鸟类，但我们都知道企鹅是不会飞的，我们应该如何屏蔽父类（鸟类）中飞的方法？

4. super 函数有什么“超级”的地方？

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

6. 如何解决上一题中出现的问题？

动动手

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

1. 展示一个你的作品：你已经掌握了 Python 大部分的基础知识，要开始学会自食其力了！

--------------------

## 0. 请写下这一节课你学习到的内容：格式不限，回忆并复述是加强记忆的好方式！ ##

上节课的课后习题我们试图模拟一个场景，里边有一只乌龟和十条鱼，乌龟通过吃鱼来补充体力，当乌龟体力消耗殆尽或者鱼吃光时游戏结束。

现在我们想扩展游戏，给鱼类进行细分，有金鱼（Goldfish），鲤鱼（Carp），三文鱼（Salmon）和鲨鱼（Shark）。那么我们就在思考一个问题：能不能不要每次都重头到尾重新定义一个新的鱼类呢？因为我们知道大部分鱼的属性和方法是相似的。如果说有一种机制可以让这些相似的东西得以自动传递，我们不用每次都自己动手写，那就方便快捷的多了。这种机制就是我们今天要讲解的继承。

语法：class 类名（父类名）：

被继承类被称为基类、父类或超类，继承者被称为子类，一个子类可以继承它的父类的任何属性和方法。举例说明：

>>> class Parent:
    	def hello(self):
    		print("正在调用父类的方法")
    
    		
    >>> class Child(Parent):
    	pass
    
    >>> p = Parent()
    >>> p.hello()
    正在调用父类的方法
    >>> c = Child()
    >>> c.hello()
    正在调用父类的方法

**需要注意的是：如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法和属性。**

>>> class Parent:
    	def hello(self):
    		print("正在调用父类的方法")
    
    	
    >>> class Child(Parent):
    	def hello(self):
    		print("正在调用子类的方法")
    
    		
    >>> c = Child()
    >>> c.hello()
    正在调用子类的方法
    >>> p = Parent()
    >>> p.hello()
    正在调用父类的方法

但是，这里覆盖的是子类实例化对象里面的方法而已，对父类的方法没有影响。

现在大家一起动手写一下刚才提到的鱼类扩展的例子。

这是一个有错误的程序代码：

import random as r
    class Fish:
            def __init__(self):
                    self.x = r.randint(0, 10)
                    self.y = r.randint(0, 10)
            def move(self):
                    self.x -= 1
                    print("我的位置是：", self.x, self.y)
    class Goldfish(Fish):
            pass
    class Shark(Fish):
            def __init__(self):
                    self.hungry = True
            def eat(self):
                    if self.hungry:
                            print("吃货的梦想就是天天有吃的^_^")
                            self.hungry = False
                    else:
                            print("太撑了，吃不下了")

但是上面的程序是存在错误的。如下：

>>> fish = Fish()
    >>> fish.move()
    我的位置是： 2 9
    >>> goldfish = Goldfish()
    >>> goldfish.move()
    我的位置是： -1 7
    >>> shark = Shark()
    >>> shark.eat()
    吃货的梦想就是天天有吃的^_^
    >>> shark.move()
    Traceback (most recent call last):
      File "<pyshell#55>", line 1, in <module>
        shark.move()
      File "C:/Users/XiangyangDai/Desktop/上课代码/38-1.py", line 7, in move
        self.x -= 1
    AttributeError: 'Shark' object has no attribute 'x'

我们在调用shark.move()方法的时候会报错，这是为什么呢？错误信息告诉我们，Shark 对象没有 x 的属性，Goldfish 和 Shark 都是继承Fish，Fish是有x的属性的，但是Shark重写了 \_\_init\_\_(self)方法，子类重写了父类的方法，就会把父类的方法给覆盖。要解决这个问题的话，我们应该在Shark 的类里面重写 \_\_init\_\_(self)方法的时候先调用父类的\_\_init\_\_(self)，实现这样子的继承总共有两种技术。

*  调用未绑定的父类方法（该方法不重要）

import random as r
    class Fish:
            def __init__(self):
                    self.x = r.randint(0, 10)
                    self.y = r.randint(0, 10)
            def move(self):
                    self.x -= 1
                    print("我的位置是：", self.x, self.y)
    class Goldfish(Fish):
            pass
    class Shark(Fish):
            def __init__(self):
                    #调用未绑定的父类方法
                    Fish.__init__(self)
                    self.hungry = True
            def eat(self):
                    if self.hungry:
                            print("吃货的梦想就是天天有吃的^_^")
                            self.hungry = False
                    else:
                            print("太撑了，吃不下了")

>>> shark = Shark()
    >>> shark.move()
    我的位置是： 6 0

这样就不会报错了，需要注意的是， Fish.\_\_init\_\_(self) 中的 self 是调用它的父类的方法，但是这个 self 是子类的实例对象。

就相当于：Fish.\_\_init\_\_(shark)。实际上，在上面出错的程序代码运行之后，我们输入下面的语句可是可以的：这里就相当于重新进行了一次初始化。

>>> shark = Shark()
    >>> Fish.__init__(shark)
    >>> shark.move()
    我的位置是： 6 1

*  **使用 super 函数（完美方法）**

使用super 函数能够帮我们自动找到父类的方法，而且还会为我们传入 self 参数，super 函数可以完美的替换上述的方法。

import random as r
    class Fish:
            def __init__(self):
                    self.x = r.randint(0, 10)
                    self.y = r.randint(0, 10)
            def move(self):
                    self.x -= 1
                    print("我的位置是：", self.x, self.y)
    class Goldfish(Fish):
            pass
    class Shark(Fish):
            def __init__(self):
                    #使用super函数
                    super().__init__()
                    self.hungry = True
            def eat(self):
                    if self.hungry:
                            print("吃货的梦想就是天天有吃的^_^")
                            self.hungry = False
                    else:
                            print("太撑了，吃不下了")

>>> shark = Shark()
    >>> shark.move()
    我的位置是： 6 2

super().\_\_init\_\_()，super 函数的超级之处就在于你不用给定任何父类的名字，如果继承有多重继承或者父类的名字太过复杂的时候，也不用给出父类的名字，就可以自动帮你一层一层的找出它所有父类里面对应的方法，由于你不需要给出父类的名字，也就意味着如果你要改变类的继承关系，你只需要修改 class Shark(Fish): 里面的父类的名字即可。

多重继承：就是同时继承多个父类的属性和方法。

语法：class 类名（父类1名，父类2名........）：

>>> class Base1:
    	def foo1(self):
    		print("我是foo1，我为Base1代言...")
    
    		
    >>> class Base2:
    	def foo2(self):
    		print("我是foo2，我为Base2代言...")
    
    		
    >>> class C(Base1, Base2):
    	pass
    
    >>> c = C()
    >>> c.foo1()
    我是foo1，我为Base1代言...
    >>> c.foo2()
    我是foo2，我为Base2代言...

多重继承可以同时继承多个父类的属性和方法，但是多重继承很容易导致代码混乱，所以当你不确定你真的必须要使用多重继承的时候，**请尽量避免使用**。

--------------------

# 测试题 #

## 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倍的现象，调试起来不是一般的痛苦……所以一定要尽量避免使用多重继承。

想更多的了解，阅读 -> [多重继承的陷阱：钻石继承（菱形继承）问题][Link 1]

## 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():
        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():
        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)
    >>> line.getLen()
    5.0

## 1. 展示一个你的作品：你已经掌握了 Python 大部分的基础知识，要开始学会自食其力了！ ##

请花一个星期做一个你能做出来的最好的作品（可以是游戏、应用软件、脚本），使用上你学过的任何东西（类，函数，字典，列表……）来改进你的程序。"

答：这一次，我不打算提醒你要具体做点什么和怎么做，你需要自己来想创意。试着下手吧，编程就是解决问题的过程，这就意味着你要尝试各种可能性，进行实验，经历失败，然后丢掉你做出来的东西重头开始！

当你被某个问题卡住的时候，你可以到论坛寻求帮助，把你的代码贴出来给其他鱼油看，争取得到别人的建议并持续修改你的代码，直到它让你满意为止！

[Link 1]: https://blog.csdn.net/qq_41556318/article/details/84521836