【Python篇】Python 类和对象:详细讲解(中篇)

本文涉及的产品
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
全局流量管理 GTM,标准版 1个月
云解析 DNS,旗舰版 1个月
简介: 【Python篇】Python 类和对象:详细讲解(中篇)

Python 类和对象:详细讲解

前言

在编程中,对象面向对象编程(OOP)的核心概念。Python 是一门支持面向对象编程的语言,这意味着你可以使用类和对象来组织代码,使其更加模块化、可维护和可扩展。


9. 方法重写(Method Overriding)

方法重写是在子类中定义与父类中同名的方法,以覆盖或扩展父类的行为。通过方法重写,子类可以改变或定制从父类继承的方法的功能。

9.1 为什么需要方法重写?

在继承中,子类会继承父类的所有方法和属性。然而,有时你可能希望子类的某些方法与父类的方法表现不同。这时,你就可以在子类中重写这些方法。

9.2 方法重写的基本示例

我们来定义一个基本的 Car 类,然后在子类 ElectricCar 中重写它的方法。

class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color
        self.speed = 0

    def start(self):
        self.speed = 10
        print(f"The {self.color} {self.brand} car is starting at {self.speed} km/h.")

    def stop(self):
        self.speed = 0
        print(f"The {self.color} {self.brand} car is stopping.")

# 定义一个 ElectricCar 类,继承自 Car 类
class ElectricCar(Car):
    def __init__(self, brand, color, battery_capacity):
        super().__init__(brand, color)  # 调用父类的构造函数初始化 brand 和 color
        self.battery_capacity = battery_capacity

    def start(self):
        # 重写 start 方法,让电动汽车以不同的方式启动
        self.speed = 20  # 电动汽车启动时速度更快
        print(f"The {self.color} {self.brand} electric car is silently starting at {self.speed} km/h with {self.battery_capacity} kWh capacity.")

    def charge(self):
        print(f"The {self.color} {self.brand} electric car is charging with {self.battery_capacity} kWh capacity.")

# 创建 ElectricCar 对象并使用它
electric_car = ElectricCar("Tesla", "White", 85)
electric_car.start()  # 输出: The White Tesla electric car is silently starting at 20 km/h with 85 kWh capacity.
electric_car.stop()   # 输出: The White Tesla car is stopping.
electric_car.charge()  # 输出: The White Tesla electric car is charging with 85 kWh capacity.

9.3 代码详解

  • 父类 Car 的方法Car 类定义了 startstop 方法。start 方法设置初始速度为 10 km/h,stop 方法将速度设为 0。

子类 ElectricCar 的方法重写:

  • ElectricCar 继承了 Car 的所有属性和方法。
  • ElectricCar 重写了 start 方法,使其启动速度为 20 km/h,并增加了电池容量的输出。
  • super().__init__(brand, color) 调用了父类的构造函数,以确保 brandcolor 属性被正确初始化。

10. 多继承(Multiple Inheritance)

多继承是指一个类可以同时继承多个父类的特性。Python 支持多继承,但使用时需要注意可能的复杂性,尤其是在多个父类中有相同方法的情况下。

10.1 多继承的概念

多继承允许一个子类同时从多个父类中继承方法和属性。这种特性非常强大,但也可能带来复杂的依赖关系。

10.2 多继承的示例

创建两个父类 VehicleElectric,然后定义一个子类 ElectricCar,它同时继承自这两个父类。

class Vehicle:
    def __init__(self, brand):
        self.brand = brand

    def start(self):
        print(f"The {self.brand} vehicle is starting.")

class Electric:
    def __init__(self, battery_capacity):
        self.battery_capacity = battery_capacity

    def charge(self):
        print(f"Charging with {self.battery_capacity} kWh battery capacity.")

# ElectricCar 继承了 Vehicle 和 Electric
class ElectricCar(Vehicle, Electric):
    def __init__(self, brand, color, battery_capacity):
        Vehicle.__init__(self, brand)  # 初始化 Vehicle 类的属性
        Electric.__init__(self, battery_capacity)  # 初始化 Electric 类的属性
        self.color = color

    def start(self):
        print(f"The {self.color} {self.brand} electric car is silently starting with {self.battery_capacity} kWh battery.")

# 使用 ElectricCar 类
electric_car = ElectricCar("Tesla", "White", 85)
electric_car.start()   # 输出: The White Tesla electric car is silently starting with 85 kWh battery.
electric_car.charge()  # 输出: Charging with 85 kWh battery capacity.

10.3 代码详解

  • VehicleElectric 父类:这两个类分别提供 brandbattery_capacity 属性,并各自定义了 startcharge 方法。

ElectricCar 的多继承:

  • ElectricCar 同时继承了 VehicleElectric 的属性和方法。
  • 通过在 __init__ 方法中分别调用 Vehicle.__init__(self, brand)
  • Electric.__init__(self, battery_capacity) 来初始化父类的属性。
  • ElectricCar 中的 start 方法重写了 Vehicle 类的 start 方法,以自定义启动行为。

10.4 方法解析顺序(MRO)

当使用多继承时,Python 会根据方法解析顺序(MRO)来决定调用哪个父类的方法。MRO 是 Python 确定方法调用顺序的规则。

  • 查看 MRO
  • 你可以通过 ClassName.mro() 方法查看一个类的 MRO。

例如:

print(ElectricCar.mro())

这将输出:

[<class '__main__.ElectricCar'>, <class '__main__.Vehicle'>, <class '__main__.Electric'>, <class 'object'>]
  • MRO 解析顺序:Python 会从左到右、从上到下地查找方法。在本例中,ElectricCar 先查找自身,然后是 Vehicle,接着是 Electric,最后是 Python 所有类的基类 object

11. 类的组合(Composition)

类的组合是指一个类可以包含其他类的实例作为属性,从而创建更复杂的对象。与继承相比,组合更灵活,因为它不涉及继承链的复杂性。

11.1 什么是类的组合?

类的组合通过在一个类中包含另一个类的实例,来实现功能模块化。这种方法使得类的职责更加明确,也让代码更加易于维护。

11.2 类的组合的示例

让我们定义一个 Battery 类,并将其组合到 ElectricCar 中。

class Battery:
    def __init__(self, capacity):
        self.capacity = capacity

    def charge(self):
        print(f"Charging the battery with {self.capacity} kWh capacity.")

class ElectricCar:
    def __init__(self, brand, color, battery_capacity):
        self.brand = brand
        self.color = color
        self.battery = Battery(battery_capacity)  # 组合 Battery 类

    def start(self):
        print(f"The {self.color} {self.brand} electric car is starting.")

    def charge(self):
        self.battery.charge()  # 调用 Battery 类的 charge 方法

# 使用 ElectricCar 类
electric_car = ElectricCar("Tesla", "White", 85)
electric_car.start()  # 输出: The White Tesla electric car is starting.
electric_car.charge()  # 输出: Charging the battery with 85 kWh capacity.
11.3 代码详解
  • Battery 类Battery 类代表电动汽车的电池。它有一个 charge 方法来模拟充电。
  • ElectricCar 的组合:
  • ElectricCar 类拥有一个 Battery 类的实例,作为其 battery 属性。
  • 当调用 electric_car.charge() 时,实际是调用 Battery 类的 charge 方法。
11.4 组合与继承的对比
  • 继承:用于创建一个“是一个”关系的类结构,例如 ElectricCar 是一个 Car
  • 组合:用于创建一个“有一个”关系的类结构,例如 ElectricCar 有一个 Battery

组合通常比继承更灵活,因为你可以在不改变类继承层次的情况下,动态地更改组合类的行为。


12. 总结3

在本次学习中,你已经掌握了以下关键概念:

  • 方法重写:通过在子类中定义与父类同名的方法,你可以重写父类的方法,从而定制子类的行为。重写方法时,子类的方法会覆盖父类的同名方法,这是实现多态性的重要方式。
  • 多继承:Python 支持一个类同时继承多个父类的属性和方法。多继承虽然强大,但使用时需要注意方法解析顺序(MRO)和潜在的复杂性。通过多继承,你可以复用多个类的功能,从而创建功能更加丰富的子类。
  • 类的组合:通过在一个类中包含其他类的实例,你可以创建复杂的对象结构。这种方法比多继承更加灵活且易于维护,因为它不涉及复杂的继承关系。组合强调对象之间的协作,而不是继承层次中的耦合。

13.方法解析顺序(MRO)

在多继承中,方法解析顺序(MRO)是 Python 用来确定类层次结构中的方法调用顺序的机制。理解 MRO 对于有效使用多继承和调试复杂的类层次结构非常重要。

13.1 MRO 的基本概念

MRO 决定了当你调用一个方法时,Python 如何查找该方法的定义。MRO 是通过一种称为 C3 线性化的算法来计算的,该算法确保了类层次结构中的一致性和方法解析的确定性。

13.2 查看 MRO

你可以使用类的 mro() 方法或 __mro__ 属性来查看一个类的 MRO。

例如:

class A:
    pass

class B(A):
    pass

class C(A):
    pass

class D(B, C):
    pass

print(D.mro())

输出将显示 D 类的 MRO:

[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

13.3 复杂继承结构中的 MRO

当类层次结构变得复杂时,MRO 可以帮助你理解方法调用的顺序。例如,如果 D 类继承了 BC,而 BC 又都继承自 A,MRO 可以告诉你调用 D 的方法时,Python 是如何在 BCA 之间选择方法的。

通过了解 MRO,你可以避免潜在的方法冲突,并确保你的代码在多继承情况下能够按照预期工作。


14. 抽象类和接口

在面向对象编程中,抽象类和接口用于定义类的框架和通用行为,确保子类实现这些行为。

14.1 什么是抽象类?

抽象类是一种不能被实例化的类,它通常用于定义子类必须实现的方法。抽象类提供了一个模板,让你可以确保所有子类都具有某些共同的行为。

14.2 Python 中的抽象类

在 Python 中,你可以使用 abc 模块中的 ABCabstractmethod 来定义抽象类和抽象方法。

例如:

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def sound(self):
        pass

class Dog(Animal):
    def sound(self):
        return "Woof!"

class Cat(Animal):
    def sound(self):
        return "Meow!"

在这个例子中,Animal 是一个抽象类,它定义了一个抽象方法 sound。任何继承 Animal 的子类都必须实现 sound 方法,否则会引发错误。

14.3 抽象类的用途

  • 统一接口:抽象类强制子类实现某些方法,从而确保所有子类有统一的接口。
  • 代码复用:抽象类可以包含具体的方法实现,这些方法可以被子类继承和复用。
  • 增强代码的可维护性:通过抽象类,你可以更容易地理解和维护子类之间的关系和行为。


以上就是关于【Python篇】Python 类和对象:详细讲解(中篇)的内容啦,各位大佬有什么问题欢迎在评论区指正,您的支持是我创作的最大动力!❤️

目录
相关文章
|
2月前
|
索引 Python
python-类属性操作
【10月更文挑战第11天】 python类属性操作列举
22 1
|
2月前
|
Java C++ Python
Python基础---类
【10月更文挑战第10天】Python类的定义
26 2
|
2月前
|
设计模式 开发者 Python
Python类里引用其他类
Python类里引用其他类
27 4
|
2月前
|
设计模式 开发者 Python
Python 类中引用其他类的实现详解
Python 类中引用其他类的实现详解
41 1
WK
|
2月前
|
Python
Python类命名
在Python编程中,类命名至关重要,影响代码的可读性和维护性。建议使用大写驼峰命名法(如Employee),确保名称简洁且具描述性,避免使用内置类型名及单字母或数字开头,遵循PEP 8风格指南,保持项目内命名风格一致。
WK
15 0
|
2月前
|
程序员 开发者 Python
深度解析Python中的元编程:从装饰器到自定义类创建工具
【10月更文挑战第5天】在现代软件开发中,元编程是一种高级技术,它允许程序员编写能够生成或修改其他程序的代码。这使得开发者可以更灵活地控制和扩展他们的应用逻辑。Python作为一种动态类型语言,提供了丰富的元编程特性,如装饰器、元类以及动态函数和类的创建等。本文将深入探讨这些特性,并通过具体的代码示例来展示如何有效地利用它们。
40 0
|
2月前
|
Python
Python中的类(一)
Python中的类(一)
17 0
|
2月前
|
Python
Python中的类(一)
Python中的类(一)
17 0
|
2月前
|
Python
Python中的类(二)
Python中的类(二)
17 0
|
2月前
|
开发者 Python
Python类和子类的小示例:建模农场
Python类和子类的小示例:建模农场
14 0