• 周二. 2月 7th, 2023

Python 多态使用方法详解

城主

12月 27, 2022 ,

多态是一种编程概念,指的是在不同类型的对象之间共享相同的接口。这意味着,在调用某个方法或属性时,无需知道对象的具体类型,只需知道它具有指定的接口即可。

在 Python 中,多态可以通过继承和重写父类方法来实现。例如,假设我们有一个基类 Shape,它有一个方法 area,用于计算图形的面积。然后,我们可以定义一些子类,如 CircleRectangle,每个子类都继承了 Shape 类并重写了 area 方法,以便计算各自的面积。





class Shape:
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

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

现在,我们可以通过创建不同类型的图形对象并调用 area 方法来使用多态。





circle = Circle(5)
print(circle.area())  # 输出: 78.5

rectangle = Rectangle(10, 20)
print(rectangle.area())  # 输出: 200

在这种情况下,无需知道 circlerectangle 的具体类型,我们就可以调用它们的 area 方法。多态使得代码更加灵活,因为我们可以将对象当做它们所实现的接口来使用,而无需关心它们的具体类型。这使得我们能够在不改变原有代码的情况下添加新的类型和功能,并且不会影响原有代码的正常运行。

需要注意的是,在 Python 中,类型检查是运行时进行的,因此实际上并没有真正的多态。相反,Python 使用了动态绑定,即在运行时决定对象使用哪个方法或属性。

在 Python 中,我们可以使用内置函数 isinstance 来检查一个对象是否属于某个类型,或者使用 issubclass 函数来检查一个类是否是另一个类的子类。

例如:





print(isinstance(circle, Circle))  # 输出: True
print(isinstance(circle, Shape))   # 输出: True
print(isinstance(circle, Rectangle))  # 输出: False

print(issubclass(Circle, Shape))  # 输出: True
print(issubclass(Rectangle, Shape))  # 输出: True
print(issubclass(Shape, Circle))  # 输出: False

多态还可以用于更复杂的场景,例如实现设计模式中的策略模式或命令模式。

阅读  Python 云服务

在策略模式中,我们可以定义一个接口,该接口用于定义特定的算法。然后,我们可以定义多个实现该接口的类,每个类实现了不同的算法。最后,我们可以在运行时动态地选择所需的算法并使用它。

例如,我们可以定义一个 SortStrategy 接口,用于定义排序算法,然后定义两个类 BubbleSortQuickSort,分别实现冒泡排序和快速排序算法。





from abc import ABC, abstractmethod

class SortStrategy(ABC):
    @abstractmethod
    def sort(self, data):
        pass

class BubbleSort(SortStrategy):
    def sort(self, data):
        # 实现冒泡排序
        pass

class QuickSort(SortStrategy):
    def sort(self, data):
        # 实现快速排序
        pass

然后,我们可以定义一个 Sorter 类,该类接收一个 SortStrategy 对象并使用它来对数据进行排序。





class Sorter:
    def __init__(self, strategy):
        self.strategy = strategy

    def sort(self, data):
        return self.strategy.sort(data)

现在,我们可以在运行时创建不同的排序策略对象,并使用它们来排序数据。





data = [3, 2, 1]

sorter = Sorter(BubbleSort())
sorter.sort(data)  # 使用冒泡排序算法排序

sorter = Sorter(QuickSort())
sorter.sort(data)  # 使用快速排序算法排序

这样,我们就可以在不改变 Sorter 类的代码的情况下添加新的排序算法,只需要实现 SortStrategy 接口并创建新的策略对象即可。

命令模式也是一种常见的多态设计模式,它允许我们将请求封装为对象,以便将请求参数化,并在不同的时间或地点使用它们。

为了演示命令模式,我们可以假设有一个电灯控制器,它可以执行打开或关闭电灯的操作。我们可以定义一个 Command 接口,用于定义执行操作的方法。然后,我们可以定义两个类 TurnOnCommandTurnOffCommand,分别实现打开和关闭电灯的操作。





from abc import ABC, abstractmethod

class Command(ABC):
    @abstractmethod
    def execute(self):
        pass

class TurnOnCommand(Command):
    def __init__(self, light):
        self.light = light

    def execute(self):
        self.light.turn_on()

class TurnOffCommand(Command):
    def __init__(self, light):
        self.light = light

    def execute(self):
        self.light.turn_off()

然后我们可以定义一个 Light 类来模拟电灯,并在其中实现 turn_onturn_off 方法。





class Light:
    def turn_on(self):
        print('Turning on the light')

    def turn_off(self):
        print('Turning off the light')

最后,我们可以定义一个 LightController 类来接收 Command 对象并执行它们。





class LightController:
    def execute(self, command):
        command.execute()

现在,我们可以在运行时创建不同的命令对象并使用它们来控制电灯。





light = Light()
controller = LightController()

controller.execute(TurnOnCommand(light))  # 输出: Turning on the light
controller.execute(TurnOffCommand(light))  # 输出: Turning off the light

通过使用多态,我们可以将控制电灯的操作封装为对象,并在不同的时间或地点使用它们。这使得代码更加灵活,因为我们可以在不改变原有代码的情况下添加新的命令并执行它们。

阅读  Python 自然语言处理(NLP)领域入门