Objets qui interagissent
Requis
La page Objets et classes, et la classe Eleve de sa section 6 écrite sans regarder la correction. Savoir dessiner des ronds et des flèches, et dire ce que is demande.
Garde la classe Animal dans ton fichier : la classe de cette page la nomme dès sa première ligne, et Python refuse de créer une classe qui déclare un attribut d'un type qu'il ne connaît pas encore.
Rappel d'ouverture (5 minutes, de mémoire, cahier fermé)
Écris tes réponses sur ton cahier avant de regarder la correction.
c = Animal("Rocket", "grogne")etd = Animal("Rocket", "grogne"). Que valentc is detc.nom == d.nom? Écris pourquoi, une raison pour chacun.- Une fonction annonce dans sa docstring qu'elle ne modifie pas son argument. Que doit regarder son test, en plus de la valeur renvoyée ?
self.moyenne()apparaissait dans la méthodebulletinde la classeEleve. Sur quel objet cette moyenne est-elle calculée ?
Correction
c is dvautFalseetc.nom == d.nomvautTrue.isdemande « est-ce le même objet », et il y a bien deux ronds, chaque appel àAnimal(...)en fabriquant un.==compare des valeurs, et elles sont égales.- L'état de l'argument après l'appel. Un test qui ne regarde que ce qui est renvoyé passe au-dessus de la moitié du contrat.
- Sur l'objet courant, celui que
selfdésigne, c'est-à-dire l'élève dont on demande le bulletin. Une méthode peut en appeler une autre sur le même objet.
1 Un objet peut en contenir d'autres
Jusqu'ici, les attributs étaient des nombres et des chaînes. Rien n'empêche un attribut d'être un autre objet, ou une liste d'autres objets. C'est à partir de là qu'un programme cesse d'être une classe isolée.
Le contrat
Un humain porte un prénom et un nom, et il adopte des animaux. On peut demander la liste des noms de ses animaux, un par ligne.
class Humain:
prenom: str
nom: str
animaux: list[Animal]
def __init__(self, prenom: str, nom: str) -> None:
self.prenom = prenom
self.nom = nom
self.animaux: list[Animal] = []
def adopte(self, bete: Animal) -> None:
"""Ajoute bete aux animaux de cet humain."""
self.animaux.append(bete)
def menagerie(self) -> str:
"""Renvoie les noms des animaux de cet humain, un par ligne."""
texte = ""
for bete in self.animaux:
texte = texte + bete.nom + "\n"
return texte
Le schéma des deux classes porte une nouveauté, la flèche qui les relie.
classDiagram
class Humain {
prenom : str
nom : str
animaux : list[Animal]
adopte(bete)
menagerie() str
}
class Animal {
nom : str
cri : str
parler() str
presenter() str
}
Humain "0..*" --> "0..*" Animal : animaux
Elle dit trois choses, et chacune se vérifie sur le code au-dessus.
- Son étiquette nomme l'attribut qui réalise le rapport, ici
animaux. - Les nombres aux deux bouts sont les cardinalités : un humain peut avoir de zéro à plusieurs animaux, et un animal peut se trouver chez de zéro à plusieurs humains.
- Sa pointe désigne la classe qui est tenue, et elle part de celle qui tient la référence. Ici
Humainporteanimaux: list[Animal], etAnimalne contient pas un seul mot sur les humains. Lis la flèche dans ce sens : un humain peut atteindre ses animaux, un animal ne peut atteindre personne.
La déclaration animaux: list[Animal] annonce l'attribut nouveau, et le type dit ce que la liste contiendra : des objets Animal, pas des chaînes. C'est pour cela que menagerie peut écrire bete.nom.
Mais c'est la ligne self.animaux = [] d'__init__ qui porte toute la section. Un humain neuf n'a aucun animal, et chacun reçoit sa liste au moment où il est fabriqué.
Lire et prédire (obligatoire)
Ne regarde pas la correction avant d'avoir écrit tes réponses sur ton cahier.
peter = Humain("Peter", "Quill")
rocket = Animal("Rocket", "grogne")
peter.adopte(rocket)
print(peter.menagerie())
print(len(peter.animaux))
print(peter.animaux[0].parler())
Écris :
- les lignes affichées, l'une sous l'autre,
- combien d'objets
Animalce programme fabrique, - ce que désigne exactement
peter.animaux[0].
Correction
La ligne vide est normale : menagerie termine chaque nom par un \n, et print en ajoute un second.
Un seul objet Animal est fabriqué, à la deuxième ligne. peter.adopte(rocket) n'en fabrique pas un deuxième : il range dans la liste une flèche vers celui qui existe.
peter.animaux[0] désigne donc cet animal-là, le même que rocket. C'est pour cela que peter.animaux[0].parler() fonctionne : ce qui est rangé dans la liste est un Animal complet, avec ses attributs et ses méthodes.
2 Un objet peut être à deux endroits à la fois
C'est le point dur de la section, et c'est celui où l'erreur ne se signale pas.
Dessiner (obligatoire)
Dessine sur ton cahier avant de lire la suite. Les règles sont celles de la page précédente : un objet, un rond, ses attributs dedans ; un nom, une flèche depuis l'extérieur.
peter = Humain("Peter", "Quill")
gamora = Humain("Gamora", "Zen Whoberi")
rocket = Animal("Rocket", "grogne")
peter.adopte(rocket)
gamora.adopte(rocket)
rocket.nom = "Groot"
Produis :
- le dessin après la cinquième ligne : tous les ronds, tous les noms, toutes les flèches, y compris celles qui partent des listes,
- le nombre total de ronds,
- ce que renvoie
peter.menagerie()après la sixième ligne, - ce que renvoie
gamora.menagerie()après la sixième ligne.
Correction
Trois ronds : deux humains et un seul animal. Et deux flèches arrivent sur l'animal, une depuis la liste de chaque humain.
graph LR
peter["prenom : Peter<br>nom : Quill<br>animaux : [ ]"] --> r["nom : Groot<br>cri : grogne"]
gamora["prenom : Gamora<br>nom : Zen Whoberi<br>animaux : [ ]"] --> r
Les deux méthodes renvoient la même chose, "Groot\n". On a renommé l'animal par le nom rocket, et le changement se voit chez les deux humains, parce qu'il n'y a qu'un animal.
C'est l'aliasing de la page précédente, remonté d'un cran : ce ne sont plus deux variables qui désignent le même objet, c'est une variable et deux listes.
Et c'est ce que le 0..* du côté Humain, sur le schéma de la section 1, annonçait : un même animal peut se trouver chez plusieurs humains à la fois.
Le bogue qui ne se voit pas tout de suite
On ajoute une méthode à Humain. Son contrat est clair, et pourtant elle est fausse.
def adopte_tous_de(self, autre: Humain) -> None:
"""Adopte tous les animaux de autre.
autre garde les siens : il n'en perd aucun, et ce qui arrive
ensuite chez l'un ne change rien chez l'autre.
"""
self.animaux = autre.animaux
Trouver quand ça casse (obligatoire)
Voici le début d'un test. Les deux assertions écrites passent.
def test_adopte_tous_de() -> None:
peter = Humain("Peter", "Quill")
gamora = Humain("Gamora", "Zen Whoberi")
peter.adopte(Animal("Rocket", "grogne"))
gamora.adopte_tous_de(peter)
assert gamora.menagerie() == "Rocket\n"
assert peter.menagerie() == "Rocket\n"
gamora.adopte(Animal("Groot", "ne dit rien"))
assert ... # ce que gamora a maintenant
assert ... # ce que peter a maintenant
Réponds sur ton cahier :
- que vaut
peter.menagerie()à la fin, vraiment ? - écris les deux assertions manquantes, celles qui disent ce qui devrait se passer,
- laquelle des quatre assertions échoue ?
- réécris
adopte_tous_depour qu'elles passent toutes.
Indice
Dessine après gamora.adopte_tous_de(peter). Combien de listes y a-t-il ?
Avant d'ouvrir la correction
Les deux premières assertions passent avec la méthode fausse. Qu'est-ce que cela t'apprend sur le moment où il faut tester un contrat du genre « l'autre n'est pas modifié » ?
Ce que ce test apprend, et qui vaut au-delà
Les deux premières assertions passent avec la méthode fausse. Un contrat du genre « l'autre n'est pas modifié » ne se teste donc pas seulement juste après l'appel : il se teste après une action ultérieure. C'est le seul moment où un partage de structure se révèle.
3 Quelle classe est le chef d'orchestre
Une question se pose chaque fois que deux classes sont en rapport, et elle n'a pas de réponse automatique : qui garde la référence vers l'autre ? Jusqu'ici l'humain tenait ses animaux. Rien n'obligeait à faire ainsi.
Les deux schémas ci-dessous ne portent que les attributs, et laissent la partie des méthodes vide : c'est dans les attributs que la question se joue.
Conception A, celle de la section 1 : l'humain tient ses animaux.
classDiagram
class Humain {
prenom : str
nom : str
animaux : list[Animal]
}
class Animal {
nom : str
cri : str
}
Humain "0..*" --> "0..*" Animal : animaux
class Humain:
prenom: str
nom: str
animaux: list[Animal]
def __init__(self, prenom: str, nom: str) -> None:
self.prenom = prenom
self.nom = nom
self.animaux = []
Conception B : l'animal garde son propriétaire.
classDiagram
class Humain {
prenom : str
nom : str
}
class Animal {
nom : str
cri : str
proprietaire : Humain
}
Animal "0..*" --> "1" Humain : proprietaire
class Animal:
nom: str
cri: str
proprietaire: Humain
def __init__(self, nom: str, cri: str, proprietaire: Humain) -> None:
self.nom = nom
self.cri = cri
self.proprietaire = proprietaire
Les deux décrivent le même monde, et elles n'écrivent pas le même programme. La flèche a changé de sens, les cardinalités aussi, et surtout l'attribut a changé de classe. Ce n'est pas une question de goût, et ce n'est pas non plus arbitraire : ce qui tranche est la liste des questions auxquelles le programme devra répondre.
Choisir, et dire pourquoi (obligatoire)
Deux questions qu'un programme pourrait avoir à traiter :
- (a) quels sont les animaux de Peter ?
- (b) à qui appartient Rocket ?
Recopie et remplis ce tableau sur ton cahier. Dans chaque case, écris immédiat si la réponse se lit directement sur l'objet, ou parcours s'il faut passer en revue tous les objets de l'autre classe.
| (a) les animaux de Peter | (b) le propriétaire de Rocket | |
|---|---|---|
Humain porte animaux: list[Animal] |
||
Animal porte proprietaire: Humain |
Puis réponds en une phrase : si ton programme ne pose jamais la question (b), lequel des deux choix retiens-tu ?
Correction
| (a) les animaux de Peter | (b) le propriétaire de Rocket | |
|---|---|---|
Humain porte animaux: list[Animal] |
immédiat | parcours de tous les humains |
Animal porte proprietaire: Humain |
parcours de tous les animaux | immédiat |
Chaque choix rend une question immédiate et l'autre coûteuse. Si la question (b) ne se pose jamais, on retient le premier : l'humain porte ses animaux, et on n'a même pas besoin de tenir la liste de tous les animaux du monde pour répondre à (a).
La classe qui porte la référence est celle qu'on appelle le chef d'orchestre, et c'est elle d'où part la flèche du schéma.
Et le troisième choix, celui auquel on pense toujours, est le plus cher. Rien n'empêche de faire les deux à la fois : Humain garde sa liste et Animal garde son propriétaire. Les deux questions deviennent immédiates, et on paie l'addition ailleurs : à chaque adoption il faut penser à écrire les deux attributs, et le jour où l'un est mis à jour sans l'autre, le programme croit deux choses contradictoires sans rien signaler. C'est une version du bogue de la section 2, et elle ne se répare pas en relisant une ligne : il faut retrouver tous les endroits qui modifient l'un des deux côtés.
4 À toi d'écrire : la voiture
Classe Voiture (obligatoire)
Une seule classe, pour se remettre en jambes avant la suivante.
Le contrat
Une voiture porte une marque, un modèle, un prix, une consommation en litres aux 100 km et une capacité de réservoir en litres. Elle démarre à 0 km et le réservoir vide.
roule(distance)augmente le kilométrage et diminue le carburant. Précondition : il y a assez de carburant pour la distance.plein()remplit le réservoir et renvoie le nombre de litres ajoutés.fiche()renvoie une chaîne de la forme"Renault Clio : 300.0 km, 35.0 L".
Complète le squelette, puis les assertions marquées d'un commentaire, et lance le test.
class Voiture:
... # les declarations d'attributs, une par ligne
def __init__(self, marque: str, modele: str, prix: float,
conso: float, capacite: float) -> None:
...
def roule(self, distance: float) -> None:
"""Augmente le kilométrage de distance et diminue le carburant.
Précondition : le carburant suffit pour la distance.
"""
...
def plein(self) -> float:
"""Remplit le réservoir et renvoie le nombre de litres ajoutés."""
...
def fiche(self) -> str:
"""Renvoie une chaîne de la forme 'Renault Clio : 300.0 km, 35.0 L'."""
...
def test_Voiture() -> None:
v = Voiture("Renault", "Clio", 12000.0, 5.0, 50.0)
assert v.km == 0.0
assert v.carburant == 0.0
assert v.plein() == 50.0
assert ... # le carburant apres le plein
v.roule(100.0)
assert v.km == 100.0
assert ... # le carburant apres 100 km a 5 L aux 100
v.roule(200.0)
assert ... # le kilometrage
assert ... # le carburant
assert ... # ce que renvoie fiche()
Indice : la consommation
La consommation est donnée aux 100 km. Pour une distance d, le carburant consommé est donc d * self.conso / 100.
Avant d'ouvrir la correction
Si une assertion échoue, écris d'abord la valeur que tu attendais et celle que Python donne. L'écart entre les deux désigne la ligne à corriger, plus sûrement que le message d'erreur.
5 À toi d'écrire : le conducteur
C'est ici que la composition revient. Le conducteur ne roule pas lui-même : il demande à une voiture de rouler, et il décide quand faire le plein.
Classe Conducteur (obligatoire)
Le contrat
Un conducteur porte un prénom, une somme d'argent, et la liste de ses voitures, vide au départ. Le prix du litre est la constante PRIX_LITRE.
achete(v)ajoutevà ses voitures et diminue son argent du prix dev. Précondition : il a assez d'argent.trajet(v, distance)fait roulervsurdistancekm. Si le carburant ne suffit pas, il fait d'abord le plein et paie les litres ajoutés. Il renvoie ce que le trajet a coûté en carburant, et0.0si aucun plein n'a été nécessaire. Précondition :vest à lui, et un réservoir plein suffit pour la distance.
Avant d'écrire la moindre ligne, dessine sur ton cahier le schéma des deux classes, Voiture et Conducteur, avec la flèche et ses cardinalités. Réfléchis au sens de la pointe avant de la tracer. Le contrat ci-dessus te donne tout ce qu'il faut : attributs, types, méthodes, et ce qu'elles renvoient. Une fois le schéma fait, tu sauras quoi écrire.
PRIX_LITRE = 2.0
class Conducteur:
... # les declarations d'attributs, une par ligne
def __init__(self, prenom: str, argent: float) -> None:
...
def achete(self, v: Voiture) -> None:
"""Ajoute v à ses voitures et diminue son argent du prix de v.
Précondition : il a assez d'argent.
"""
...
def trajet(self, v: Voiture, distance: float) -> float:
"""Fait rouler v sur distance km, après un plein si nécessaire.
Renvoie le coût du carburant acheté, 0.0 si aucun plein.
Précondition : v est à lui, et un plein suffit pour la distance.
"""
...
def test_Conducteur() -> None:
sam = Conducteur("Sam", 15000.0)
clio = Voiture("Renault", "Clio", 12000.0, 5.0, 50.0)
assert sam.voitures == []
sam.achete(clio)
assert sam.argent == 3000.0
assert len(sam.voitures) == 1
assert ... # la voiture rangee est bien CELLE qu'on a achetee
cout = sam.trajet(clio, 100.0)
assert cout == 100.0
assert ... # l'argent de sam
assert ... # le kilometrage de la clio
assert ... # le carburant de la clio
cout = sam.trajet(clio, 200.0)
assert ... # le cout de ce second trajet
assert ... # le carburant de la clio
Indice : la quatrième assertion
Elle ne compare pas des valeurs, elle demande si deux noms désignent le même objet. Un seul opérateur fait cela.
Avant d'ouvrir la correction
Le second trajet ne coûte rien. Avant de regarder, écris pourquoi, en une phrase, et vérifie que ton trajet produit bien ce résultat.
6 Ce qui vient ensuite
Un objet qui en contient d'autres, et une classe qui en pilote une autre : c'est le motif de tout ce qui suit.
Le projet de jeu en est fait entièrement, une classe Jeu tenant un vaisseau, des ennemis et des tirs, et les faisant agir à chaque image. Et la liste chaînée ira plus loin encore : un objet qui référence un objet de sa propre classe.
Avant cela, il reste une façon d'écrire une classe à partir d'une autre : l'héritage.