Recherche de site Web

Comment appeler une méthode de classe Parent en Python ?

Dans la programmation orientée objet, l'héritage vous permet de créer de nouvelles classes basées sur celles existantes, offrant ainsi un moyen de réutiliser le code et d'organiser la structure de votre programme. Python, étant un langage orienté objet, prend en charge l'héritage et vous permet de remplacer les méthodes définies dans les classes parents dans les classes enfants. Cependant, il peut arriver que vous souhaitiez exploiter les fonctionnalités d'une méthode de classe parent tout en l'étendant ou en la modifiant dans la classe enfant.

Remplacement de méthode en Python

Avant d'en apprendre davantage sur l'appel des méthodes de classe parent, discutons brièvement du remplacement de méthode. La substitution de méthode est une fonctionnalité de la programmation orientée objet qui permet à une sous-classe de fournir une implémentation différente d'une méthode déjà définie dans sa classe parent. Lorsque vous remplacez une méthode, vous la redéfinissez dans la sous-classe portant le même nom que dans la classe parent.

Pour illustrer le remplacement de méthode en Python, considérons l'exemple suivant -

class ParentClass:
   def my_method(self):
      print("This is the parent class method.")

class ChildClass(ParentClass):
   def my_method(self):
      print("This is the child class method.")

Dans l'extrait de code ci-dessus, nous avons une ParentClass avec une méthode appelée my_method(). La ChildClass hérite de ParentClass et définit également sa propre my_method().

Lorsque vous créez des instances de ces classes et appelez my_method() dessus, Python utilise l'implémentation définie dans les classes respectives − 

parent = ParentClass()
child = ChildClass()

parent.my_method()  # Output: "This is the parent class method."
child.my_method()  # Output: "This is the child class method."

Comme vous pouvez le voir, appeler my_method() sur une instance de ParentClass invoque l'implémentation de la classe parent, tandis que l'appeler sur une instance de ChildClass invoque la méthode remplacée dans la classe enfant.

Appel de la méthode de classe parent

En Python, vous pouvez appeler la méthode de la classe parent à partir de la méthode remplacée à l'aide de la fonction super(). La fonction super() renvoie un objet temporaire de la classe parent, vous permettant d'accéder à ses méthodes.

La syntaxe générale pour appeler une méthode de classe parent à l'aide de super() est la suivante −

class ChildClass(ParentClass):
   def overridden_method(self):
      super().method_name(arguments)
      # Additional code in the child class method

Voici un exemple qui montre comment appeler la méthode de classe parent en utilisant super() -

class ParentClass:
   def my_method(self):
      print("This is the parent class method.")

class ChildClass(ParentClass):
   def my_method(self):
      super().my_method()  # Calling the parent class method
      print("This is the child class method.")

Dans l'exemple ci-dessus, ChildClass remplace my_method() défini dans ParentClass. Dans la méthode remplacée de la classe enfant, nous utilisons super().my_method() pour appeler la méthode de la classe parent. Cela garantit que la méthode de la classe parent est exécutée avant le code supplémentaire dans la méthode de la classe enfant.

Lorsque vous créez une instance de ChildClass et appelez my_method(), la méthode de la classe parent et la méthode de la classe enfant seront invoquées −

child = ChildClass()
child.my_method()

# Output:
# "This is the parent class method."
# "This is the child class method."

Comme vous pouvez le voir, l'appel super().my_method() dans la méthode de classe enfant appelle d'abord la méthode de classe parent, suivi de l'exécution de la méthode de classe enfant.

En appelant la méthode de classe parent à l’aide de super(), vous pouvez efficacement étendre ou modifier le comportement de la méthode de classe parent tout en conservant sa fonctionnalité d’origine. Cette approche est particulièrement utile lorsque vous souhaitez ajouter un traitement supplémentaire ou personnaliser certains aspects de la méthode de la classe parent.

Avantages de l'utilisation de super() pour appeler les méthodes de classe parent

L'utilisation de la fonction super() pour appeler des méthodes de classe parent offre plusieurs avantages dans le contexte de la programmation orientée objet. Explorons certains de ces avantages −

Réutilisabilité du code

En appelant la méthode de la classe parent à l'aide de super(), vous pouvez réutiliser la fonctionnalité existante implémentée dans la classe parent. Cela favorise la réutilisabilité du code et réduit la duplication. Au lieu de réécrire toute la logique de la méthode de la classe parent dans la classe enfant, vous pouvez exploiter l’implémentation de la classe parent et la développer.

Maintenir la cohérence du code

L’appel de la méthode de classe parent à l’aide de super() permet de maintenir la cohérence et la consistance du code. Cela garantit que le comportement principal défini dans la méthode de la classe parent est préservé, même si la classe enfant le remplace. Ceci est particulièrement important lorsque vous travaillez avec des bases de code ou des équipes volumineuses, car cela permet aux développeurs de comprendre et de prédire le comportement des méthodes héritées dans la hiérarchie des classes.

Extensibilité et personnalisation

La fonction super() fournit un moyen d'étendre ou de personnaliser le comportement de la méthode de classe parent. En appelant d'abord la méthode de classe parent à l'aide de super(), vous pouvez effectuer tout prétraitement ou opération supplémentaire nécessaire avant ou après l'appel de la méthode de classe parent. Cela vous permet de vous appuyer sur les fonctionnalités existantes et de les adapter aux exigences spécifiques de la classe enfant.

S'adapter aux changements futurs

L'utilisation de super() pour appeler les méthodes de la classe parent permet une adaptabilité aux modifications futures de la base de code. Si l'implémentation de la méthode de la classe parent est mise à jour ou modifiée, les modifications se propagent automatiquement à la classe enfant via l'appel super(). Cela garantit que la classe enfant continue de bénéficier des améliorations ou des corrections de bogues apportées à la méthode de la classe parent sans nécessiter de mises à jour explicites dans la classe enfant.

Exemples pratiques

Explorons quelques exemples pratiques pour mieux comprendre comment appeler des méthodes de classe parent à l'aide de super().

Exemple

class Vehicle:
   def start(self):
      print("Vehicle started.")

class Car(Vehicle):
   def start(self):
      super().start()  # Call the parent class method
      print("Car started.")

car = Car()
car.start()

Sortir

Vehicle started.
Car started.

Dans cet exemple, la classe Car remplace la méthode start() définie dans la classe Vehicle. En appelant super().start(), la méthode de la classe parent est invoquée en premier, affichant « Véhicule démarré ». Ensuite, la classe enfant ajoute sa propre fonctionnalité en affichant « Voiture démarrée ».

Exemple

class Shape:
   def __init__(self, color):
      self.color = color

   def draw(self):
      print(f"Drawing a shape with color: {self.color}")

class Circle(Shape):
   def __init__(self, color, radius):
      super().__init__(color)
      self.radius = radius

   def draw(self):
      super().draw()  # Call the parent class method
      print(f"Drawing a circle with radius: {self.radius}")

circle = Circle("Red", 5)
circle.draw()

Sortir

Drawing a shape with color: Red
Drawing a circle with radius: 5

Dans cet exemple, la classe Circle hérite de la classe Shape et remplace la méthode draw(). En appelant super().draw(), la méthode de la classe parent est appelée en premier, affichant « Dessiner une forme avec la couleur : Rouge ». Ensuite, la classe enfant ajoute sa propre fonctionnalité en imprimant « Dessiner un cercle de rayon : 5 ».

Ces exemples montrent comment super() peut être utilisé pour appeler des méthodes de classe parent et étendre leurs fonctionnalités dans les classes enfants.

Conclusion

Ici, nous avons exploré comment appeler une méthode de classe parent en Python. Nous avons discuté du remplacement de méthode et de la façon dont vous pouvez utiliser la fonction super() pour appeler la méthode de la classe parent à partir de la classe enfant. Cette technique permet d'étendre ou de modifier les fonctionnalités de la méthode de la classe parent tout en conservant son comportement d'origine.

Articles connexes: