Polymorphisme Python

Introduction

Le polymorphisme est encore un autre aspect important de la programmation orientée objet. Pas de fans de Warcraft, cela n’a rien à voir avec le fait de transformer les gens en moutons. Ce serait beaucoup plus cool. Au lieu de cela, le polymorphisme permet aux méthodes et aux fonctions d’utiliser des classes ayant des fonctionnalités similaires de la même manière.

Le polymorphisme réduit la quantité de code que vous devez écrire en éliminant la redondance de manière logique et significative. Il compte sur vous, le programmeur, pour être intelligent dans votre conception et exploiter les similitudes entre les objets.

Qu’est-ce que le polymorphisme ?

Le polymorphisme est l’une de ces choses qu’il est difficile de définir en un seul mot ou une seule phrase. Le terme prend des formes légèrement différentes dans différents langages de programmation, ce qui le rend un peu plus difficile à cerner de manière concise. D’une manière générale, et en Python, c’est la capacité de plusieurs objets différents dérivés de différentes classes à être utilisés de la même manière.

Pour reprendre l’exemple des voitures avec lesquelles ce guide a travaillé, imaginez que vous deviez écrire une fonction qui appelle la méthode move_forward sur n’importe quel type de voiture qu’elle a transmise. Chaque objet créé à partir de la classe « Car » d’origine ou de l’une des sous-classes qui l’étendent doit avoir une méthode move_forward, même si elle a été remplacée pour faire quelque chose de légèrement différent dans certaines des sous-classes. Cela signifie que grâce au polymorphisme, vous pouvez écrire une seule fonction qui prend un objet « Car » et l’appelle move_forward. Étant donné que tous les objets instanciés à partir des sous-classes de « Car » sont toujours techniquement des objets « Car » et ont toutes leurs propriétés d’origine sous une forme ou une autre, cela fonctionnera.

Veuillez noter que la spécification d’une seule superclasse à utiliser comme type d’objet n’est pas entièrement nécessaire en Python. Python n’est pas fortement typé, vous n’avez donc pas besoin de définir explicitement les types de variables qu’une méthode ou une fonction prend. Dans des langages comme Java, cela joue un rôle dans le comportement du polymorphisme. Cependant, en Python, c’est une bonne idée d’y penser de cette manière pour s’assurer que les objets que vous passez auront tous la méthode ou la propriété utilisée.

L’utiliser en Python

Maintenant, il serait vraiment utile de voir tout cela en action. Ce n’est pas aussi complexe que vous le pensez probablement en ce moment. Tout d’abord, assurez-vous que vous êtes configuré avec les exemples de classes. Si vous ne les avez pas déjà, ils se trouvent juste en dessous.


class Car(object):
    def __init__(self, make = 'Ford', model = 'Pinto', year = '1971', mileage = 253812, color = 'orange'):
        self.__make = make
        self.__model = model
        self.__year = year
        self.__mileage = mileage
        self.__color = color

    def set_make(self, make):
        self.__make = make

    def get_make(self):
        return self.__make

    def set_model(self, model):
        self.__model = model

    def get_model(self):
        return self.__model

    def set_year(self, year):
        self.__year = year

    def get_year(self):
        return self.__year

    def set_mileage(self, mileage):
        self.__mileage = mileage

    def get_mileage(self):
        return self.__mileage

    def set_color(self, color):
        self.__color = color
	def get_color(self):
        return self.__color

    def move_forward(self, speed):
        print("Your %s is moving forward at %s" % (self.__model, speed))

    def move_backward(self, speed):
        print("Moving backward at %s" % speed)


class MuscleCar(Car):
    def __init__(self, make = 'Ford', model = 'Mustang', year = '1965', mileage = 54032, color = 'blue', hp = 325):
		super().__init__(make, model, year, mileage, color)
        self.__hp = hp

    def set_hp(self, hp):
        self.__hp = hp

    def get_hp(self):
        return self.__hp

    def drag_race(self, opponent):
        if (self.__hp > opponent.get_hp()):
            return "You Win!"
        else:
            return "You Lose!"

    def trade_up(self, year, color):
        super().set_year(year)
        super().set_color(color)
        super().set_mileage(0)

Une fois les classes de démonstration configurées, vous pouvez tester une fonction rapide qui utilise le polymorphisme pour appeler move_forward.


newmusclecar = MuscleCar()
newcar = Car()

def go_25(car_object):
	car_object.move_forward("25mph")

go_25(newcar)
go_25(newmusclecar)

Les deux appels de fonction se comportent exactement de la même manière, même s’ils ont reçu des objets différents qui ont été créés à partir de classes différentes. Grâce au polymorphisme, vous n’avez pas besoin d’écrire deux fonctions différentes et vous pouvez utiliser les propriétés similaires des objets pour écrire une seule fonction.

Essayez de remplacer l’une des méthodes move_forward dans la classe « MuscleCar ». Exécutez à nouveau la fonction et voyez ce qui se passe.



class MuscleCar(Car):
	…

	def move_forward(self, speed):
        print("Your awesome %s is roaring down the road  at %s" % (self.__model, speed))

	…

Lorsque la fonction appelle la méthode move_forward sur l’objet muscle car, elle fonctionne toujours parfaitement et la version remplacée de la méthode est utilisée.

Réflexions finales

Le polymorphisme semble être un concept terriblement complexe, mais son nom est quelque peu erroné. Le concept lui-même n’est pas si intimidant, et il aide même à simplifier la structure globale de votre code.

Un thème commun à la programmation orientée objet est l’élimination de la redondance grâce au code réutilisable et adaptable. Le polymorphisme est une partie importante de ce tableau.

Exercices