Dans cet article, nous allons explorer les concepts de classes et de polymorphisme en Python. Nous verrons comment créer des classes, comment hériter et comment utiliser le polymorphisme grâce au typage duck et à la fonction isinstance.

Les classes

Une classe est un modèle de code permettant de créer des objets. Les objets ont des variables et des méthodes, qui sont des fonctions pouvant être appelées sur l'objet. En Python, vous pouvez définir une classe en utilisant le mot-clé class, suivi du nom de la classe et de deux points :

class Animal:
    pass

Vous pouvez définir des méthodes dans une classe en créant des fonctions dans la définition de la classe. Voici un exemple de classe avec une méthode :

class Animal:
    def speak(self):
        print("The animal makes a sound")

Héritage

L'héritage est un moyen de créer une nouvelle classe qui est une version modifiée d'une classe existante. La nouvelle classe est appelée classe dérivée (ou enfant) et la classe existante est la classe de base (ou parent). En Python, vous pouvez créer une classe dérivée en spécifiant la classe de base entre parenthèses après le nom de la classe dérivée :

class Dog(Animal):
    pass

Dans cet exemple, la classe Chien hérite de la classe Animal. Cela signifie que la classe Chien a accès à la méthode speak() définie dans la classe Animal :

my_dog = Dog()
my_dog.speak()  # Output: The animal makes a sound

Polymorphisme

Le polymorphisme est un concept de programmation qui permet de traiter des objets de classes différentes comme s'ils étaient des objets de la même classe. En Python, le polymorphisme peut être réalisé en utilisant le typage duck et la fonction isinstance.

Duck Typing

Le duck typing est un concept de programmation dans lequel le type d'un objet est déterminé par son comportement (méthodes et propriétés), plutôt que par sa classe. En Python, vous pouvez utiliser le duck typing pour obtenir du polymorphisme en définissant des méthodes portant le même nom dans différentes classes et en appelant ces méthodes sans vérifier le type de l'objet (stackoverflow.com) :

class Wolf:
    def bark(self):
        print("hooooowll")

class Dog:
    def bark(self):
        print("woof")

def bark_for_me(animal):
    animal.bark()

my_dog = Dog()
my_wolf = Wolf()
bark_for_me(my_dog)  # Output: woof
bark_for_me(my_wolf)  # Output: hooooowll

Vérifier l'appartenance

La fonction isinstance peut être utilisée pour vérifier si un objet est une instance d'une classe spécifique ou d'une sous-classe de celle-ci. Cela peut être utile dans les cas où vous devez vous assurer qu'un objet est d'un certain type avant d'appeler une méthode (stackoverflow.com) :

class Animal:
    pass

class Dog(Animal):
    pass

my_dog = Dog()
print(isinstance(my_dog, Dog))  # Output: True
print(isinstance(my_dog, Animal))  # Output: True

Cependant, il est intéressant de noter que le langage Python idiomatique évite généralement d'utiliser isinstance pour la vérification des types, car il est plus courant de s'appuyer sur le typage des canards pour obtenir un comportement polymorphe.

Conclusion

Dans cet article, nous avons exploré les concepts de classes, d'héritage et de polymorphisme en Python. La compréhension de ces concepts vous aidera à créer un code plus flexible et réutilisable, vous permettant de tirer parti de la puissance de la programmation orientée objet dans vos projets Python !

Allez plus loin :