Héritage python

Introduction

L'héritage est encore un autre concept clé dans la programmation orientée objet, et il joue un rôle essentiel dans la construction de cours. Il permet à un cours d'être basé sur un existant.

Lorsque vous avez commencé à écrire des classes Python, on vous a dit de simplement mettre «un objet» dans la parenthèse de la définition de la classe et de ne pas trop y penser. Eh bien, c'est le moment de commencer à y penser.

«Objet» est en fait la classe de base dont toutes les classes Python héritent de. Il définit un ensemble de fonctionnalité de base que toutes les classes Python devraient avoir. En héritant de celui-ci lorsque vous créez une nouvelle classe, vous vous assurez que cette classe a cette fonctionnalité de base.

Bref, l'héritage est une belle façon de catégoriser les cours et de vous assurer que vous ne vous répétez pas inutilement.

Qu'est-ce que l'héritage?

L'héritage existe également dans le monde réel. Les deux premiers guides ont utilisé une voiture comme exemple d'une classe. Eh bien, et si vous voulez des types de voitures plus spécifiques qui partagent tous ces principes de base d'une voiture? L'héritage peut aider.

Vous pouvez commencer par une classe de base «voiture» qui possède toutes les propriétés que chaque voiture partage. Tout serait très général.

Après avoir votre «voiture», vous pouvez créer de nouvelles classes et leur passer «voiture.«Ils auront tous les mêmes propriétés que la classe de« voiture »de base. Ensuite, vous pouvez ajouter toutes les propriétés supplémentaires que vous souhaitez à ces classes plus spécialisées. Par exemple, vous pouvez avoir des cours «Truck», «Muscle Car» et «SUV» qui héritent tous de «voiture."

Lorsque vous y réfléchissez en termes réels, les camions, les voitures musculaires et les VUS ont tous les mêmes propriétés de base que n'importe quelle autre voiture, mais ils ont aussi des propriétés spécialisées.

Vous pouvez également vous spécialiser. Il y a des tonnes de différents types de camions. Ainsi, vous pouvez créer des cours plus spécialisés qui héritent de «Truck."Le testament commence tous avec tout ce qui forme" voiture "et tout de" Truck."

Utilisation de l'héritage dans Python

Très bien, alors maintenant vous pouvez l'essayer avec un vrai code. Configurez une classe de base «voiture» qui hérite de «Objet."Essayez de travailler avec l'exemple ci-dessous.

Class Car (Object): Def __init __ (self, Make = 'Ford', Model = 'Pinto', Year = '1971', kilométrage = 253812, Color = 'Orange'): Self.__Make = se faire auto.__Model = Modèle de soi.__ ans = an.__mileage = self de kilométrage.__Color = Color Def Move_Forward (self, Speed): Print ("Votre% S va de l'avant à% S"% (Self.__Model, Speed)) def move_backward (self, Speed): Imprimer ("se déplaçant en arrière à% s"% vitesse) Class Musclear (voiture): __hp = 300 def set_hp (self, hp): self.__hp = hp def get_hp (self): return soi.__hp def drag_race (self, adversaire): if (self.__hp> adversaire.get_hp ()): Renvoyez "vous gagnez!"Sinon: retour" tu perds!"MyNewCar = MuscleCar ('Ford', 'Mustang', '2016', 3000, 'Red') MyNewCar.set_hp (687) adversaire = musclecar ('Ford', 'Mustang', '2014', 6400, 'Green') adversaire.set_hp (465) MyNewCar.MOVE_FORWARD ('25MPH') Impression (MyNewCar.drag_race (adversaire)) 

Notez que le Musclar Les objets ont pu utiliser le constructeur et le Avance La méthode de la classe «voiture» même si la classe dont ils ont été instanciés ne les ont pas explicitement.

Primordial

Juste parce qu'une classe hérite d'un autre, vous n'êtes pas coincé avec toutes les fonctionnalités de la classe parentale. Vous pouvez écraser des parties de la classe parent dans les classes enfants. Les modifications appliquées à la classe d'enfants ne s'appliqueront pas à la classe parentale d'origine, vous n'avez donc pas à vous soucier de gâcher d'autres classes.

Dans l'exemple ci-dessus, la «Musclecar» venait d'avoir une variable, __hp Je fais juste flotter là-bas sans aucun moyen de le régler sur l'instanciation. Découvrez le même exemple, mais avec le constructeur remplacé.

Class Car (Object): Def __init __ (self, Make = 'Ford', Model = 'Pinto', Year = '1971', kilométrage = 253812, Color = 'Orange'): Self.__Make = se faire auto.__Model = Modèle de soi.__ ans = an.__mileage = self de kilométrage.__Color = Color Def Move_Forward (self, Speed): Print ("Votre% S va de l'avant à% S"% (Self.__Model, Speed)) def move_backward (self, Speed): Imprimer ("se déplaçant en arrière à% s"% Speed) Class Musclear (Car): Def __init __ (self, make = 'Ford', modèle = 'Mustang', année = '1965', kilométrage = 54032, color = 'bleu', hp = 325): soi.__Make = se faire auto.__Model = Modèle de soi.__ ans = an.__mileage = self de kilométrage.__color = Couleur soi.__hp = hp def set_hp (self, hp): self.__hp = hp def get_hp (self): return soi.__hp def drag_race (self, adversaire): if (self.__hp> adversaire.get_hp ()): Renvoyez "vous gagnez!"Sinon: retour" tu perds!"MyNewCar = MuscleCar ('Ford', 'Mustang', '2016', 3000, 'Red', 687) Adversation = MuscLecar () MyNewCar.MOVE_FORWARD ('25MPH') Impression (MyNewCar.drag_race (adversaire)) 

Il y a deux choses à remarquer. D'abord, __hp est devenu soi.__hp et est incorporé dans le constructeur. Pour cette raison, le définir est beaucoup plus facile. Deuxièmement, les valeurs par défaut pour une nouvelle «Musclecar» ont été modifiées. Une pinto n'est pas une très bonne voiture de muscle par défaut, est-ce?

Vous pouvez le faire avec n'importe quelle variable ou méthode dans une sous-classe ou une classe enfant. Il ajoute un degré de flexibilité supplémentaire et vous empêche d'être enfermé dans la fonctionnalité du parent ou de la super classe.

La super méthode

Parfois, vous devez accéder aux méthodes trouvées dans la classe parentale depuis la classe enfant. Prenez l'exemple précédent qui remplace ce constructeur. Une grande partie de ce code est redondante. En utilisant super() Pour appeler le constructeur de la classe «voiture» élimine cette redondance et permet une classe plus rationalisée.

super() Peut également être utilisé pour accéder à des méthodes régulières à utiliser dans les méthodes de sous-classe. L'exemple ci-dessous super() dans les deux sens.

Class Car (Object): Def __init __ (self, Make = 'Ford', Model = 'Pinto', Year = '1971', kilométrage = 253812, Color = 'Orange'): Self.__Make = se faire auto.__Model = Modèle de soi.__ ans = an.__mileage = self de kilométrage.__Color = couleur def set_make (self, make): self.__Make = Make def get_make (self): renvoie soi-même.__make def set_model (self, modèle): soi.__Model = modèle def get_model (self): renvoyer.__Model def set_year (self, année): soi.__year = an def get_year (self): return self.__ ans def set_mileage (self, kilométrage): soi.__mileage = kilométrage def get_mileage (self): renvoyer soi-même.__mileage def set_color (self, couleur): soi.__Color = couleur def get_color (self): retourne.__color def move_forward (self, vitesse): imprimer ("Votre% s va de l'avant à% s"% (self.__Model, Speed)) def move_backward (self, Speed): Imprimer ("se déplaçant en arrière à% s"% Speed) Class Musclear (Car): Def __init __ (self, make = 'Ford', modèle = 'Mustang', année = '1965', kilométrage = 54032, color = 'bleu', hp = 325): super ().__INIT __ (Make, modèle, année, kilométrage, couleur) Self.__hp = hp def set_hp (self, hp): self.__hp = hp def get_hp (self): return soi.__hp def drag_race (self, adversaire): if (self.__hp> adversaire.get_hp ()): Renvoyez "vous gagnez!"Sinon: retour" tu perds!"Def Trade_up (self, année, couleur): super ().set_year (année) super ().set_color (couleur) super ().set_mileage (0) myNewCar = MuscLecar ('Ford', 'Mustang', '2016', 3000, 'Red', 687) Adversation = MuscLecar () MyNewCar.MOVE_FORWARD ('25MPH') Impression (MyNewCar.drag_race (adversaire)) MyNewCar.Trade_up ('2017', 'Black') imprimer ("My New% S Muscle Car est% s et a% d miles"% (MyNewCar.get_year (), myNewCar.get_color (), myNewCar.get_mileage ())) 

Regardez la façon dont le Trade_up La méthode utilise super() Pour accéder et appeler ces méthodes de setter à partir de la classe parentale.

Réflexions de clôture

L'héritage vous permet d'utiliser des classes comme modèles pour des classes plus spécialisées. Vous pouvez construire des cours dans une telle structure que le début à ressembler à un arbre généalogique, avec les membres «plus âgés» et plus généraux transmettant des traits aux membres «plus jeunes» plus spécialisés.

Une grande partie de la programmation orientée objet réduit la quantité de code écrite et empêche le plus de code que possible d'être réécrit. L'héritage sert un grand rôle dans la rendez-vous possible.

Des exercices

1. Créer une classe de base qui hérite de la classe «voiture».
2. Instanciez votre nouvelle classe et appelez l'une des méthodes de «voiture."
3. Créez de nouvelles méthodes dans votre classe d'enfants.
4. Appelez votre nouvelle méthode.
5. Utiliser super() Pour ajouter des variables au constructeur de votre classe d'enfants.
6. Créer une méthode en utilisant super() Pour accéder aux méthodes de la classe parentale.
7. Appelez votre nouvelle méthode qui utilise super().

Tutoriels Linux connexes:

• Choses à installer sur Ubuntu 20.04
• Choses à faire après l'installation d'Ubuntu 20.04 Focal Fossa Linux
• Choses à installer sur Ubuntu 22.04
• Une introduction à l'automatisation Linux, des outils et des techniques
• Ubuntu 20.04 astuces et choses que vous ne savez peut-être pas
• Ubuntu 20.04 Guide
• Choses à faire après l'installation d'Ubuntu 22.04 Jammy Jellyfish…
• Comment doubler Kali Linux et Windows 10
• Comment créer une application Tkinter à l'aide d'un objet orienté…
• Mint 20: Mieux que Ubuntu et Microsoft Windows?