Python est l'un des langages de programmation les plus populaires en raison de sa polyvalence et de sa syntaxe conviviale . Comme d'autres langages qui prennent en charge la programmation orientée objet (POO), Python est polymorphe . Cela signifie qu'un seul opérateur, fonction ou méthode de classe en Python peut avoir plusieurs utilisations. Ces diverses utilisations peuvent être difficiles à apprendre, mais elles font finalement de Python un langage plus efficace.

Aujourd'hui, nous allons discuter du polymorphisme et de son fonctionnement en Python.

Nous aborderons les sujets suivants :

• Qu'est-ce que le polymorphisme ?
• Exemples de polymorphisme en Python
• Tutoriel sur le polymorphisme Python
• Conclusion et prochaines étapes

Le polymorphisme est le principe selon lequel un type de chose peut prendre diverses formes. Dans le contexte de la programmation, cela signifie qu'une seule entité dans un langage de programmation peut se comporter de plusieurs manières en fonction du contexte. C'est similaire à la façon dont un mot comme "express" peut agir comme un verbe dans une phrase, un nom dans une autre phrase et un adjectif dans une troisième phrase. La séquence des lettres sur la page ne change pas, mais le sens qu'elles ajoutent à la phrase est fondamentalement différent dans chaque cas. De même, dans les langages de programmation polymorphes, une seule entité peut agir différemment dans différents contextes.

Exemples de polymorphisme en Python

Le polymorphisme est une condition de base de Python et affecte le fonctionnement du langage à plusieurs niveaux. Aujourd'hui, nous allons nous concentrer sur le polymorphisme des opérateurs, des fonctions et des méthodes de classe en Python.

Polymorphisme d'opérateur

Le polymorphisme d'opérateur, ou surcharge d'opérateur, signifie qu'un symbole peut être utilisé pour effectuer plusieurs opérations . L'un des exemples les plus simples est l'opérateur d'addition +. L'opérateur d'addition de Python fonctionne différemment selon les différents types de données.

Par exemple, si le +opère sur deux entiers, le résultat est additif, renvoyant la somme des deux entiers.

int1 = 10
int2 = 15
print(int1 + int2)
# returns 25

Cependant, si l'opérateur d'addition est utilisé sur deux chaînes, il concatène les chaînes. Voici un exemple de la façon dont l' +opérateur agit sur les types de données de chaîne.

str1 = "10"
str2 = "15"
print(str1 + str2)
# returns 1015

Polymorphisme de fonction

Certaines fonctions de Python sont également polymorphes, ce qui signifie qu'elles peuvent agir sur plusieurs types de données et structures pour produire différents types d'informations.

La fonction intégrée de Python len(), par exemple, peut être utilisée pour renvoyer la longueur d'un objet. Cependant, il mesurera la longueur de l'objet différemment selon le type de données et la structure de l'objet. Par exemple, si l'objet est une chaîne, la len()fonction renverra le nombre de caractères dans la chaîne. Si l'objet est une liste, il renverra le nombre d'entrées dans la liste.

Voici un exemple de la façon dont la len()fonction agit sur les chaînes et les listes :

str1 = "animal"
print(len(str1))
# returns 6
list1 = ["giraffe","lion","bear","dog"]
print(len(list1))
# returns 4

Polymorphisme de classe et de méthode

La nature polymorphe de Python facilite la réaffectation des classes et des méthodes. Souvenez-vous qu'une classe est comme un blueprint et qu'un objet est une instanciation concrète de ce blueprint . Ainsi, une méthode qui fait partie d'une classe se reproduira dans les objets qui instancient cette classe. De même, si vous générez une nouvelle classe à partir d'une classe préexistante, la nouvelle classe héritera des méthodes de la classe préexistante. La nouvelle classe dans ce scénario est appelée "classe enfant", tandis que la classe préexistante est appelée "classe parent".

Voici un exemple d'une classe parent et d'une classe enfant qui en est dérivée. Notez que la classe parent établit la méthode type, de sorte que la classe enfant hérite de cette méthode. La méthode est cependant redéfinie dans la classe enfant, de sorte que les objets instanciés à partir de la classe enfant utilisent la méthode redéfinie. C'est ce qu'on appelle le " remplacement de méthode ".

# Define parent class Animal
class Animal:
# Define method
    def type(self):
        print("animal")
# Define child class Dog    
class Dog (Animal):
    def type(self):
        print("dog")

# Initialize objects
obj_bear = Animal()
obj_terrier = Dog()
obj_bear.type()
# returns animal
obj_terrier.type()
# returns dog

Un principe similaire s'applique aux classes qui sont indépendantes les unes des autres. Par exemple, imaginez que vous créez deux nouvelles classes : Lionet Giraffe.

class Lion:
    def diet(self):
        print(“carnivore”)
class Giraffe:
    def diet(self):
        print(“herbivore”)
obj_lion=Lion()
obj_giraffe=Giraffe()

obj_lion.diet()
# returns carnivore
obj_giraffe.diet()
# returns herbivore

Tutoriel sur le polymorphisme Python

La meilleure façon d'apprendre une nouvelle compétence de codage est de la pratiquer réellement . Essayez d'exécuter le code dans les exemples ci-dessous pour voir le polymorphisme en action !
Tout d'abord, pratiquons le polymorphisme des opérateurs. Nous utiliserons l' +opérateur pour additionner les entiers 2et 3tout en concaténant les chaînes “2”et “3”.

int1 = 2
int2 = 3
print(int1+int2)
str1 = "2"
str2 = "3"
print(str1+str2)

---> 5
    23

str1="numbers"
print(len(str1))
list1=["1","2","3","4"]
print(len(list1))

---> 7
     4

class Fish:
       def type(self):
             print("fish")
class Shark(Fish):
    def type(self):
          print("shark")
obj_goldfish=Fish()
obj_hammerhead=Shark()
obj_goldfish.type()
obj_hammerhead.type()

---> fish
     shark

class Turtle:
    def type(self):
        print("turtle")class Frog:
    def type(self):
        print("frog")
obj_sea_turtle=Turtle()
obj_treefrog=Frog()
obj_sea_turtle.type()
obj_treefrog.type()
---> turtle
     frog

Le polymorphisme est un élément important de la programmation orientée objet en Python. Le polymorphisme fait de Python un langage plus polyvalent et efficace. Il vous permet d'utiliser un seul opérateur ou une seule fonction pour effectuer plusieurs tâches. Il vous permet également de réutiliser les noms de méthodes tout en les redéfinissant pour les besoins uniques de différentes classes.

J'aimerais entendre vos réflexions à ce sujet, alors n'hésitez pas à me contacter dans les commentaires ci-dessous !

— Si cet article vous a aidé de quelque manière que ce soit, pensez à le partager avec 2 amis qui vous sont chers.

Jusque-là, restez en vie.

MERCI