开源图书《Python完全自学教程》8.5.1单继承

老齐

发布于 2022-07-06 08:13:13

24400

代码可运行

文章被收录于专栏：老齐教室老齐教室

运行总次数：0

代码可运行

8.5 继承

继承（Inheritance）是 OOP（Object-oriented programming，面向对象程序设计）中的一个重要概念，也是类的三大特性之一（另外两个特性分别是多态和封装）。

OOP 中的“继承”概念和人类自然语言中的“继承”含义相仿。当对象 C 继承了对象 P，C 就具有了对象 P 的所有属性和方法。通常 C 和 P 都是类对象，称 C 为子类，称 P 为父类。

>>> class P: p = 2
...
>>> class C(P): pass
...

定义类 P （注意写法，因为代码块只有一行，所以可以如上所示书写），里面只有一个类属性。然后定义类 C 。为了能够让类 C 实现对类 P 的继承，在类 C 的名称后面紧跟一个圆括号，圆括号里面写父类 P 的名称。

虽然类 C 的代码块只有 pass ，在其中没有定义任何属性和方法，但是由于它继承了类 P ，父类中所定义的类属性 p 及其值就会被“代入”到类 C ：

>>> hasattr(C, 'p')
True
>>> C.p
2

当子类继承父类之后，不需要再次编写相同的代码，实现了代码重用——“减少重复代码”是编程的一项基本原则。另外，子类继承父类的同时，也可以重新定义父类中的某些属性或方法，即用同名称的属性和方法覆盖父类的原有的对应部分，使其获得与父类不同的功能。

>>> class D(P):
...     p = 222
...     q = 20
...
>>> D.p
222

类 D 继承了类 P ，在类 D 中定义了类属性 p = 222 ，与父类 P 中所定义的类属性重名，则 D.p 的值即为子类中所定义的值。这样的效果称为对父类中属性 p 重写或覆盖。

从继承方式而言，Python 中的继承可以分为“单继承”和“多继承”。

8.5.1 单继承

所谓单继承，就是只从一个父类那里继承。前面列举的继承，都是单继承。要想知道类的父类，可以用类对象的属性 __base__ 查看：

>>> C.__base__
<class '__main__.P'>

类 C 的父类是类 P ，这是毫无疑问的，前面定义类 C 是就已经说明了。再看：

>>> P.__base__
<class 'object'>

在定义类 P 时，并没有注明它继承什么对象，实际上，它也有上一级，那就是类 object 。在 Python 3 中所有的类都是 object 的子类，所以，就不用在定义类的时候写这个“公共的父类”了（读者在阅读代码的时候，还可能遇到如此定义类的情况：class MyCls(object) ，在 Python 3 中，其效果与 class MyCls 等同。但是，如果在 Python 2 中，通常将 object 作为定义类时显式继承的对象，即写成 class MyCls(object) 的样式。请注意 Python 版本）。

下面列举一个示例，从中既能理解单继承的含义，也能明白为什么要继承——本节开篇未解释为什么，而是单刀直入介绍继承的写法，读者可以通过此示例理解“为什么”。

#coding:utf-8
'''
filename: personinhe.py
'''
class Person:
    def __init__(self, name, age):  
        self.name = name
        self.age = age
    
    def get_name(self):
        return self.name
    
    def get_age(self):
        return self.age

class Student(Person):
    def grade(self, n):
        print(f"{self.name}'s grade is {n}")

 
if __name__ == "__main__":
    stu1 = Student("Galileo", 27)    # (1)
    stu1.grade(99)                   # (2)
    print(stu1.get_name())           # (3)
    print(stu1.get_age())            # (4)

执行结果：

% python personinhe.py
Galileo's grade is 99
Galileo
27

类 Student 继承了类 Person ，相当于将类 Person 的代码完全搬到了类 Student 里，即如同定义了下面的类：

class Student:
    def __init__(self, name, age):  
        self.name = name
        self.age = age
    
    def get_name(self):
        return self.name
    
    def get_age(self):
        return self.age

    def grade(self, n):
        print(f"{self.name}'s grade is {n}")

注释（1）实例化 Student 类，其效果即等同于上述代码——参数 name 和 age 皆来自于父类 Person 的初始化方法。

注释（2）的 grade() 方法是子类 Student 中定义的；注释（3）和（4）的两个实例方法，均在父类中定义。

试想，如果还要定义一个名为 Girl 的类，其中也有一部分代码与 Person 类相同，就可以继续继承 Person 类。如此，Person 类中的代码可以被多次重用。这就是继承的意义所在。

继承了之后，子类如果还有个性化的需要，怎么办？例如，子类 Student 需要再增加一个实例属性 school ，用以说明所属学校。若对子类 Student 进行如下修改：

class Student(Person):
    def __init__(self, school):    # 增加初始化方法
        self.school = school

    def grade(self, n):
        print(f"{self.name}'s grade is {n}")

而后实例化类 Student ，但是会遇到疑惑。按照此前所说，类 Student 继承了类 Person ，那么父类中的 __init__() 方法也就被“搬运”到子类中，而现在子类中又有了一个同名的 __init__() 方法，这就是所谓的重写了父类的该方法，即子类的 __init__() 方法覆盖了父类的此方法，那么在子类中，父类的 __init__() 方法不再显现。按照此逻辑，实例化应当这样做：

if __name__ == "__main__":
    # stu1 = Student("Galileo", 27)
    stu1 = Student("Social University")
    stu1.grade(99) 
    print(stu1.get_name()) 
    print(stu1.get_age())

再执行程序：

 % python personinhe.py
Traceback (most recent call last):
  File "/Users/qiwsir/Documents/my_books/Python完全自学教程/codes/personinhe.py", line 27, in <module>
    stu1.grade(99) 
  File "/Users/qiwsir/Documents/my_books/Python完全自学教程/codes/personinhe.py", line 21, in grade
    print(f"{self.name}'s grade is {n}")
AttributeError: 'Student' object has no attribute 'name'

报错！

在程序开发中，出现错误很正常，这并不可怕，可怕的是没有耐心阅读报错信息。

从输出的异常信息中不难看出，错误在于类 Student 中没有属性 name 。

从前面的程序中可知，属性 name 是类 Person 的 __init__() 方法中所定义的实例属性，现在新写的类 Student 虽然继承了类 Person ，但因为重写了父类的 __init__() 方法，且子类的该初始化方法中没有定义 name 属性，故在实例化 Student 类的时候，报出没有此属性的异常。

现在就提出了一个问题，子类重写或覆盖了父类的方法，但还要在子类中继续使用被覆盖的父类方法——颇有些“儿子打算脱离老子独立，但是还想要老子给予财政支持”的味道。在单继承中，为了解决此问题，可以使用 Python 的一个内置 super() 函数。再次修改 Student 类：

class Student(Person):
    def __init__(self, school, name, age):    # 增加参数
        self.school = school
        super().__init__(name, age)   # (5) 

    def grade(self, n):
        print(f"{self.name}'s grade is {n}")

注释（5）即表示在子类中调用父类中被覆盖的 __init__() 方法——注意此处初始化方法的形参，不再显式地写出 self 。这样，在实例化 Student 类的时候，就需要 school, name, age 三个参数——注意类 Student 的 __init__() 方法中的参数。继续修改程序：

if __name__ == "__main__":
    # stu1 = Student("Galileo", 27)
    stu1 = Student("Social University", "Galileo", 27)
    stu1.grade(99) 
    print(stu1.get_name()) 
    print(stu1.get_age()) 
    print(stu1.school)              # 增加一行

执行程序：

% python personinhe.py
Galileo's grade is 99
Galileo
27
Social University

注释（5）还有两种替代写法，分别是：

super(Student, self).__init__(name, age)
Person.__init__(self, name, age)

在这两种替代写法中，都使用了父类的名称。对于单继承而言，推荐使用注释（5），在后续的多继承中，会使用到替代写法的形式。

不妨将单继承的知识运用到下面的代码优化中。假设有如下所示的两个类：

#coding:utf-8
'''
filename: rectangle.py
'''
class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

    def perimeter(self):
        return 2 * self.length + 2 * self.width

class Square:
    def __init__(self, length):
        self.length = length

    def area(self):
        return self.length * self.length

    def perimeter(self):
        return 4 * self.length

很显然，类 Rectangle 和类 Square 有很多类似之处——数学上也告诉我们，正方形可以看成是长宽相等的矩形。因此，可以将类 Square 利用单继承的知识进行优化——请读者先试试，再看下面的代码。

class Square(Rectangle):
    def __init__(self, length):
        super().__init__(length, length)

顿感简洁，可以发出一声惊叹了。

在此基础上，再设计一个计算正方体（六个面都是正方形，也称立方体、正六面体）的体积和表面积的类，继续使用单继承，当如何编写？思考、尝试后再看参考代码。

class Cube(Square):
    def surface_area(self):
        face_area = super().area()
        return face_area * 6

    def volume(self):
        face_area = super().area()
        return face_area * self.length