Vue d'ensemble
- En savoir plus sur l'héritage dans la programmation orientée objet et diverses formes d'héritage
- Comprendre la substitution de méthode et la super fonction () dans le monde de la programmation orientée objet
introduction
L'héritage est l'un des aspects les plus importants de la programmation orientée objet (POO). La clé pour comprendre l'héritage est qu'il permet la réutilisation du code. Au lieu d'écrire le même code, encore et encore, nous pouvons simplement hériter des propriétés d'une classe dans l'autre.
Ce, comment peux-tu imaginer, gagner beaucoup de temps. Et le temps c'est de l'argent en science des données!
La programmation orientée objet concerne les objets du monde réel et l'héritage est un moyen de représenter les relations du monde réel. Voici un exemple: auto, autobus, vélo – ils appartiennent tous à une catégorie plus large appelée Véhicule. Cela signifie qu'ils ont hérité des propriétés des véhicules de classe, c'est-à-dire, tous sont utilisés pour le transport.
Nous pouvons représenter cette relation dans le code à l'aide de l'héritage.
Une autre chose intéressante à propos de l'héritage est qu'il est de nature transitive.. Mais qu'est ce que ça veut dire? Nous verrons en détail plus loin dans cet article. Python prend également en charge divers types d'héritage que je couvrirai en détail dans cet article..
Ceci est le deuxième article de la série d'articles liés à la programmation orientée objet. Lire aussi le premier article:
Table des matières
- Qu'est-ce que l'héritage dans la programmation orientée objet?
- Différentes formes d'héritage en programmation orientée objet
- Héritage unique
- Héritage multiple
- Héritage à plusieurs niveaux
- Héritage hiérarchique
- Héritage hybride
- Remplacement de méthode
- La super fonction ()
Qu'est-ce que l'héritage dans la programmation orientée objet?
L'héritage est la procédure dans laquelle une classe hérite des attributs et des méthodes d'une autre classe. La classe dont les propriétés et les méthodes sont héritées est appelée classe principale. Et la classe qui hérite des propriétés de la classe principale est la classe Child.
La chose intéressante est que, ainsi que les propriétés et les méthodes héritées, une classe enfant peut avoir ses propres propriétés et méthodes.
Vous pouvez utiliser la syntaxe suivante: implémenter l'héritage en Python:
classe parent_class: corps de la classe parent classe classe_enfant( classe_parent): corps de classe enfant
Voyons la mise en oeuvre:
classe Voiture: #parent class def __init__(soi, Nom, kilométrage): self.name = name self.mileage = mileage def description(soi): retour f"Les {nom.de.soi} voiture donne le kilométrage de {auto.kilométrage}km/l" classe BMW(Auto): #classe enfant passe classe Audi(Auto): #classe enfant def audi_desc(soi): revenir "C'est la méthode de description de la classe Audi."
obj1 = BMW("BMW Série 7",39.53)
imprimer(obj1.description())
obj2 = Audi("Audi A8 L",14)
imprimer(obj2.description())
imprimer(obj2.audi_desc())
Production:
Nous avons créé deux classes secondaires, a savoir, « BMW » Oui « Audi », qui ont hérité des méthodes et propriétés de la classe principale « Auto ». Nous n'avons pas fourni de fonctions et de méthodes supplémentaires dans la classe BMW. Alors qu'il existe une méthode supplémentaire au sein de la classe Audi.
Remarquez comment les objets des classes enfants peuvent accéder à la méthode d'instance de description () de la classe principale à l'aide de obj1.description () y obj2.description (). Et la méthode séparée de la classe Audi est également accessible par obj2.audi_desc ().
Nous pouvons vérifier la classe de base ou parent de n'importe quelle classe en utilisant un attribut de classe intégré __bases__
imprimer(BMW.__bases__, Audi.__bases__)
Comment pouvons-nous ici, la classe de base des deux sous-classes est Auto. À présent, Voyons ce qui se passe lorsque __base__ est utilisé avec la classe parent Car:
imprimer( Voiture.__bases__ )
Chaque fois que nous créons une nouvelle classe en Python 3.x, hérite d'une classe de base intégrée appelée Objet. En d'autres termes, class L'objet est la racine de toutes les classes.
Formes d'héritage en programmation orientée objet
En général, il existe cinq formes d'héritage basées sur la participation de la classe parent-enfant.
1. Héritage unique
Il s'agit d'une forme d'héritage où une classe hérite d'une seule classe principale. C'est la forme simple de l'héritage et, donc, aussi connu sous le nom héritage simple.
classe Parent:
def f1(soi):
imprimer("Fonction de la classe mère.")
classe Enfant(Parent):
def f2(soi):
imprimer("Fonction de la classe enfant.")
objet1 = enfant()
objet1.f1()
objet1.f2()
Ici, La classe enfant n'hérite que d'une seule classe parent, donc, c'est un exemple d'héritage simple.
2. Héritage multiple
Un héritage devient des héritages multiples lorsqu'une classe hérite de plusieurs classes principales. La classe enfant après avoir hérité des propriétés de plusieurs classes principales a accès à tous ses objets.
classe Parent_1:
def f1(soi):
imprimer("Fonction de la classe parent_1.")
classe Parent_2:
def f2(soi):
imprimer("Fonction de la classe parent_2.")
classe Parent_3:
def f3(soi):
imprimer("fonction de la classe parent_3.")
classe Enfant(Parent_1, Parent_2, Parent_3):
par défaut f4(soi):
imprimer("Fonction de la classe enfant.")
objet_1 = Enfant()
objet_1.f1()
objet_1.f2()
objet_1.f3()
objet_1.f4()
Ici, nous avons une classe Child qui hérite des propriétés des trois classes parent Parent_1, Parent_2 et Parent_3. Toutes les classes ont des fonctions différentes et toutes les fonctions sont appelées à l'aide de l'objet classe enfant.
Mais supposons qu'une classe enfant hérite de deux classes qui ont la même fonction:
classe Parent_1:
def f1(soi):
imprimer("Fonction de la classe parent_1.")
classe Parent_2:
def f1(soi):
imprimer("Fonction de la classe parent_2.")
classe Enfant(Parent_1, Parent_2):
def f2(soi):
imprimer("Fonction de la classe enfant.")
Ici, Les classes Parent_1 et Parent_2 ont la même fonction f1 (). À présent, quand l'objet de la classe Child appelle f1 (), puisque la classe enfant hérite des deux classes parent, Que pensez-vous qu'il devrait se passer?
obj = Enfant() obj.f1()
Mais, Pourquoi la fonction f1 n'a-t-elle pas été héritée () de la clase Parent_2?
En héritage multiple, la classe enfant recherche d'abord la méthode dans sa propre classe. Si non trouvé, rechercher les classes parentes depth_first et les classer de gauche à droite. Comme il s'agissait d'un exemple simple avec seulement deux classes principales, nous pouvons clairement voir que la classe Parent_1 a été héritée en premier, donc la classe enfant cherchera la méthode dans la classe Parent_1 avant de chercher dans la classe Parent_2.
Mais pour des problèmes d'héritage compliqués, il est difficile d'identifier la commande. Ensuite, la façon réelle de faire cela s'appelle Orden de résolutionLa "résolution" fait référence à la capacité de prendre des décisions fermes et d’atteindre les objectifs fixés.. Dans des contextes personnels et professionnels, Il s’agit de définir des objectifs clairs et d’élaborer un plan d’action pour les atteindre. La résolution est essentielle à la croissance personnelle et à la réussite dans divers domaines de la vie, car cela vous permet de surmonter les obstacles et de rester concentré sur ce qui compte vraiment.... de método (MRO) et Python. Nous pouvons trouver le MRO de n'importe quelle classe en utilisant l'attribut __mro__
Enfant.__mro__
Cela indique que la classe enfant a visité la classe Parent_1 en premier, puis Parent_2, donc la méthode f1 sera appelée () de Parent_1.
Prenons un exemple un peu compliqué en Python:
classe Parent_1: passe classe Parent_2: passe classe Parent_3: passe classe Enfant_1(Parent_1,Parent_2): passe classe Enfant_2(Parent_2,Parent_3): passe classe Enfant_3(Enfant_1, Enfant_2, Parent_3): passe
Ici, la classe Child_1 hérite de deux classes: Parent_1 et Parent_2. La classe Child_2 hérite également de deux classes: Parent_2 et Parent_3. Une autre classe Child_3 hérite de trois classes: Enfant_1, Enfant_2 et Parent_3.
À présent, juste en regardant cet héritage, il est assez difficile de déterminer l'ordre de résolution des méthodes pour la classe Child_3. Voici donc l'utilisation réelle de __mro __-
Nous pouvons voir que d'abord, l'interprète recherche Child_3, puis Child_1 suivi de Parent_1, Enfant_2, Parent_2 et Parent_3 respectivement.
3. Héritage à plusieurs niveaux
Par exemple, une classe_1 est héritée par une classe_2 et cette classe_2 est également héritée par classe_3 et ce processus continue. C'est ce qu'on appelle l'héritage à plusieurs niveaux.. Comprenons avec un exemple:
classe Parent:
def f1(soi):
imprimer("Fonction de la classe mère.")
classe Enfant_1(Parent):
def f2(soi):
imprimer("Fonction de la classe child_1.")
classe Enfant_2(Enfant_1):
def f3(soi):
imprimer("Fonction de la classe child_2.")
obj_1 = Enfant_1()
obj_2 = Enfant_2()
obj_1.f1()
obj_1.f2()
imprimer("m")
obj_2.f1()
obj_2.f2()
obj_2.f3()
Ici, la classe Child_1 hérite de la classe Parent et la classe Child_2 hérite de la classe Child_1. Dans ce Child_1 vous avez accès aux fonctions f1 () oui f2 () tandis que Child_2 a accès aux fonctions f1 (), f2 () et f3 (). Si nous essayons d'accéder à la fonction f3 () en utilisant l'objet de classe Class_1, une erreur se produira indiquant:
El objeto ‘Enfant_1’ no tiene atributo ‘f3’
obj_1.f3()
4- Héritage hiérarchique
Dans ce, plusieurs classes enfant héritent d'une seule classe parent. L'exemple donné dans l'introduction de l'héritage est un exemple d'héritage hiérarchique car les classes BMW et Audi héritent de la classe Car.
Pour simplifier, voyons un autre exemple:
classe Parent:
deff1(soi):
imprimer("Fonction de la classe mère.")
classe Enfant_1(Parent):
deff2(soi):
imprimer("Fonction de la classe child_1.")
classe Enfant_2(Parent):
deff3(soi):
imprimer("Fonction de la classe child_2.")
obj_1 = Enfant_1()
obj_2 = Enfant_2()
obj_1.f1()
obj_1.f2()
imprimer('n')
obj_2.f1()
obj_2.f3()
Ici, deux classes enfants héritent de la même classe parent. La classe Child_1 a accès aux fonctions f1 () de la classe Parent et à la fonction f2 () D'elle-même. Alors que la classe Child_2 a accès aux fonctions f1 () de la classe Parent et de la fonction f3 () D'elle-même.
5- Héritage hybride
Lorsqu'il y a une combinaison de plus d'une forme d'héritage, connu sous le nom d'héritage hybride. Ce sera plus clair après cet exemple:
classe Parent:
def f1(soi):
imprimer("Fonction de la classe mère.")
classe Enfant_1(Parent):
def f2(soi):
imprimer("Fonction de la classe child_1.")
classe Enfant_2(Parent):
def f3(soi):
imprimer("Fonction de la classe child_2.")
classe Enfant_3(Enfant_1, Enfant_2):
par défaut f4(soi):
imprimer("Fonction de la classe child_3.")
obj = Enfant_3()
obj.f1()
obj.f2()
obj.f3()
obj.f4()
Dans cet exemple, deux classes ‘Child_1 ′ y’ Enfant_2 ‘se derivan de la clase base’ Parent ‘usando herencia jerárquica. Otra clase ‘Child_3’ se deriva de las clases ‘Enfant_1’ Oui ‘Enfant_2’ utiliser plusieurs héritages. Classe ‘Child_3’ maintenant dérivé par héritage hybride.
Remplacement de méthode
Le concept d'annulation est très important dans l'héritage. Accorde la capacité spéciale à l'enfant / sous-classes pour fournir une implémentation spécifique à une méthode qui est déjà présente dans ses classes parentes.
classe Parent:
def f1(soi):
imprimer("Fonction de la classe Parent.")
classe Enfant(Parent):
def f1(soi):
imprimer("Fonction de la classe enfant.")
obj = Enfant()
obj.f1()
Ici, fonction f1 () de la classe Child a remplacé la fonction f1 () de la clase Parent. Chaque fois que l'objet de la classe Child invoque f1 (), la fonction de la classe Child est exécutée. Cependant, l'objet de classe principale peut invoquer la fonction f1 () de la classe principale.
obj_2 = Parent() obj_2.f1()
La super fonction ()
La super fonction () en Python, il renvoie un objet proxy qui fait référence à la classe parent en utilisant le super Mot-clé. Ce super mot-clé () il est fondamentalement utile pour accéder aux méthodes surchargées de la classe principale.
- Dans une hiérarchie de classes avec héritage unique, super aide à référencer les classes principales sans les nommer explicitement, ce qui rend le code plus facile à maintenir.
Par exemple-
classe Parent: def f1(soi): imprimer("Fonction de la classe Parent.") classe Enfant(Parent): def f1(soi): super().f1() imprimer("Fonction de la classe enfant.") obj = Enfant() obj.f1()
Ici, avec l'aide de super (). F1 (), la méthode f1 a été appelée () superclasse de classe Enfant, c'est-à-dire, la classe Parent sans la nommer explicitement.
Une chose à noter ici est que la super classe () puede aceptar dos paramètresLes "paramètres" sont des variables ou des critères qui sont utilisés pour définir, mesurer ou évaluer un phénomène ou un système. Dans divers domaines tels que les statistiques, Informatique et recherche scientifique, Les paramètres sont essentiels à l’établissement de normes et de standards qui guident l’analyse et l’interprétation des données. Leur sélection et leur manipulation correctes sont cruciales pour obtenir des résultats précis et pertinents dans toute étude ou projet....: le premier est le nom de la sous-classe et le second est un objet qui est une instance de cette sous-classe. Voyons comment
classe Parent: def f1(soi): imprimer("Fonction de la classe Parent.") classe Enfant(Parent): def f1(soi): super( Enfant, soi ).f1() imprimer("Fonction de la classe enfant.") obj = Enfant() obj.f1()Le premier paramètre fait référence à la sous-classe Enfant, tandis que le deuxième paramètre fait référence à l'objet Child qui, dans ce cas, il est soi-même. Vous pouvez voir le résultat après avoir utilisé super () et super (Enfant, soi) est le même parce que, et Python 3, super (Enfant, soi) est équivalent à soi ().
Regardons maintenant un autre exemple utilisant la fonction __init__.
classe Parent(objet): def__init__(soi, Nom du parent): imprimer(Nom du parent, 'is derived from another class.') classe Enfant(Parent): def__init__(soi, Nom de l'enfant): imprimer(Nom,'is a sub-class.') super().__init__(Nom de l'enfant) obj = Enfant('Child')
Ce que nous avons fait ici, c'est que nous appelons la fonction __init__ de la classe Parent (dans la classe Enfant) en utilisant super () .__ initialiser __ (Nom de l'enfant). Et puisque la méthode __init__ de la classe Parent nécessite un argument, c'est arrivé comme « Nom de l'enfant ». Ensuite, après avoir créé l'objet de la classe Child, d'abord la fonction __init__ de la classe Child a été exécutée, puis la fonction __init__ de la classe Parent.
- Le deuxième cas d'utilisation consiste à prendre en charge plusieurs héritages coopératifs dans un environnement d'exécution dynamique.
classe première(): def __init__(soi): imprimer("premier") super().__init__() classe Deuxième(): def __init__(soi): imprimer("seconde") super().__init__() classe troisième(Seconde, D'abord): def __init__(soi): imprimer("troisième") super().__init__() obj = Troisième()
Le super appel () retrouvez la méthode suivante dans le MRO à chaque étape, donc premier et deuxième doivent l'avoir aussi, au contraire, l'exécution s'arrête à la fin de premier () .__ init__.Notez que la première et la deuxième superclasse sont Objet.
Trouvons le MRO de Third () aussi-
Troisième.__mro__
L'ordre est troisième> Seconde> Le premier et le même est l'ordre de notre départ.
Remarques finales
Compléter, Dans cet article j'ai développé le concept d'héritage en programmation orientée objet en Python. J'ai couvert diverses formes d'héritage et certains des concepts communs en matière d'héritage, comme la substitution de méthode et la super fonction ().
J'espère que vous avez compris les concepts expliqués dans cet article. Faites-moi savoir dans les commentaires ci-dessous si vous avez des questions..
