Python Polymorphie

在本教程中，我们将学习多态，不同类型的多态以及如何借助示例演示在Python中实现它们。

什么是多态？

多态性的字面意思是指以不同形式出现的条件。

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

让我们举个实例：

Beispiel1：加法运算符的多态

我们知道 + 运算符已在Python程序中广泛使用。但是，它没有单一用法。

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

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

因此，以上程序输出 3

类似地，对于字符串数据类型，使用 + 运算符进行连接。

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

结果，以上程序输出 : Python Programming

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

Python中的函数多态

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

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

Beispiel2：多态len()函数

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

Ausgabefolge

5
3
2

Hier können wir sehen, dass viele Datentypen (z.B. Strings, Listen, Tupel, Mengen und Dictionarys) die len() - Funktion verwenden können. Aber wir können sehen, dass es spezifische Informationen über den bestimmten Datentyp zurückgibt.

Polymorphie der Klassen in Python

Polymorphie ist ein sehr wichtiger Begriff in der objektorientierten Programmierung.

Besuchen Sie bitte: für weitere Informationen über OOP in PythonPython-orientierte objektorientierte Programmierung

Bei der Erstellung von Klassenmethoden können wir das Konzept der Polymorphie verwenden, da Python verschiedene Klassen Methoden mit dem gleichen Namen erlauben.

Dann können wir diese Methodenaufrufe später durch das Ignorieren des momentan verwendeten Objekts abstrahieren. Lassen Sie uns einen Beispiel betrachten:

Beispiel3：类方法中的多态

class Cat:
　　　　def __init__(self, name, age):
　　　　　　　　self.name = name
　　　　　　　　self.age = age
　　　　def info(self):
　　　　　　　　print(f"Ich bin eine Katze. Mein Name ist {self.name}. Ich bin {self.age} Jahre alt.")
　　　　def make_sound(self):
　　　　　　　　print("Meow")
class Dog:
　　　　def __init__(self, name, age):
　　　　　　　　self.name = name
　　　　　　　　self.age = age
　　　　def info(self):
　　　　　　　　print(f"Ich bin ein Hund. Mein Name ist {self.name}. Ich bin {self.age} Jahre alt.")
　　　　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()

Ausgabefolge

Meow
Ich bin eine Katze. Mein Name ist Kitty. Ich bin　2.5　Jahr.
Meow
Bark
Ich bin ein Hund. Mein Name ist Fluffy. Ich bin　　4　Jahr.
Bark

Hier haben wir die beiden Klassen Cat und Dog erstellt. Sie haben eine ähnliche Struktur und haben die gleichen Methodennamen info() und make_sound().

Bitte beachten Sie jedoch, dass wir noch keine öffentliche Superklasse erstellt haben oder die Klassen auf irgendeine Weise miteinander verknüpft haben. Selbst so können wir diese beiden verschiedenen Objekte in ein Tupel verpacken und mit einem gemeinsamen animal-Variablen iterieren. Dies ist aufgrund der Polymorphie erlaubt.

Polymorphie und Vererbung

Wie in anderen Programmiersprachen auch, erbt die Unterklasse in Python Methoden und Eigenschaften von der Superklasse. Wir können bestimmte Methoden und Eigenschaften speziell für die Unterklasse neu definieren, was alsMethod Overriding（方法重写）。

Polymorphie ermöglicht es uns, auf diese überschriebenen Methoden und Eigenschaften, die mit der Superklasse gleichnamig sind, zuzugreifen.

Lassen Sie uns einen Beispiel betrachten:

Beispiel4：方法重写

from math import pi
class Shape:
　　　　def __init__(self, name):
　　　　　　　　self.name = name
　　　　def area(self):
　　　　　　　　pass
　　　　def fact(self):
　　　　　　　　return "Ich bin eine zweidimensionale Form."
　　　　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 "Jeder Winkel des Quadrats ist"90 Grad."
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())

Ausgabefolge

Circle
Ich bin eine zweidimensionale Form.
Jeder Winkel des Quadrats ist90 Grad.
153.93804002589985

Hier können wir sehen, dass Methoden wie __str__() verwendet werden, die in der Unterklasse nicht überschrieben wurden.

Durch Polymorphie erkennt der Python-Interpreter automatisch, dass die Methode fact() des Objekts a (Square-Klasse) überschrieben wurde. Er verwendet die in der Unterklasse definierte.

Andererseits kann die Methode fact() von Objekt b nicht überschrieben werden, daher kann sie aus der Klasse Parent Shape verwendet werden.

Beachten Sie:Methode überschreibenDies ist eine Methode, die es nicht ermöglicht, in Python eine Methode mit dem gleichen Namen und verschiedenen Parametern zu erstellen.