了解Python中的多态

什么是多态

    多态性（polymorphism）的字面意思是不同形式出现的条件。多态性是编程中一个非常重要的概念。它是指使用单个类型实体（方法、运算符或对象）来表示不同场景中的不同类型（我理解的多态，就像一个人，会有很多身份，在家庭中是父亲，在公司中是员工，在高校中是学生，这些身份彼此无关却都属于一个人，这个人就具有多态的性质）。
示例1：加法运算符的多态
    我们知道+运算符在Python程序中广泛使用，但是它的用法并不单一。对于整数数据类型，+运算符被用来执行算术加法运算。

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

    上述程序输出3。
    同样，对于字符串数据类型，+运算符被用于执行串联。

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

    结果，以上程序输出 Python Programming。
    在这里，我们可以看到使用一个+运算符对不同的数据类型执行了不同的操作。这是Python中最简单的多态现象之一。

Python中的函数多态

    Python中有一些函数可以与多种数据类型兼容。len() 函数可以在Python中与许多数据类型一起运行。
示例2：多态 len() 函数

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

    在这里，我们可以看到许多数据类型（例如字符串，列表，元组，集合和字典）都可以使用该 len() 函数，同时，len() 函数返回特定数据类型的相关信息。

Python中 len() 函数的多态

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中的子类也从父类继承方法和属性。我们可以专门针对子类重新定义某些方法和属性，这称为方法重写（Method Overriding）。多态性允许我们访问这些与父类同名的重写方法和属性。
示例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 的 fact() 方法（Square类）已经被重写。因此，它使用子类中定义的 fact() 方法。
    另一方面，由于对象 b 的 fact() 方法没有被重写，所以它使用父类Shape的 fact() 方法。

Python父类和子类中的多态

参考文献

https://www.programiz.com/python-programming/polymorphism