Polymorphisme en Python

Dans ce tutoriel, nous allons étudier le poly morphisme, le poly morphisme de différents types et comment les démontrer avec des exemples en Python.

Qu'est-ce que le poly morphisme ?

Le sens littéral du poly morphisme est qu'il s'agit de conditions apparaissant sous différentes formes.

Le poly morphisme est une conception importante en programmation. Il s'agit d'utiliser un type d'entité unique (méthode, opérateur ou objet) pour représenter différents scénarios dans différentes situations.

Laissez-nous prendre un exemple :

Example1：Poly morphisme de l'opérateur d'addition

Nous savons + Les opérateurs sont largement utilisés dans les programmes Python. Mais ils n'ont pas une utilisation unique.

Pour le type de données entiers, utilisez + Les opérateurs exécutent l'addition arithmétique.

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

Par conséquent, le programme suivant sort 3

De même, pour le type de données chaîne, utilisez + les opérateurs pour la concaténation.

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

Le résultat, le programme suivant sort : Programmation Python

Ici, nous pouvons voir l'utilisation de l'opérateur + Des opérations différentes sont exécutées pour différents types de données. C'est l'un des poly morphismes les plus simples en Python.

Poly morphisme des fonctions en Python

Python comporte certains fonctions qui sont compatibles avec plusieurs types de données.

L'une de ces fonctions est la fonction len(). Elle peut fonctionner avec de nombreux types de données en Python. Voici quelques exemples d'utilisation de cette fonction.

Example2：Poly morphisme de la fonction len()

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

Output result

5
3
2

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

Python中的类多态

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

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

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

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

Example3：类方法中的多态

class　Cat:
　　　　def　__init__(self,　name,　age):
　　　　　　　　self.name = name
　　　　　　　　self.age = age
　　　　def　info(self):
　　　　　　　　print(f"Je suis un chat. Mon nom est {self.name}. Je suis {self.age} ans.")
　　　　def　make_sound(self):
　　　　　　　　print("Meow")
class　Dog:
　　　　def　__init__(self,　name,　age):
　　　　　　　　self.name = name
　　　　　　　　self.age = age
　　　　def　info(self):
　　　　　　　　print(f"Je suis un chien. Mon nom est {self.name}. Je suis {self.age} ans.")
　　　　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()

Output result

Meow
Je suis un chat. Mon nom est Kitty. Je suis　2.5　岁.
Meow
Bark
Je suis un chien. Mon nom est Fluffy. Je suis　　4　岁.
Bark

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

但是，请注意，我们还没有创建公共的超类或以任何方式将这些类链接在一起。即使这样，我们也可以将这两个不同的对象打包到一个元组中，并使用一个公共animal变量对其进行迭代。由于多态性，这是允许的。

多态与继承

与其他编程语言一样，Python中的子类也从父类继承方法和属性。我们可以专门针对子类重新定义某些方法和属性，这称为Method Overriding（方法重写）。

多态性使我们能够访问与父类同名的这些覆盖的方法和属性。

让我们看一个实例：

Example4：方法重写

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 "Each corner of the square is"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())

Output result

Circle
I am a two-dimensional shape.
Each corner of the square is90 degrees.
153.93804002589985

Here, we can see that methods such as __str__ that have not been overridden in the subclass are used in the superclass.

Due to polymorphism, the Python interpreter automatically recognizes that the fact() method of object a (Square class) has been overridden. It uses the one defined in the subclass.

On the other hand, since the fact() method of object b has not been overridden, it can be used from the Parent Shape class.

Note:Method overloadingIt is a method that cannot be created with the same name but different parameters in Python.