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

news2024/11/24 20:10:11

引言

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 关键点解释

定义父类:
- ParentClass 是一个简单的类，有一个构造函数 __init__ 和一个方法 method
定义子类:
- ChildClass 继承自 ParentClass，在括号中指定父类
- 在 ChildClass 的构造函数中，使用 super() 调用父类的构造函数来初始化父类的属性
- ChildClass 可以添加自己的属性（如 extra_value）和方法，也可以重写（覆盖）父类的方法
调用父类方法:
- 使用 super() 函数可以调用父类的方法。这有助于保持代码的一致性和可维护性
方法覆盖:
- 子类可以重写（覆盖）父类的方法，提供不同的实现。例如，ChildClass 重写了 method 方法

多重继承:

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

抽象基类 (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!

访问控制:
- 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.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 类定义

Animal 类:
- __init__(self, name): 构造函数，初始化 name 属性
- eat(self): 方法，打印一条消息，表示动物要吃东西
Dog 类:
- 继承自 Animal 类
- eat(self): 重写 Animal 类的 eat 方法。首先打印一条特定于狗的消息，然后调用父类的 eat 方法
- bark(self): 新增的方法，打印一条消息，表示狗要汪汪汪
Xtdog 类:
- 继承自 Dog 类，但没有添加或重写任何方法

1.4.2 对象创建与方法调用

创建 Animal 对象 red_dog:
```
red_dog = Animal('小红')
red_dog.eat()
```
- 创建一个 Animal 类的实例 red_dog，名字为 ‘小红’
- 调用 eat 方法，输出：小红动物要吃东西
创建 Dog 对象 black_dog:
```
black_dog = Dog('小黑')
black_dog.eat()
black_dog.bark()
```
- 创建一个 Dog 类的实例 black_dog，名字为 ‘小黑’
- 调用 eat 方法，输出：
  - 小黑狗要吃东西
  - 小黑动物要吃东西（通过 super().eat() 调用 Animal 类的 eat 方法）
- 调用 bark 方法，输出：小黑狗要汪汪汪
创建 Xtdog 对象 white_dog:
```
white_dog = Xtdog('小白')
white_dog.eat()
white_dog.bark()
```
- 创建一个 Xtdog 类的实例 white_dog，名字为 ‘小白’
- 调用 eat 方法，输出：
  - 小白狗要吃东西
  - 小白动物要吃东西（通过 super().eat() 调用 Animal 类的 eat 方法）
- 调用 bark 方法，输出：小白狗要汪汪汪