Python 中的多态

什么是多态性？

多态性的字面意思是“以不同形式出现的状态”。

多态性是编程中一个非常重要的概念。它指的是使用单一类型的实体（方法、运算符或对象）在不同场景中表示不同类型。

我们来看一个例子

示例 1：加法运算符中的多态性

我们知道 + 运算符在 Python 程序中被广泛使用。但它并非只有一种用法。

对于整数数据类型，+ 运算符用于执行算术加法运算。

num1 = 1
num2 = 2
print(num1+num2)

因此，上述程序输出 3。

同样，对于字符串数据类型，+ 运算符用于执行连接操作。

str1 = "Python"
str2 = "Programming"
print(str1+" "+str2)

结果，上述程序输出 Python Programming。

在这里，我们可以看到一个单一的运算符 + 被用于对不同的数据类型执行不同的操作。这是 Python 中多态性最简单的表现之一。

Python 中的函数多态性

Python 中有一些函数兼容多种数据类型。

其中一个函数是 len() 函数。它可以在 Python 中与许多数据类型一起运行。让我们看看该函数的一些示例用例。

示例 2：多态的 len() 函数

print(len("Programiz"))
print(len(["Python", "Java", "C"]))
print(len({"Name": "John", "Address": "Nepal"}))

输出

9
3
2

在这里，我们可以看到许多数据类型，如字符串、列表、元组、集合和字典都可以与 len() 函数一起使用。然而，我们可以看到它返回特定数据类型的特定信息。

Python 中的类多态性

多态性是面向对象编程中一个非常重要的概念。

要了解更多关于 Python 面向对象编程的信息，请访问：Python 面向对象编程

我们可以在创建类方法时使用多态性概念，因为 Python 允许不同的类拥有同名的方法。

然后，我们可以通过忽略我们正在使用的对象来概括地调用这些方法。让我们看一个例子

示例 3：类方法中的多态性

class Cat:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(f"I am a cat. My name is {self.name}. I am {self.age} years old.")

    def make_sound(self):
        print("Meow")


class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(f"I am a dog. My name is {self.name}. I am {self.age} years old.")

    def make_sound(self):
        print("Bark")


cat1 = Cat("Kitty", 2.5)
dog1 = Dog("Fluffy", 4)

for animal in (cat1, dog1):
    animal.make_sound()
    animal.info()
    animal.make_sound()

输出

Meow
I am a cat. My name is Kitty. I am 2.5 years old.
Meow
Bark
I am a dog. My name is Fluffy. I am 4 years old.
Bark

在这里，我们创建了两个类 Cat 和 Dog。它们具有相似的结构，并且拥有相同的方法名 info() 和 make_sound()。

然而，请注意，我们没有创建共同的超类，也没有以任何方式将这些类连接起来。即便如此，我们仍然可以将这两个不同的对象打包成一个元组，并使用一个共同的 animal 变量对其进行迭代。这归因于多态性。

多态性与继承

与其他编程语言一样，Python 中的子类也继承了父类的方法和属性。我们可以重新定义某些方法和属性以特别适合子类，这称为方法重写。

多态性允许我们访问这些与父类同名的被重写的方法和属性。

我们来看一个例子

示例 4：方法重写

from math import pi


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

    def area(self):
        pass

    def fact(self):
        return "I am a two-dimensional shape."

    def __str__(self):
        return self.name


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

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

    def fact(self):
        return "Squares have each angle equal to 90 degrees."


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

    def area(self):
        return pi*self.radius**2


a = Square(4)
b = Circle(7)
print(b)
print(b.fact())
print(a.fact())
print(b.area())

输出

Circle
I am a two-dimensional shape.
Squares have each angle equal to 90 degrees.
153.93804002589985

在这里，我们可以看到子类中未被重写的方法，例如 __str__()，是从父类使用的。

由于多态性，Python 解释器会自动识别对象 a（Square 类）的 fact() 方法已被重写。因此，它使用子类中定义的方法。

另一方面，由于对象 b 的 fact() 方法未被重写，因此它使用的是父类 Shape 中的方法。

注意：方法重载，一种创建多个同名但参数不同的方法的方式，在 Python 中是不可能的。

另请阅读

• Python 继承