Héritage
Requis
La page Objets et classes, et la classe Eleve de sa section 6 écrite sans regarder la correction. Savoir dire ce que vaut self pendant l'exécution d'une méthode.
Rappel d'ouverture (5 minutes, de mémoire, cahier fermé)
Écris tes réponses sur ton cahier avant de regarder la correction.
- Dans une méthode, à quoi correspond
self? Une phrase. - On a
x = Animal("Rocket", "grogne")ety = x, puisy.cri = "ne dit rien". Que renvoiex.parler()? - La méthode
presenterd'Animalne contient pas le motcri, et pourtant son résultat change quandcrichange. Pourquoi ?
Correction
selfdésigne l'objet sur lequel la méthode a été appelée. Écrirex.parler()exécuteparleravecselfvalant l'objet désigné parx."Rocket ne dit rien".y = xne copie pas l'animal, les deux noms désignent le même objet, donc écrire paryse lit parx.- Parce que
presenterappelleself.parler(), et que c'estparlerqui litcri. Retiens ce chemin, c'est exactement ce que cette page va exploiter.
1 Écrire une classe à partir d'une autre
Un chien est un animal. Il porte un nom, il a un cri, il sait parler et se présenter. Tout cela est déjà écrit dans Animal, et le recopier serait du travail en double : le jour où parler change, il faudrait le changer à deux endroits.
Héritage
Une classe peut être écrite à partir d'une autre. Elle en reçoit tous les attributs et toutes les méthodes sans les réécrire, et elle peut en ajouter de nouveaux, ou en redéfinir un qui ne lui convient pas.
La classe de départ est la super classe, celle qu'on écrit à partir d'elle est la sous classe. Le test en français est « est un » : un chien est un animal, donc Chien peut hériter d'Animal.
class Chien(Animal):
def __init__(self, nom: str) -> None:
super().__init__(nom, "aboie")
def rapporter(self, objet: str) -> str:
return f"{self.nom} rapporte {objet}."
def presenter(self) -> str:
return f"Je suis {self.nom}, et je rapporte tout ce qui traîne."
Le schéma porte une seconde sorte de flèche, à pointe creuse, et elle ne dit pas du tout la même chose que celle de la page précédente.
classDiagram
Animal <|-- Chien
class Animal {
nom : str
cri : str
parler() str
presenter() str
}
class Chien {
rapporter(objet) str
presenter() str
}
La flèche à pointe simple de la page précédente disait « a un », et sa pointe désignait la classe tenue : un humain a des animaux. Celle-ci, à pointe creuse, dit « est un », et elle va toujours de la sous classe vers la super classe : un chien est un animal. Deux pointes différentes, deux sens de lecture différents.
Deux détails du schéma méritent qu'on s'arrête.
- La partie des attributs de
Chienest vide. Un chien n'en ajoute aucun : il anometcricomme tout animal, et c'est la flèche qui le dit. C'est pour cela que la classe ne déclare aucun attribut en haut, contrairement àAnimalet àHumain. Rien à recopier. parlerne figure pas non plus dansChien, alors quepresentery figure. On n'écrit dans la sous classe que ce qu'elle ajoute ou ce qu'elle redéfinit. Tout le reste se lit en remontant la flèche.
Trois choses se passent dans ces sept lignes, et il faut les distinguer.
Chien(Animal)dit d'où l'on part. Tout ce qu'Animalsait faire,Chienle sait déjà.super().__init__(nom, "aboie")appelle le constructeur de la super classe. Un chien a un cri comme tout animal, et ce cri est toujours le même : la sous classe fixe ce que la super classe laissait au choix. C'est pour cela queChien("Medor")ne prend qu'un argument.rapporterest ajoutée, elle n'existe pas dansAnimal.presenterest redéfinie, elle existait déjà et la version deChienremplace celle d'Animalpour les chiens, et pour eux seuls.
Et parler n'apparaît nulle part dans Chien. C'est voulu : elle est héritée telle quelle.
Lire et prédire (obligatoire)
Ne regarde pas la correction avant d'avoir écrit tes réponses sur ton cahier.
rocket = Animal("Rocket", "grogne")
medor = Chien("Medor")
print(rocket.parler())
print(medor.parler())
print(medor.rapporter("la balle"))
print(rocket.presenter())
print(medor.presenter())
print(isinstance(medor, Animal), isinstance(rocket, Chien))
Écris :
- les six lignes affichées, l'une sous l'autre,
- pour
medor.parler(), le nom de la classe où est écrite la méthode qui s'exécute,AnimalouChien, - la même question pour
medor.presenter().
Correction
Rocket grogne
Medor aboie
Medor rapporte la balle.
Je suis Rocket. Rocket grogne
Je suis Medor, et je rapporte tout ce qui traîne.
True False
medor.parler() exécute la méthode d'Animal : Chien n'en a pas, donc on remonte à la super classe. Elle renvoie "Medor aboie" parce que self.cri vaut "aboie", posé par super().__init__.
medor.presenter() exécute la méthode de Chien : elle y existe, donc celle d'Animal n'est pas utilisée. rocket, lui, n'est pas un chien, et prend donc celle d'Animal.
La dernière ligne dit que medor est un animal, et que rocket n'est pas un chien. isinstance sert à cela. Hors du débogage, en avoir besoin est en général le signe qu'on s'y est mal pris.
2 La méthode qui part est celle de l'objet, pas celle du code qui l'appelle
C'est le point qui décide si l'héritage est compris, et il se joue en trois lignes.
Qui parle ? (obligatoire)
Ne regarde pas la correction avant d'avoir écrit ta réponse sur ton cahier.
class A:
def dire(self) -> str:
return "A"
def presenter(self) -> str:
return "je dis " + self.dire()
class B(A):
def dire(self) -> str:
return "B"
b = B()
print(b.presenter())
Écris :
- la ligne affichée,
- le nom de la classe où est écrite la méthode
presenterqui s'exécute, - le nom de la classe où est écrite la méthode
direqui s'exécute.
Avant d'ouvrir la correction
presenter n'est écrite que dans A, et A ne connaît pas B. Pendant son exécution, que vaut self ?
Correction
La ligne affichée est je dis B.
presenter est celle de A, puisque B n'en a pas.
dire est celle de B. C'est le point à retenir : presenter écrit self.dire(), et self est l'objet sur lequel on a appelé la méthode, c'est-à-dire un B. On part donc chercher dire dans B d'abord, et on l'y trouve.
Autrement dit, une méthode écrite dans la super classe appelle la version redéfinie de la sous classe sans rien savoir d'elle. Ce n'est pas le texte de A qui décide, c'est l'objet.
3 À toi d'écrire
Classe Chat (obligatoire)
Un chat est un animal. Il miaule, toujours, et il sait en plus ronronner.
Écris la classe Chat, sur le modèle de Chien, puis complète les assertions marquées d'un commentaire et lance le test.
class Chat(Animal):
def __init__(self, nom: str) -> None:
...
def ronronner(self) -> str:
"""Renvoie une chaîne de la forme 'Felix ronronne.'."""
...
def test_Chat() -> None:
felix = Chat("Felix")
assert felix.nom == "Felix"
assert ... # son cri
assert ... # ce que renvoie parler()
assert ... # ce que renvoie ronronner()
assert ... # ce que renvoie presenter()
assert isinstance(felix, Animal) == True
Indice
Tu n'écris ni self.nom, ni self.cri, ni parler, ni presenter. Une seule ligne de __init__ suffit, et Chien te la montre.
Avant d'ouvrir la correction
Deux des assertions à compléter portent sur des méthodes que tu n'as pas écrites. Si tu ne sais pas quoi y mettre, relis la section 1 : où est écrite la méthode qui s'exécute ?
4 Ce qui vient ensuite
L'héritage sert peu quand les classes sont aussi proches que Chien et Chat : un attribut cri suffisait. Il devient utile quand la sous classe fait vraiment autre chose.
Tu en rencontreras deux usages dans la suite de l'année, et tu peux déjà aller voir à quoi ils ressemblent.
- Le projet Space Invaders, où une classe
EltGraphiqueporte ce que tout élément à l'écran sait faire, sa position, son déplacement, son dessin, sa collision, et oùVaisseau,EnnemietMissilen'écrivent que ce qui les distingue. Le schéma de classes y est déjà dessiné, et tu sais maintenant le lire : trois flèches à pointe creuse, et un trait entreJeuetVaisseauavec ses cardinalités. - La liste chaînée, où une classe marque la fin de la chaîne en héritant du maillon ordinaire. Elle s'écrit en Java, et c'est là que la forme de la section 2 de la première page prend tout son sens.
Les schémas ont un nom
Les trois dessins de ce chapitre, le cadre en trois parties, la flèche à pointe simple et celle à pointe creuse, ne sont pas une invention de ce cours. Ils viennent d'une notation standard, UML, utilisée partout où l'on conçoit des programmes à objets, et tu en as vu la petite partie qui sert ici.
Deux choses à savoir si tu cherches par toi-même. C'est le mot à taper, et il te donnera bien plus que ce dont tu as besoin : UML compte une dizaine de sortes de schémas, et une seule nous a servi. Et tu verras des + et des - devant les attributs, que nous n'écrivons pas : ils disent ce qui est accessible depuis l'extérieur de la classe, et Python ne le marque pas.
Tu n'as d'ailleurs pas besoin de chercher pour les rencontrer. Le schéma du projet Space Invaders les emploie, et il y écrit aussi le type avant le nom, +float x au lieu de x : float. C'est l'ordre de Java, celui que tu retrouveras dans la liste chaînée.