Comment comprendre le polymorphisme en python

Python ne prend pas en charge le polymorphisme, et n'a pas besoin de prendre en charge le polymorphisme. Python est un langage polymorphe qui préconise le typage canard. La sémantique effective d'un objet n'est pas déterminée par l'héritage d'une classe spécifique ou l'implémentation d'une interface spécifique, mais par l'ensemble actuel de méthodes et de propriétés.

Le polymorphisme

est une technique qui permet à un objet parent d'être défini comme égal à un ou plusieurs de ses objets enfants, tels que Parent:=Child; More Morphism permet d'utiliser des pointeurs d'une même classe (classe de base) pour référencer des objets de classes différentes, et d'effectuer la même opération de différentes manières en fonction des objets référencés.

Recommandations associées : "Tutoriel vidéo Python"

class A:
def prt(self):
print("A")
class B(A):
def prt(self):
print("B")
class C(A):
def prt(self):
print("C")
class D(A):
pass
class E:
def prt(self):
print("E")
class F:
pass
def test(arg):
arg.prt()
a = A()
b = B()
c = C()
d = D()
e = E()
f = F()
test(a)
test(b)
test(c)
test(d)
test(e)
test(f)

输出结果

A
B
C
A
E
Traceback (most recent call last):
File "D:/Python/多态1.py", line 45, in <module>
test(f)
File "D:/Python/多态1.py", line 30, in test
arg.prt()
AttributeError: &#39;F&#39; object has no attribute &#39;prt&#39;
Process finished with exit code 1

À première vue, il semble que Python prenne en charge le polymorphisme, appelant test(a), test(b), test( c ), test(d) fonctionne très bien, mais ce qui suit est très différent.
Lors de l'appel de test(e), python appelle simplement la méthode prt de e et ne détermine pas si e est un objet d'une sous-classe de A (en fait, le type du paramètre n'est pas spécifié lors de la définition de la méthode de test , et python ne peut pas le déterminer du tout).
Une erreur se produit lors de l'appel de test(f). La raison est très simple. f n'a pas de méthode prt.

Tout d'abord, Python ne prend pas en charge le polymorphisme, et il n'a pas non plus besoin de prendre en charge le polymorphisme. Python est un langage polymorphe et préconise le typage canard. Ce qui suit est une discussion sur le typage canard sur Wikipédia :

En programmation, le typage canard est un style de typage dynamique. Dans ce style, la sémantique effective d'un objet est déterminée non pas par l'héritage d'une classe spécifique ou par l'implémentation d'une interface spécifique, mais par l'ensemble actuel de méthodes et de propriétés. Le nom de ce concept vient du test du canard proposé par James Whitcomb Riley. Le « test du canard » peut s'exprimer ainsi :

« Quand vous voyez un oiseau qui marche comme un canard, nage comme un canard, et cancane comme un canard, alors l'oiseau peut être appelé un canard »

Dans la frappe du canard, l'accent n'est pas mis sur le type de l'objet lui-même, mais sur la façon dont il est utilisé. Par exemple,
Dans un langage qui n'utilise pas le typage duck, on peut écrire une fonction qui accepte un objet de type duck et appelle ses méthodes walk et aboiement.
Dans un langage utilisant le typage canard, une telle fonction peut accepter un objet de n'importe quel type et appeler ses méthodes walk et call. Si les méthodes qui doivent être appelées n’existent pas, une erreur d’exécution sera générée. Le fait que tout objet avec les méthodes de marche et d'appel correctes puisse être accepté par une fonction conduit à l'instruction ci-dessus, d'où le nom de cette façon de déterminer les types.

Le typage Duck gagne souvent à ne pas tester les types de paramètres dans les méthodes et les fonctions, mais à s'appuyer plutôt sur la documentation, le code clair et les tests pour garantir une utilisation correcte. Les utilisateurs passant de langages à typage statique à des langages à typage dynamique tentent souvent d'ajouter une vérification de type statique (avant l'exécution), compromettant ainsi les avantages et l'évolutivité du typage canard et limitant la nature dynamique du langage.

Il ne fait aucun doute qu'un objet en python est aussi un morceau de mémoire En plus des attributs et des méthodes, la mémoire contient également le type de l'objet. Nous accédons à l'objet via des références, telles que a=. A(). Tout d'abord, python Créez un objet A, puis déclarez une variable a, puis associez la variable a à l'objet A. La variable a n'a pas de type, son type dépend de son objet associé. Lorsque a=A(), a est une référence de type A. On peut dire que a est de type A. Si a se voit attribuer une valeur de 3 et a=3, a est une référence entière, mais python n'est pas faible. Tapez le langage, en python '2'+3 signalera une erreur, tandis qu'en PHP '2'+3 en obtiendra 5. On peut comprendre que les variables en python sont similaires aux pointeurs en c. La différence avec c est que les variables en python peuvent pointer vers n'importe quel type. Bien que ce ne soit pas exact de le dire, c'est plus facile à comprendre.
Par conséquent, pendant le processus d'exécution de python, le type du paramètre n'est pas connu avant que le paramètre ne soit transmis. Bien que la méthode en python soit également une liaison tardive, elle est différente de la liaison tardive polymorphe en Java. La liaison connaît au moins le type de l'objet, mais Python ne connaît pas le type du paramètre.

La méthode test stipule uniquement qu'elle reçoit un paramètre et appelle la méthode prt de ce paramètre. Lors de l'exécution, si ce paramètre a une méthode prt, python l'exécutera. Sinon, python signalera une erreur, car abcde a une méthode prt, mais pas f, donc le résultat ci-dessus est obtenu. C'est ainsi que python s'exécute.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!