【python实操】python小程序之继承

引言

python小程序之继承

文章目录

• 引言
• 一、继承
• • 1.1 概念
  • • 1.1.1 基本语法
    • 1.1.2 关键点解释
    • 1.1.3 示例
    • 1.1.4 总结
  • 1.2 题目
  • 1.3 代码
  • 1.4 代码解释
  • • 1.4.1 类定义
    • 1.4.2 对象创建与方法调用
    • 1.4.3 总结
• 二、思考

一、继承

1.1 概念

python 中的继承是一种强大的机制，它允许一个类（子类或派生类）继承另一个类（父类或基类）的属性和方法。通过继承，子类可以重用父类的代码，并且可以在不改变原有代码的情况下扩展功能

1.1.1 基本语法

class ParentClass:  # 父类
    def __init__(self, value):
        self.value = value

    def method(self):
        print(f"Parent method, value: {self.value}")

class ChildClass(ParentClass):  # 子类继承了ParentClass
    def __init__(self, value, extra_value):
        super().__init__(value)  # 调用父类构造函数
        self.extra_value = extra_value

    def method(self):
        print(f"Child method, value: {self.value}, extra_value: {self.extra_value}")

# 创建对象
parent = ParentClass(10)
child = ChildClass(20, 30)

# 调用方法
parent.method()  # 输出: Parent method, value: 10
child.method()   # 输出: Child method, value: 20, extra_value: 30

1.1.2 关键点解释

1. 定义父类:

   • ParentClass 是一个简单的类，有一个构造函数 __init__ 和一个方法 method

2. 定义子类:

   • ChildClass 继承自 ParentClass，在括号中指定父类
   • 在 ChildClass 的构造函数中，使用 super() 调用父类的构造函数来初始化父类的属性
   • ChildClass 可以添加自己的属性（如 extra_value）和方法，也可以重写（覆盖）父类的方法

3. 调用父类方法:

   • 使用 super() 函数可以调用父类的方法。这有助于保持代码的一致性和可维护性

4. 方法覆盖:

   • 子类可以重写（覆盖）父类的方法，提供不同的实现。例如，ChildClass 重写了 method 方法

5. 多重继承:

   • Python 支持多重继承，即一个类可以从多个父类继承。例如：

     class A:
         def method(self):
             print("Method from A")
     
     class B:
         def method(self):
             print("Method from B")
     
     class C(A, B):
         pass
     
     c = C()
     c.method()  # 输出: Method from A
     

   • 多重继承时，方法解析顺序（MRO）决定了哪个父类的方法会被优先调用。可以通过 __mro__ 属性查看 MRO

6. 抽象基类 (ABC):

   • 使用 abc 模块可以创建抽象基类，其中包含未实现的方法（抽象方法）。子类必须实现这些抽象方法才能被实例化

     from abc import ABC, abstractmethod
     
     class Animal(ABC):
         @abstractmethod
         def speak(self):
             pass
     
     class Dog(Animal):
         def speak(self):
             print("Woof!")
     
     dog = Dog()
     dog.speak()  # 输出: Woof!
     

7. 访问控制:

   • Python 没有严格的访问控制关键字（如 public, private, protected），但可以通过命名约定来模拟这种行为
     • 公有属性和方法：没有任何前缀
     • 私有属性和方法：使用双下划线前缀 __
     • 受保护属性和方法：使用单下划线前缀 _

1.1.3 示例

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("Subclasses must implement this method")

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

# 创建对象
dog = Dog("Buddy")
cat = Cat("Whiskers")

# 调用方法
print(dog.speak())  # 输出: Buddy says Woof!
print(cat.speak())  # 输出: Whiskers says Meow!

在这个例子中，Animal 类是一个抽象基类，因为它包含了一个未实现的方法 speak。Dog 和 Cat 类继承自 Animal 并实现了 speak 方法

1.1.4 总结

通过继承，可以构建出层次清晰、易于维护和扩展的代码结构

1.2 题目

1. 定义一个 动物类，吃
2. 定义一个 狗类, 继承动物类，吃，叫
3. 定义一个 哮天犬类，继承狗类

1.3 代码

class Animal:
    def __init__(self, name):
        self.name = name

    def eat(self):
        print(f'{self.name}动物要吃东西')


class Dog(Animal):
    def eat(self):
        print(f'{self.name}狗要吃东西')
        super().eat()

    def bark(self):
        print(f'{self.name}狗要汪汪汪')


class Xtdog(Dog):
    pass


red_dog = Animal('小红')
red_dog.eat()
print('-'*30)
black_dog = Dog('小黑')
black_dog.eat()
black_dog.bark()
print('-'*30)
white_dog = Xtdog('小白')
white_dog.eat()
white_dog.bark()

输出结果：

1.4 代码解释

这段代码定义了一个简单的类层次结构，展示了 python 中的继承和方法重写

1.4.1 类定义

1. Animal 类:

   • __init__(self, name): 构造函数，初始化 name 属性
   • eat(self): 方法，打印一条消息，表示动物要吃东西

2. Dog 类:

   • 继承自 Animal 类
   • eat(self): 重写 Animal 类的 eat 方法。首先打印一条特定于狗的消息，然后调用父类的 eat 方法
   • bark(self): 新增的方法，打印一条消息，表示狗要汪汪汪

3. Xtdog 类:

   • 继承自 Dog 类，但没有添加或重写任何方法

1.4.2 对象创建与方法调用

1. 创建 Animal 对象 red_dog:

   red_dog = Animal('小红')
   red_dog.eat()
   

   • 创建一个 Animal 类的实例 red_dog，名字为 ‘小红’
   • 调用 eat 方法，输出：小红动物要吃东西

2. 创建 Dog 对象 black_dog:

   black_dog = Dog('小黑')
   black_dog.eat()
   black_dog.bark()
   

   • 创建一个 Dog 类的实例 black_dog，名字为 ‘小黑’
   • 调用 eat 方法，输出：
     • 小黑狗要吃东西
     • 小黑动物要吃东西（通过 super().eat() 调用 Animal 类的 eat 方法）
   • 调用 bark 方法，输出：小黑狗要汪汪汪

3. 创建 Xtdog 对象 white_dog:

   white_dog = Xtdog('小白')
   white_dog.eat()
   white_dog.bark()
   

   • 创建一个 Xtdog 类的实例 white_dog，名字为 ‘小白’
   • 调用 eat 方法，输出：
     • 小白狗要吃东西
     • 小白动物要吃东西（通过 super().eat() 调用 Animal 类的 eat 方法）
   • 调用 bark 方法，输出：小白狗要汪汪汪

1.4.3 总结

通过这个例子，可以看到如何使用继承来扩展类的功能，并且如何在子类中重写父类的方法

二、思考

• red_dog 是 Animal 类的实例，只调用了 eat 方法
• black_dog 是 Dog 类的实例，重写（覆盖+拓展）了 eat 方法，并新增了 bark 方法
• white_dog 是 Xtdog 类的实例，继承了 Dog 类的所有属性和方法，因为 Xtdog 没有添加或重写任何方法