Programmation orientée objet (POO) en Python 3 – Real Python

By | juillet 6, 2020
0 Comment

Formation Python

Programmation orientée objet (POO) est une méthode de structuration d'un programme en regroupant des propriétés et des comportements objets. Dans ce didacticiel, vous apprendrez les bases de la programmation orientée objet en Python.

Conceptuellement, les objets sont comme les composants d'un système. Considérez un programme comme une sorte de chaîne de montage en usine. À chaque étape de la chaîne de montage, un composant du système traite du matériel, transformant finalement la matière première en un produit fini.

Un objet contient des données, comme les matières brutes ou prétraitées à chaque étape d'une chaîne de montage, et un comportement, comme l'action que chaque composant de la chaîne de montage effectue.

Dans ce didacticiel, vous allez apprendre à:

  • Créer un classe, qui est comme un plan pour créer un objet
  • Utilisez des classes pour créer de nouveaux objets
  • Modéliser des systèmes avec héritage de classe

Qu'est-ce que la programmation orientée objet en Python?

La programmation orientée objet est un paradigme de programmation qui fournit un moyen de structurer les programmes de sorte que les propriétés et les comportements soient regroupés en individus objets.

Par exemple, un objet pourrait représenter une personne avec Propriétés comme un nom, un âge, une adresse et comportements comme marcher, parler, respirer et courir. Ou il peut représenter un e-mail avec des propriétés comme une liste de destinataires, un sujet et un corps et des comportements tels que l'ajout de pièces jointes et l'envoi.

Autrement dit, la programmation orientée objet est une approche pour modéliser des choses concrètes et réelles, comme les voitures, ainsi que les relations entre les choses, comme les entreprises et les employés, les étudiants et les enseignants, etc. La POO modélise les entités du monde réel comme des objets logiciels auxquels certaines données sont associées et peuvent exécuter certaines fonctions.

Un autre paradigme de programmation commun est programmation procédurale, qui structure un programme comme une recette en ce qu'il fournit un ensemble d'étapes, sous la forme de fonctions et de blocs de code, qui s'écoulent séquentiellement afin de terminer une tâche.

Le point clé à retenir est que les objets sont au centre de la programmation orientée objet en Python, représentant non seulement les données, comme dans la programmation procédurale, mais aussi dans la structure globale du programme.

Définir une classe en Python

Les structures de données primitives – comme les nombres, les chaînes et les listes – sont conçues pour représenter des éléments d'information simples, tels que le coût d'une pomme, le nom d'un poème ou vos couleurs préférées, respectivement. Et si vous voulez représenter quelque chose de plus complexe?

Par exemple, supposons que vous souhaitiez suivre les employés d'une organisation. Vous devez stocker des informations de base sur chaque employé, telles que son nom, son âge, son poste et l'année où il a commencé à travailler.

Une façon de procéder consiste à représenter chaque employé sous forme de liste:

église = [[[["James Kirk", 34, "Capitaine", 2265]
spock = [[[["Spock", 35, "Officier scientifique", 2254]
mccoy = [[[["Leonard McCoy", "Médecin chef", 2266]

Il y a un certain nombre de problèmes avec cette approche.

Tout d'abord, cela peut rendre les fichiers de code plus volumineux plus difficiles à gérer. Si vous faites référence église[0] plusieurs lignes de là où le église est déclarée, vous souviendrez-vous que l'élément avec index 0 est le nom de l'employé?

Deuxièmement, il peut introduire des erreurs si tous les employés n'ont pas le même nombre d'éléments dans la liste. dans le mccoy liste ci-dessus, l'âge est manquant, donc mccoy[1] reviendra "Médecin chef" au lieu de l'âge du Dr McCoy.

Un excellent moyen de rendre ce type de code plus facile à gérer et à maintenir est d'utiliser Des classes.

Classes vs Instances

Les classes sont utilisées pour créer des structures de données définies par l'utilisateur. Les classes définissent des fonctions appelées les méthodes, qui identifient les comportements et les actions qu'un objet créé à partir de la classe peut effectuer avec ses données.

Dans ce didacticiel, vous allez créer un Chien classe qui stocke des informations sur les caractéristiques et les comportements qu'un chien peut avoir.

Une classe est un modèle de définition d'un élément. Il ne contient en fait aucune donnée. le Chien classe spécifie qu'un nom et un âge sont nécessaires pour définir un chien, mais il ne contient le nom ou l'âge d'aucun chien spécifique.

Alors que la classe est le plan, un exemple est un objet qui est construit à partir d'une classe et contient des données réelles. Une instance de la Chien la classe n'est plus un plan. C'est un vrai chien avec un nom, comme Miles, qui a quatre ans.

Autrement dit, une classe est comme un formulaire ou un questionnaire. Une instance est comme un formulaire rempli d'informations. Tout comme de nombreuses personnes peuvent remplir le même formulaire avec leurs propres informations uniques, de nombreuses instances peuvent être créées à partir d'une seule classe.

Comment définir une classe

Toutes les définitions de classe commencent par le classe mot-clé, qui est suivi du nom de la classe et de deux points. Tout code mis en retrait sous la définition de classe est considéré comme faisant partie du corps de la classe.

Voici un exemple de Chien classe:

Le corps du Chien La classe se compose d'une seule instruction: la classe passer mot-clé. passer est souvent utilisé comme espace réservé indiquant où le code finira par aller. Il vous permet d'exécuter ce code sans que Python ne génère d'erreur.

le Chien La classe n'est pas très intéressante pour le moment, alors revenons un peu en définissant certaines propriétés que tous Chien les objets devraient avoir. Il existe un certain nombre de propriétés parmi lesquelles nous pouvons choisir, notamment le nom, l'âge, la couleur de la robe et la race. Pour simplifier les choses, nous allons simplement utiliser le nom et l'âge.

Les propriétés que tous Chien les objets doivent avoir sont définis dans une méthode appelée .__ init __ (). Chaque fois qu'un nouveau Chien l'objet est créé, .__ init __ () définit l'initiale Etat de l'objet en affectant les valeurs des propriétés de l'objet. C'est, .__ init __ () initialise chaque nouvelle instance de la classe.

Tu peux donner .__ init __ () n'importe quel nombre de paramètres, mais le premier paramètre sera toujours une variable appelée soi. Lorsqu'une nouvelle instance de classe est créée, l'instance est automatiquement transmise au soi paramètre dans .__ init __ () pour que le nouveau les attributs peut être défini sur l'objet.

Mettons à jour le Chien classe avec un .__ init __ () méthode qui crée .Nom et .âge les attributs:

classe Chien:
    def __init__(soi, Nom, âge):
        soi.Nom = Nom
        soi.âge = âge

Notez que le .__ init __ () La signature de la méthode comporte quatre espaces en retrait. Le corps de la méthode est indenté de huit espaces. Cette indentation est d'une importance vitale. Il indique à Python que le .__ init __ () appartient à la méthode Chien classe.

Dans le corps de .__ init __ (), il existe deux déclarations utilisant le soi variable:

  1. self.name = nom crée un attribut appelé Nom et lui attribue la valeur du Nom paramètre.
  2. self.age = age crée un attribut appelé âge et lui attribue la valeur du âge paramètre.

Attributs créés dans .__ init __ () sont appelés attributs d'instance. La valeur d'un attribut d'instance est spécifique à une instance particulière de la classe. Tout Chien les objets ont un nom et un âge, mais les valeurs Nom et âge les attributs varient en fonction de la Chien exemple.

D'autre part, attributs de classe sont des attributs qui ont la même valeur pour toutes les instances de classe. Vous pouvez définir un attribut de classe en affectant une valeur à un nom de variable en dehors de .__ init __ ().

Par exemple, les éléments suivants Chien la classe a un attribut de classe appelé espèce avec la valeur "Canis familiaris":

classe Chien:
    # Attribut de classe
    espèce = "Canis familiaris"

    def __init__(soi, Nom, âge):
        soi.Nom = Nom
        soi.âge = âge

Les attributs de classe sont définis directement sous la première ligne du nom de classe et sont mis en retrait par quatre espaces. Il faut toujours leur attribuer une valeur initiale. Lorsqu'une instance de la classe est créée, les attributs de classe sont automatiquement créés et affectés à leurs valeurs initiales.

Utilisez des attributs de classe pour définir des propriétés qui doivent avoir la même valeur pour chaque instance de classe. Utilisez des attributs d'instance pour les propriétés qui varient d'une instance à l'autre.

Maintenant que nous avons un Chien cours, créons des chiens!

Instancier un objet en Python

Ouvrez la fenêtre interactive d'IDLE et saisissez ce qui suit:

>>>

>>> classe Chien:
...     passer

Cela crée un nouveau Chien classe sans attribut ni méthode.

La création d'un nouvel objet à partir d'une classe est appelée instancier un objet. Vous pouvez instancier une nouvelle Chien en tapant le nom de la classe, suivi de l'ouverture et de la fermeture des parenthèses:

>>>

>>> Chien()
<__main__.Dog object at 0x106702d30>

Vous avez maintenant un nouveau Chien objet à 0x106702d30. Cette drôle de chaîne de lettres et de chiffres est un adresse mémoire qui indique où le Chien l'objet est stocké dans la mémoire de votre ordinateur. Notez que l'adresse que vous voyez sur votre écran sera différente.

Maintenant instanciez une seconde Chien objet:

>>>

>>> Chien()
<__main__.Dog object at 0x0004ccc90>

Le nouveau Chien l'instance se trouve à une adresse mémoire différente. C'est parce que c'est une instance entièrement nouvelle et complètement unique dès le premier Chien objet que vous avez instancié.

Pour voir cela d'une autre manière, tapez ce qui suit:

>>>

>>> une = Chien()
>>> b = Chien()
>>> une == b
Faux

Dans ce code, vous créez deux nouveaux Chien objets et les affecter aux variables une et b. Quand vous comparez une et b en utilisant le == opérateur, le résultat est Faux. Même si une et b sont les deux instances de la Chien classe, ils représentent deux objets distincts en mémoire.

Attributs de classe et d'instance

Maintenant, créez un nouveau Chien classe avec un attribut de classe appelé .espèce et deux attributs d'instance appelés .Nom et .âge:

>>>

>>> classe Chien:
...     espèce = "Canis familiaris"
...     def __init__(soi, Nom, âge):
...         soi.Nom = Nom
...         soi.âge = âge

Pour instancier des objets de cette Chien , vous devez fournir des valeurs pour la classe Nom et âge. Si vous ne le faites pas, alors Python soulève un Erreur-type:

>>>

>>> Chien()
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
    Chien()
Erreur-type: __init __ () manque 2 arguments positionnels requis: 'nom' et 'âge'

Pour passer des arguments au Nom et âge paramètres, mettez des valeurs entre parenthèses après le nom de la classe:

>>>

>>> copain = Chien("Copain", 9)
>>> miles = Chien("Miles", 4)

Cela crée deux nouveaux Chien exemples – un pour un chien de neuf ans nommé Buddy et un pour un chien de quatre ans nommé Miles.

le Chien classe .__ init __ () La méthode a trois paramètres, alors pourquoi ne lui est-on transmis que deux arguments dans l'exemple?

Lorsque vous instanciez un Chien , Python crée une nouvelle instance et la transmet au premier paramètre de .__ init __ (). Cela supprime essentiellement la soi paramètre, vous n'avez donc qu'à vous soucier de la Nom et âge paramètres.

Après avoir créé le Chien instances, vous pouvez accéder à leurs attributs d'instance à l'aide notation par points:

>>>

>>> copain.Nom
'Copain'
>>> copain.âge
9

>>> miles.Nom
«Miles»
>>> miles.âge
4

Vous pouvez accéder aux attributs de classe de la même manière:

>>>

>>> copain.espèce
«Canis familiaris»

L'un des plus grands avantages de l'utilisation des classes pour organiser les données est que les instances sont garanties d'avoir les attributs que vous attendez. Tout Chien les instances ont .espèce, .Nom, et .âge vous pouvez donc utiliser ces attributs en toute confiance en sachant qu'ils renverront toujours une valeur.

Bien que les attributs soient garantis pour exister, leurs valeurs pouvez être changé dynamiquement:

>>>

>>> copain.âge = dix
>>> copain.âge
dix

>>> miles.espèce = "Felis silvestris"
>>> miles.espèce
«Felis silvestris»

Dans cet exemple, vous modifiez le .âge attribut de copain s'opposer à dix. Ensuite, vous modifiez le .espèce attribut de miles s'opposer à "Felis silvestris", qui est une espèce de chat. Cela fait de Miles un chien assez étrange, mais c'est du Python valide!

Le point clé à retenir ici est que les objets personnalisés sont modifiables par défaut. Un objet est modifiable s'il peut être modifié dynamiquement. Par exemple, les listes et les dictionnaires sont mutables, mais les chaînes et les tuples sont immuables.

Méthodes d'instance

Méthodes d'instance sont des fonctions qui sont définies à l'intérieur d'une classe et ne peuvent être appelées qu'à partir d'une instance de cette classe. Juste comme .__ init __ (), le premier paramètre d'une méthode d'instance est toujours soi.

Ouvrez une nouvelle fenêtre d'éditeur dans IDLE et tapez ce qui suit Chien classe:

classe Chien:
    espèce = "Canis familiaris"

    def __init__(soi, Nom, âge):
        soi.Nom = Nom
        soi.âge = âge

    # Méthode d'instance
    def la description(soi):
        revenir F"soi.Nom    est soi.âge    ans"

    # Une autre méthode d'instance
    def parler(soi, du son):
        revenir F"soi.Nom    dit du son"

Ce Chien La classe a deux méthodes d'instance:

  1. .la description() renvoie une chaîne affichant le nom et l'âge du chien.
  2. .parler() a un paramètre appelé du son et renvoie une chaîne contenant le nom du chien et le son qu'il fait.

Enregistrez le modifié Chien classe dans un fichier appelé dog.py et appuyez sur F5 pour exécuter le programme. Ouvrez ensuite la fenêtre interactive et tapez ce qui suit pour voir vos méthodes d'instance en action:

>>>

>>> miles = Chien("Miles", 4)

>>> miles.la description()
«Miles a 4 ans»

>>> miles.parler("Woof Woof")
«Miles dit Woof Woof»

>>> miles.parler("Bow Wow")
«Miles dit Bow Wow»

Au dessus Chien classe, .la description() renvoie une chaîne contenant des informations sur le Chien exemple miles. Lorsque vous écrivez vos propres classes, c'est une bonne idée d'avoir une méthode qui retourne une chaîne contenant des informations utiles sur une instance de la classe. cependant, .la description() n'est pas la façon la plus pythonique de le faire.

Lorsque vous créez un liste objet, vous pouvez utiliser impression() pour afficher une chaîne qui ressemble à la liste:

>>>

>>> des noms = [[[["Fletcher", "David", "Dan"]
>>> impression(des noms)
['Fletcher', 'David', 'Dan']

Voyons ce qui se passe lorsque vous impression() les miles objet:

>>>

>>> impression(miles)
<__main__.Dog object at 0x00aeff70>

Lorsque vous imprimer (miles), vous obtenez un message cryptique vous disant que miles est un Chien objet à l'adresse mémoire 0x00aeff70. Ce message n'est pas très utile. Vous pouvez modifier ce qui est imprimé en définissant une méthode d'instance spéciale appelée .__ str __ ().

Dans la fenêtre de l'éditeur, changez le nom du Chien classe .la description() méthode pour .__ str __ ():

classe Chien:
    # Laisser les autres parties de la classe Dog telles quelles

    # Remplacez .description () par __str __ ()
    def __str__(soi):
        revenir F"soi.Nom    est soi.âge    ans"

Enregistrez le fichier et appuyez sur F5. Maintenant, quand vous imprimer (miles), vous obtenez une sortie beaucoup plus conviviale:

>>>

>>> miles = Chien("Miles", 4)
>>> impression(miles)
«Miles a 4 ans»

Des méthodes comme .__ init __ () et .__ str __ () sont appelés méthodes de dunder car ils commencent et se terminent par des doubles soulignements. Il existe de nombreuses méthodes de dunder que vous pouvez utiliser pour personnaliser les classes en Python. Bien qu'il soit un sujet trop avancé pour un livre Python débutant, la compréhension des méthodes de dunder est une partie importante de la maîtrise de la programmation orientée objet en Python.

Dans la section suivante, vous verrez comment approfondir vos connaissances et créer des classes à partir d'autres classes.

Vérifie ta compréhension

Développez le bloc ci-dessous pour vérifier votre compréhension:

Créer un Voiture classe avec deux attributs d'instance:

  1. .Couleur, qui stocke le nom de la couleur de la voiture sous forme de chaîne
  2. .kilométrage, qui stocke le nombre de miles sur la voiture sous forme d'entier

Puis instanciez deux Voiture objets – une voiture bleue avec 20 000 milles et une voiture rouge avec 30 000 milles – et imprimer leurs couleurs et leur kilométrage. Votre sortie devrait ressembler à ceci:

La voiture bleue a 20 000 milles.
La voiture rouge a 30 000 milles.

Vous pouvez développer le bloc ci-dessous pour voir une solution:

Créez d'abord un Voiture classe avec .Couleur et .kilométrage attributs d'instance:

classe Voiture:
    def __init__(soi, Couleur, kilométrage):
        soi.Couleur = Couleur
        soi.kilométrage = kilométrage

le Couleur et kilométrage paramètres de .__ init __ () sont affectés à self.color et self.mileage, qui crée les deux attributs d'instance.

Vous pouvez maintenant créer les deux Voiture les instances:

voiture bleue = Voiture(Couleur="bleu", kilométrage=20_000)
voiture rouge = Voiture(Couleur="rouge", kilométrage=30_000)

le voiture bleue l'instance est créée en passant la valeur "bleu" à la Couleur paramètre et 20_000 à la kilométrage paramètre. De même, voiture rouge est créé avec les valeurs "rouge" et 30_000.

Pour imprimer la couleur et le kilométrage de chacun Voiture objet, vous pouvez faire une boucle sur un tuple contenant les deux objets:

pour voiture dans (voiture bleue, voiture rouge):
    impression(F"Le voiture.Couleur    la voiture a voiture.kilométrage:,    miles ")

La f-string ci-dessus pour boucle insère le .Couleur et .kilométrage attributs dans la chaîne et utilise le :, spécificateur de format pour imprimer le kilométrage groupé par milliers et séparé par une virgule.

La sortie finale ressemble à ceci:

La voiture bleue a 20 000 milles.
La voiture rouge a 30 000 milles.

Lorsque vous êtes prêt, vous pouvez passer à la section suivante.

Hériter d'autres classes en Python

L'héritage est le processus par lequel une classe prend les attributs et les méthodes d'une autre. Les classes nouvellement formées sont appelées cours pour enfantset les classes dont dérivent les classes enfants sont appelées classes parentales.

Les classes enfants peuvent remplacer ou étendre les attributs et les méthodes des classes parents. En d'autres termes, les classes enfants héritent de tous les attributs et méthodes du parent, mais peuvent également spécifier des attributs et des méthodes qui leur sont propres.

Bien que l'analogie ne soit pas parfaite, vous pouvez penser à l'héritage d'objet comme l'héritage génétique.

Vous avez peut-être hérité de la couleur de vos cheveux de votre mère. C'est un attribut avec lequel vous êtes né. Disons que vous décidez de colorer vos cheveux en violet. En supposant que votre mère n'a pas de cheveux violets, vous venez de remplacé l'attribut de couleur de cheveux que vous avez hérité de votre maman.

Vous héritez également, en un sens, de votre langue de vos parents. Si vos parents parlent anglais, vous parlerez également anglais. Imaginez maintenant que vous décidez d'apprendre une deuxième langue, comme l'allemand. Dans ce cas, vous avez élargi vos attributs parce que vous avez ajouté un attribut que vos parents n'ont pas.

Exemple de parc pour chiens

Imaginez un instant que vous êtes dans un parc pour chiens. Il y a beaucoup de chiens de races différentes dans le parc, tous se livrant à divers comportements canins.

Supposons maintenant que vous souhaitiez modéliser le parc à chiens avec des classes Python. le Chien La classe que vous avez écrite dans la section précédente peut distinguer les chiens par leur nom et leur âge, mais pas par race.

Vous pouvez modifier le Chien dans la fenêtre de l'éditeur en ajoutant un .race attribut:

classe Chien:
    espèce = "Canis familiaris"

    def __init__(soi, Nom, âge, race):
        soi.Nom = Nom
        soi.âge = âge
        soi.race = race

Les méthodes d'instance définies précédemment sont omises ici car elles ne sont pas importantes pour cette discussion.

presse F5 pour enregistrer le fichier. Vous pouvez maintenant modéliser le parc pour chiens en instanciant un tas de chiens différents dans la fenêtre interactive:

>>>

>>> miles = Chien("Miles", 4, "Jack Russell Terrier")
>>> copain = Chien("Copain", 9, "Teckel")
>>> jack = Chien("Jack", 3, "Bouledogue")
>>> Jim = Chien("Jim", 5, "Bouledogue")

Chaque race de chien a des comportements légèrement différents. Par exemple, les bouledogues ont une écorce basse qui ressemble à trame, mais les teckels ont une écorce plus aiguë qui ressemble plus à japper.

En utilisant uniquement le Chien , vous devez fournir une chaîne pour le du son argument de .parler() chaque fois que vous l'appelez sur un Chien exemple:

>>>

>>> copain.parler("Japper")
«Buddy dit Yap»

>>> Jim.parler("Trame")
«Jim dit Woof»

>>> jack.parler("Trame")
«Jack dit Woof»

Passer une chaîne à chaque appel à .parler() est répétitif et peu pratique. De plus, la chaîne représentant le son que chaque Chien par exemple les marques doivent être déterminées par son .race , mais ici, vous devez passer manuellement la chaîne correcte à .parler() à chaque appel.

Vous pouvez simplifier l'expérience de travail avec le Chien classe en créant une classe enfant pour chaque race de chien. Cela vous permet d'étendre les fonctionnalités dont chaque classe enfant hérite, notamment en spécifiant un argument par défaut pour .parler().

Classes parents vs classes enfants

Créons une classe enfant pour chacune des trois races mentionnées ci-dessus: Jack Russell Terrier, Teckel et Bulldog.

Pour référence, voici la définition complète du Chien classe:

classe Chien:
    espèce = "Canis familiaris"

    def __init__(soi, Nom, âge):
        soi.Nom = Nom
        soi.âge = âge

    def __str__(soi):
        revenir F"soi.Nom    est soi.âge    ans"

    def parler(soi, du son):
        revenir F"soi.Nom    dit du son"

N'oubliez pas que pour créer une classe enfant, vous créez une nouvelle classe avec son propre nom, puis mettez le nom de la classe parent entre parenthèses. Ajoutez ce qui suit à la dog.py fichier pour créer trois nouvelles classes enfants du Chien classe:

classe JackRussellTerrier(Chien):
    passer

classe Teckel(Chien):
    passer

classe Bouledogue(Chien):
    passer

presse F5 pour enregistrer et exécuter le fichier. Avec les classes enfants définies, vous pouvez désormais instancier certains chiens de races spécifiques dans la fenêtre interactive:

>>>

>>> miles = JackRussellTerrier("Miles", 4)
>>> copain = Teckel("Copain", 9)
>>> jack = Bouledogue("Jack", 3)
>>> Jim = Bouledogue("Jim", 5)

Les instances de classes enfants héritent de tous les attributs et méthodes de la classe parent:

>>>

>>> miles.espèce
«Canis familiaris»

>>> copain.Nom
'Copain'

>>> impression(jack)
Jack a 3 ans

>>> Jim.parler("Trame")
«Jim dit Woof»

Pour déterminer à quelle classe un objet donné appartient, vous pouvez utiliser la fonction intégrée type():

>>>

>>> type(miles)

Et si vous voulez déterminer si miles est également une instance de la Chien classe? Vous pouvez le faire avec le intégré isinstance ():

>>>

>>> isinstance(miles, Chien)
Vrai

Remarquerez que isinstance () prend deux arguments, un objet et une classe. Dans l'exemple ci-dessus, isinstance () vérifie si miles est une instance de la Chien classe et retours Vrai.

le miles, copain, jack, et Jim les objets sont tous Chien instances, mais miles n'est pas un Bouledogue par exemple, et jack n'est pas un Teckel exemple:

>>>

>>> isinstance(miles, Bouledogue)
Faux

>>> isinstance(jack, Teckel)
Faux

Plus généralement, tous les objets créés à partir d'une classe enfant sont des instances de la classe parent, bien qu'ils ne puissent pas être des instances d'autres classes enfants.

Maintenant que vous avez créé des classes pour enfants pour différentes races de chiens, donnons à chaque race son propre son.

Étendre les fonctionnalités d'une classe parent

Étant donné que différentes races de chiens ont des aboiements légèrement différents, vous souhaitez fournir une valeur par défaut pour le du son argument de leurs respectifs .parler() méthodes. Pour ce faire, vous devez remplacer .parler() dans la définition de classe pour chaque race.

Pour remplacer une méthode définie sur la classe parent, vous définissez une méthode portant le même nom sur la classe enfant. Voici à quoi cela ressemble pour le JackRussellTerrier classe:

classe JackRussellTerrier(Chien):
    def parler(soi, du son="Arf"):
        revenir F"soi.Nom    dit du son"

Maintenant .parler() est défini sur le JackRussellTerrier classe avec l'argument par défaut pour du son mis à "Arf".

Mettre à jour dog.py avec le nouveau JackRussellTerrier classe et presse F5 pour enregistrer et exécuter le fichier. Vous pouvez maintenant appeler .parler() sur un JackRussellTerrier par exemple sans passer un argument à du son:

>>>

>>> miles = JackRussellTerrier("Miles", 4)
>>> miles.parler()
«Miles dit Arf»

Parfois, les chiens font des aboiements différents, donc si Miles se met en colère et grogne, vous pouvez toujours appeler .parler() avec un son différent:

>>>

>>> miles.parler("Grrr")
«Miles dit Grrr»

Une chose à garder à l'esprit concernant l'héritage de classe est que les modifications apportées à la classe parent se propagent automatiquement aux classes enfants. Cela se produit tant que l'attribut ou la méthode en cours de modification n'est pas remplacé dans la classe enfant.

Par exemple, dans la fenêtre de l'éditeur, modifiez la chaîne renvoyée par .parler() dans le Chien classe:

classe Chien:
    # Laisser les autres attributs et méthodes tels quels

    # Changer la chaîne retournée par .speak ()
    def parler(soi, du son):
        revenir F"soi.Nom    aboiements: du son"

Enregistrez le fichier et appuyez sur F5. Maintenant, lorsque vous créez un nouveau Bouledogue instance nommée Jim, jim.speak () renvoie la nouvelle chaîne:

>>>

>>> Jim = Bouledogue("Jim", 5)
>>> Jim.parler("Trame")
«Jim aboie: Woof»

Cependant, appeler .parler() sur un JackRussellTerrier l'instance n'affichera pas le nouveau style de sortie:

>>>

>>> miles = JackRussellTerrier("Miles", 4)
>>> miles.parler()
«Miles dit Arf»

Parfois, il est logique de remplacer complètement une méthode d'une classe parente. Mais dans ce cas, nous ne voulons pas que JackRussellTerrier pour perdre toutes les modifications qui pourraient être apportées à la mise en forme de la chaîne de sortie de Dog.speak ().

Pour ce faire, vous devez toujours définir un .parler() méthode sur l'enfant JackRussellTerrier classe. Mais au lieu de définir explicitement la chaîne de sortie, vous devez appeler le Chien classe .parler() à l'intérieur de la classe enfant .parler() en utilisant les mêmes arguments que vous avez transmis à JackRussellTerrier.speak ().

Vous pouvez accéder à la classe parent depuis l'intérieur d'une méthode d'une classe enfant en utilisant super():

classe JackRussellTerrier(Chien):
    def parler(soi, du son="Arf"):
        revenir super().parler(du son)

Quand vous appelez super (). parler (son) à l'intérieur JackRussellTerrier, Python recherche la classe parente, Chien, pour un .parler() et l'appelle avec la variable du son.

Mettre à jour dog.py avec le nouveau JackRussellTerrier classe. Enregistrez le fichier et appuyez sur F5 afin que vous puissiez le tester dans la fenêtre interactive:

>>>

>>> miles = JackRussellTerrier("Miles", 4)
>>> miles.parler()
«Miles aboie: Arf»

Maintenant, quand vous appelez miles.speak (), vous verrez une sortie reflétant la nouvelle mise en forme dans le Chien classe.

Vérifie ta compréhension

Développez le bloc ci-dessous pour vérifier votre compréhension:

Créer un Golden retriever classe qui hérite de la Chien classe. Donner la du son argument de GoldenRetriever.speak () une valeur par défaut de "Écorce". Utilisez le code suivant pour votre parent Chien classe:

classe Chien:
    espèce = "Canis familiaris"

    def __init__(soi, Nom, âge):
        soi.Nom = Nom
        soi.âge = âge

    def __str__(soi):
        revenir F"soi.Nom    est soi.âge    ans"

    def parler(soi, du son):
        revenir F"soi.Nom    dit du son"

Vous pouvez développer le bloc ci-dessous pour voir une solution:

Créez une classe appelée Golden retriever qui hérite de la Chien classe et remplace la .parler() méthode:

classe Golden retriever(Chien):
    def parler(soi, du son="Écorce"):
        revenir super().parler(du son)

le du son paramètre dans GoldenRetriever.speak () reçoit une valeur par défaut de "Écorce". ensuite super() est utilisé pour appeler la classe parent .parler() méthode avec le même argument passé à du son comme le Golden retriever classe .parler() méthode.

Conclusion

Dans ce didacticiel, vous avez appris la programmation orientée objet (POO) en Python. La plupart des langages de programmation modernes, tels que Java, C # et C ++, suivent les principes de la POO, de sorte que les connaissances que vous avez acquises ici seront applicables, peu importe où votre carrière en programmation vous mène.

Dans ce didacticiel, vous avez appris à:

  • Définissez un classe, qui est une sorte de plan pour un objet
  • Instancier une objet d'une classe
  • Utilisation les attributs et les méthodes définir le Propriétés et comportements d'un objet
  • Utilisation héritage créer cours pour enfants de classe parent
  • Référencez une méthode sur une classe parente en utilisant super()
  • Vérifiez si un objet hérite d'une autre classe à l'aide isinstance ()

Si vous avez apprécié ce que vous avez appris dans cet exemple de Bases de Python: une introduction pratique à Python 3, alors assurez-vous de consulter le reste du livre.

[ad_2]