Héritage python

Le Python est un langage de programmation orienté objet. Dans un langage de programmation orienté objet, nous créons les classes et effectuons la fonctionnalité prévue. L'héritage est la caractéristique fondamentale des langages de programmation orientés objet. L'héritage peut être défini comme la capacité d'une classe à hériter de toutes les fonctions et propriétés d'une autre classe. L'héritage permet essentiellement d'étendre les propriétés d'une classe existante. L'héritage est exploité avec les deux concepts principaux:

1. Classe parent ou classe de base
2. Classe d'enfants ou classe dérivée

La classe parent est la classe qui permet à d'autres classes d'être héritées de. Il est aussi appelé la classe de base. La classe enfant ou la classe dérivée est cette classe qui hérite de toutes les propriétés et fonctions d'une autre classe. L'héritage favorise plusieurs avantages, je.e., C'est la représentation du phénomène de l'héritage du monde réel. Il encourage la réutilisabilité du code. Si une fonction est définie dans une classe, l'autre classe peut hériter de cette classe et utiliser toutes les fonctions existantes. Il n'est pas nécessaire d'écrire le même code encore et encore pour effectuer des tâches similaires. L'héritage est appliqué à plusieurs niveaux. Par exemple, si la classe B est héritée de A et la classe C est héritée de la classe B, alors la classe C possède toutes les propriétés de la classe B ainsi que de la classe A. La syntaxe de l'héritage est la suivante:

Classe parentClass:
Détails d'implémentation de la classe parent
classe d'enfants de classe:
Détails d'implémentation de la classe infantile

Bien que la classe enfant ait accès à toutes les fonctionnalités et fonctions de la classe parent, cependant, il peut également ajouter ses nouvelles fonctionnalités et fonctions.

Cet article décrit et couvre tous les aspects de l'héritage de Python.

Implémentation de l'héritage dans Python

L'héritage peut être appliqué dans de nombreuses situations. Supposons que vous construisez un système logiciel pour une université. Il peut être composé de plusieurs parties prenantes comme les étudiants, les enseignants, le personnel, etc. Ainsi, chaque personne a un nom, un âge, un e-mail et d'autres propriétés communes. Il n'est pas nécessaire de déclarer toutes les propriétés de chaque classe séparément. Nous pouvons faire une classe de personne, et toutes les classes des parties prenantes peuvent hériter de toutes les propriétés et fonctions communes de la classe de personne. Dans ce cas, il n'est pas nécessaire d'écrire les propriétés communes dans chaque classe encore et encore. De même, nous pouvons envisager une classe animale. Il existe des centaines de types d'animaux dans ce monde. Tous les animaux mangent, dorment et ont aussi certaines espèces. Ce concept peut également être mis en œuvre en utilisant l'héritage.

Considérons l'animal comme une super classe et mettons en œuvre l'héritage. Dans l'exemple ci-dessous, nous avons créé une classe animale. La classe animale est la classe parentale. De plus, nous avons créé le chien et les classes de chats qui héritent des propriétés et des fonctions de la classe animale. Le mot-clé PASS est utilisé dans la classe infantile, lorsque nous n'avons pas à implémenter aucune fonctionnalité étendue dans la classe infantile.

# CRASSE DE PARENTS CRÉATION
Animal de classe:
Fonction d'initialisation
#Inilisation du nom de l'animal et du type d'espèce
def __init __ (self, nom, espion_type):
soi.nom = nom
soi.SPECIE_TYPE = SPECIE_TYPE
# une fonction pour imprimer le nom de l'animal
def printname (self):
Print ("Le nom de l'animal est:", Self.nom)
# une fonction pour imprimer le type d'espèce animale
Def PrintSpecie (self):
Print ("Le type d'espèce est:", soi.SPECIE_TYPE)
# Création de la classe de chiens comme classe d'enfants de classe animale
Chien de classe (animal):
# Aucune extension ou modification
passer
#Now Dog Class a accès à toutes les fonctions et propriétés de la classe animale
#Scréation de l'objet de classe de chien
dogobj = chien ("chien", "carnivore")
dogobj.printName ()
dogobj.PrintSpecie ()
# Création de la classe de chat comme classe d'enfants de classe animale
Chat de classe (animal):
#La fonction d'initialisation de la classe CAT
def __init __ (soi):
#Alling et utilisation de la fonction d'initinération de la classe animale
Animal.__init __ (self, "chat", "mammifère carnivore")
#Now Cat Class a accès à toutes les fonctions et propriétés de la classe animale
#Scréation de l'objet Cat Class
catobj = cat ()
catobj.printName ()
catobj.PrintSpecie ()

Sortir

Le "Animal.__init __ (self, «chat», «mammifère carnivore») » L'appel est la fonction d'initialisation de la classe animale.

La fonction super ()

Le Python fournit une fonction super () intégrée pour hériter de toutes les propriétés et fonctions de la classe parentale. Lorsque nous utilisons la fonction super (), il n'est pas nécessaire de mentionner le nom de la classe parent comme nous l'avons fait dans "Animal.__init __ (self, «chat», «mammifère carnivore») » Mais la fonction super () pointe automatiquement vers la classe parent. Utilisons la super fonction.

# CRASSE DE PARENTS CRÉATION
Animal de classe:
Fonction d'initialisation
#Inilisation du nom de l'animal et du type d'espèce
def __init __ (self, nom, espion_type):
soi.nom = nom
soi.SPECIE_TYPE = SPECIE_TYPE
# une fonction pour imprimer le nom de l'animal
def printname (self):
Print ("Le nom de l'animal est:", Self.nom)
# une fonction pour imprimer le type d'espèce animale
Def PrintSpecie (self):
Print ("Le type d'espèce est:", soi.SPECIE_TYPE)
# Création de la classe de chiens comme classe d'enfants de classe animale
Chien de classe (animal):
Fonction using super ()
def __init __ (self, nom, espion_type):
super().__init __ (nom, espion_type)
#Now Dog Class a accès à toutes les fonctions et propriétés de la classe animale
#Scréation de l'objet de classe de chien
dogobj = chien ("chien", "carnivore")
dogobj.printName ()
dogobj.PrintSpecie ()
# Création de la classe de chat comme classe d'enfants de classe animale
Chat de classe (animal):
#La fonction d'initialisation de la classe CAT
Fonction using super ()
def __init __ (self, nom, espion_type):
super().__init __ (nom, espion_type)
#Now Cat Class a accès à toutes les fonctions et propriétés de la classe animale
#Scréation de l'objet Cat Class
catobj = chat ("chat", "mammifère carnivore")
catobj.printName ()
catobj.PrintSpecie ()

Sortir

Ajoutons maintenant quelques fonctionnalités plus. Chaque classe hérite des propriétés et des fonctions communes de la classe parent, mais la classe infantile peut avoir une classe supplémentaire qui est destinée à cette classe particulière. Créons maintenant des propriétés et des fonctions supplémentaires dans le chien et la classe de chat.

# CRASSE DE PARENTS CRÉATION
Animal de classe:
Fonction d'initialisation
#Inilisation du nom de l'animal et du type d'espèce
def __init __ (self, nom, espion_type):
soi.nom = nom
soi.SPECIE_TYPE = SPECIE_TYPE
# une fonction pour imprimer le nom de l'animal
def printname (self):
Print ("Le nom de l'animal est:", Self.nom)
# une fonction pour imprimer le type d'espèce animale
Def PrintSpecie (self):
Print ("Le type d'espèce est:", soi.SPECIE_TYPE)
# Création de la classe de chiens comme classe d'enfants de classe animale
Chien de classe (animal):
Fonction using super ()
#PET Le nom est une fonctionnalité nouvellement ajoutée
def __init __ (self, nom, espion_type, pet_name):
super().__init __ (nom, espion_type)
soi.Pet_name = Pet_name
#Scréation d'une nouvelle fonction
Def PrintpetName (self):
imprimer ("Le nom de l'animal est:", Self.nom d'animal domestique)
#Now Dog Class a accès à toutes les fonctions et propriétés de la classe animale
#Scréation de l'objet de classe de chien
dogobj = chien ("chien", "carnivore", "max")
dogobj.printName ()
dogobj.PrintSpecie ()
dogobj.PrintpetName ()
# Création de la classe de chat comme classe d'enfants de classe animale
Chat de classe (animal):
#La fonction d'initialisation de la classe CAT
Fonction using super ()
#Adding Food et Pet_Name Properties
def __init __ (self, nom, espion_type, nourriture, pet_name):
super().__init __ (nom, espion_type)
soi.nourriture = nourriture
soi.Pet_name = Pet_name
#New Fonction pour accéder aux informations alimentaires
Def PrintFood (self):
imprimer ("le chat aime:", soi.nourriture)
#NEW Fonction pour le nom de l'animal
Def PrintpetName (self):
imprimer ("Le nom de l'animal est:", Self.nom d'animal domestique)
#Now Cat Class a accès à toutes les fonctions et propriétés de la classe animale
#Scréation de l'objet Cat Class
catobj = chat ("chat", "mammifère carnivore", "biscuit", "marguerite")
catobj.printName ()
catobj.PrintSpecie ()

Sortir

Les fonctions remplacées

La fonction primordiale est le concept important dans l'héritage. Une fonction est appelée une fonction remplacée si le nom de la fonction est le même dans les classes parentaux et enfants, mais l'implémentation ou la fonctionnalité de la fonction est différente dans chaque classe. Voyons l'exemple d'une fonction remplacée dans la classe animale. Dans l'exemple donné ci-dessous, nous avons une fonction de manger dans les classes animales et dans ses classes enfants (chien et chat). Le nom de la fonction est le même dans les classes mais l'implémentation est différente.

# CRASSE DE PARENTS CRÉATION
Animal de classe:
Def mange (soi):
imprimer ("tous les animaux mangent de la nourriture")
# création d'objet
animalobj = animal ()
Fonction de calcul
animal.manger()
# CRASSE DE CHIEN CRÉATION
Chien de classe (animal):
Def mange (soi):
imprimer ("le chien mange de la viande")
# création d'objet
dogobj = dog ()
Fonction de calcul
dogobj.manger()
Chat de classe (animal):
Def mange (soi):
Print ("Le chat mange des biscuits et de la nourriture spéciale")
# création d'objet
catobj = cat ()
Fonction de calcul
catobj.manger()

Sortir

Conclusion

L'héritage est l'un des concepts fondamentaux des langages de programmation orientés objet. En utilisant l'héritage, nous créons les classes d'enfants qui héritent de toutes les fonctions et propriétés de la classe parentale. L'héritage favorise la réutilisation du code. Cet article explique l'héritage de Python avec des exemples.