L'informatique et l'internet ont révolutionné le monde de la diffusion musicale. Grâce à la numérisation et aux connexions à haut débit, chacun peut de nos jours stocker et échanger très facilement de larges volumes de musique. La vente en ligne a détrôné les magasins physiques, les ventes de disques sont en chute libre et les logiciels sont désormais au centre de la diffusion musicale, que ce soit dans les serveurs des diffuseurs, sur nos ordinateurs et sur les baladeurs et smartphones dans nos poches.

Spotify, un service logiciel d'écoute musicale bien connu.

Fondé par de jeunes diplômés de l'UCL, la société SoundPlaza compte mettre en place un espace de rencontre pour les musiciens de la région, avec une forte présence sur la Toile. Ils veulent offrir un site de diffusion de musique pour leurs membres et font appel à votre service pour les aider à développer leur infrastructure de gestion de données. Ils désirent, à partir de la liste des chansons disponibles sur leur serveur, assembler automatiquement des albums correspondant à la taille d'un CD. Ils comptent sur vos compétences nouvellement acquises en programmation orientée objets pour définir et exploiter les structures de données nécessaires.

Depuis le début de ce cours, vous avez commencé à manipuler des classes et objets déjà définis (comme les classes str, int, float et Turtle, par exemple). Néanmoins, cette mission marque votre entrée dans le vrai monde de la programmation orientée objets. Cette semaine, vous allez définir vos propres classes et objets.

2 Objectifs

A l'issue de cette mission, chacun d'entre vous :

pourra expliquer en ses propre mots en quoi consiste la programmation orientée objets;
pourra expliquer et illustrer les notions élémentaires de la programmation orientée objets telles que:
- classe, objet et instance;
- attributs et méthodes d'instance;
- méthode d'initialisation et constructeur;
pourra faire des manipulations simple sur un objet comme :
- la création d'un objet;
- accéder à un de ces attributs;
- modifier la valeur d'un attribut;
- appeler une méthode sur cet objet;
aura appris la conversion automatique d'un objet en un string par la méthode magique __str__;
aura écrit un premier programme utilisant des objets en Python;

3 Préparation, étude et apprentissage

La matière relative à cette mission est décrite dans les sections suivantes de la partie Objects du syllabus en ligne:

1 - Classes and objects - Basics
- Object-oriented programming
- User-defined compound data types
- Attributes
- Improving the initialiser
- Adding other methods to the class
- Instances as arguments and parameters
- Converting an instance to a string
- Instances as return values
- A change of perspective
- Objects can have state
2 - Classes and objects - Advanced
- Rectangles
- Objects are mutable
- Sameness
- Copying

Un exemple d'un un premier programme utilisant des objets en Python, utlisé comme illustration dans le cours théorique, se trouve dans l'annexe suivant:

Appendix - Source code of phone class

4 Questionnaire de démarrage

4.1 Questions à choix multiple

Les questions à choix multiples de cette mission sont accessibles en ligne depuis https://inginious.info.ucl.ac.be/course/LSINF1101-PYTHON/Session9_QCM

4.2 Questions ouvertes

4.2.1 Définitions

Considérez le code suivant d'une classe Student représentant un étudiant:

class Student :

    def __init__(self,n) :
        """
        Initialise un nouvel objet de type Student avec un nom n donné.
        @pre:  -
        @post: Un objet de type Student a été créé avec comme 'name' n,
               et un score None pour chacun des trois tests 'test1', 'test2' et 'test3'
        """
        # nom de l'étudiant
        self.name = n
        # score reçu par l'étudiant sur trois tests
        # (initialement None car l'étudiant n'a pas encore passé les tests)
        self.test1 = None
        self.test2 = None
        self.test3 = None

    def average_score(self) :
        """"
        Calcul de la moyenne des scores obtenus par l'étudiant sur les 3 tests.
        @pre: les variables d'instance test1, test2 et test3
              contiennent des valeurs de type int
        @post: retourne la moyenne de ces trois valeurs
        """
        return (self.test1 + self.test2 + self.test3) / 3

Les instructions suivant donnent un exemple de comment cette classe peut être utilisé:

student = Student("Kim")
student.test1 = 14.0
student.test2 = 10.5
student.test3 = 12.0
print("Bonjour, " + student.name + ". Vos scores sont:")
print(student.test1)
print(student.test2)
print(student.test3)
print("La moyenne de vos scores est " + str(student.average_score()))
student2 = student
print("La moyenne de vos scores est " + str(student2.average_score()))
student = None
student2 = None

Sur base de ces extraits, donnez des exemples des notions suivantes, en veillant à être précis et rigoureux dans votre formulation:

**Classe, objet (ou instance)**

**Constructeur et méthode d'initialisation**

**Attribut (ou variable d'instance)**

**Méthode d'instance**

**Référence à un objet et la valeur None**

**Référence à self**

4.2.2 Classes et objets

Dans la question précédente, expliquez les notations student.name, student.average_score() et self.name et leur interprétation par Python.

4.2.3 Méthode de conversion de string

Dans la première question, pour imprimer le détail d'un objet student de la classe Student on devait exécuter la série d'instructions suivante:

print("Bonjour, " + student.name + ". Vos scores sont:")
print(student.test1)
print(student.test2)
print(student.test3)
print("Votre score moyenne est " + str(student.average_score()))

Au lieu d'exécuter cette série d'instructions à l'extérieur de la classe, ce serait beaucoup plus facile de pouvoir obtenir le même résultat en écrivant seulement:

print(student)

A cette fin, ajoutez une méthode magique __str__ à la classe Student qui retourne un string du style:

"Bonjour, Kim. Vos scores sont:
 14.0
 10.5
 12.0
 Votre score moyenne est 12.166666666666666"

Tester votre code comme suite:

>>> student = Student("Kim")
>>> student.test1 = 14.0
>>> student.test2 = 10.5
>>> student.test3 = 12.0
>>> print(student)
Bonjour, Kim. Vos scores sont:
14.0
10.5
12.0
Votre score moyenne est 12.666666666

4.2.4 Création de classes

4.2.5 Une classe simple

Dans le cadre d'un cours de programmation, un étudiant a développé une classe Pair permettant de manipuler un objet contenant une paire d'entiers. Le code de cette classe Python est repris ci-dessous :

class Pair:
    """
    Une paire d'entiers
    """

    def __init__(self, x=None, y=None):
        """
        @pre -
        @post crée une paire (a,b) composée de x et y,
              ou une paire non-initialisée si aucune valeur
              de x et de y n'est donné lors de l'appel au constructeur
        """
        self.a = x   # le premier élément de la paire
        self.b = y   # le second élément de la paire

    def __str__(self):
        return str(self.a) + ", " + str(self.b)

Remarque: La notation x=None, y=None dans l'entête de la méthode __init__ permet de donner des valeurs par défaut à certains ou à tous paramètres de la fonction. Lorsque nous appelons la fonction, si des valeurs ne sont pas données pour ces paramètres, ils reçoivent les valeurs par défaut sinon, on peut leur donner une valeur différente en donnant un argument lors de l'appel.

Considérons maintenant le code Python ci-dessous illustrant une utilisation de la classe Pair:

p0 = Pair()      ##1##
p1 = Pair(0,0)   ##2##
p2 = Pair(1,1)   ##3##
p0.b = 3         ##4##
p1.a = 10        ##5##
p2.a = p1.a      ##6##
p2 = p1          ##7##

Expliquez les opérations effectuées par chacune de ces lignes. Pensez à utiliser une représentation graphique des différents objets telle que celle utilisée dans le syllabus ou les transparents en indiquant les valeurs des différentes variables d'instance.

Après avoir exécuté les opérations précédentes, qu'impriment les instructions suivantes?

print(p0)        ##8##
print(p1)        ##9##
print(p2)        ##10##

4.2.6 Egalité

Considérez les instructions suivantes qui utilisent la classe Pair vue précédemment:

p1 = Pair(9, 42)
p2 = Pair(9, 42);
if (p1 == p2) : print("Egaux en 1")   ##1##
p2 = p1
if (p1 == p2) : print("Egaux en 2")   ##2##

Lesquelles des lignes ##1## et/ou ##2## produiront-elles un message? Pourquoi? Expliquez ce comportement avec un dessin.

4.2.7 Une méthode simple

4.2.8 OrderedPair

Un étudiant propose ensuite de construire une classe OrderedPair qui utilise la classe Pair définie précédemment et y ajoute un booléen. Ce booléen est utilisé pour indiquer si une instance de la classe OrderedPair est ordonnée ou non: il est vrai lorsque la valeur stockée dans l'attribut a est inférieure ou égale à la valeur stockée dans l'attribut b.

Mission 8

1 Introduction

L'objectif principal de cette mission est de définir et d'utiliser trois classes correspondant respectivement à une durée (une espace de temps sous la forme heures-minutes-secondes), à une chanson (caractérisée par un titre, un auteur et une durée) et à un album (un ensemble de chansons). Vous utiliserez ensuite ces classes pour réaliser la génération d'albums souhaitée. Vous travaillerez par groupes de deux.

Dans le cadre du prototype à réaliser, les chansons vous sont fournies dans un fichier contenant des lignes de texte:

"TITRE AUTEUR MIN SEC"

où "TITRE", "AUTEUR", "MIN" et "SEC" correspondent respectivement au titre, à l'auteur, et à la durée de la chanson en minutes et secondes, et ne contiennent eux-mêmes pas d'espaces, par exemple:

Let's_Dance David_Bowie 4 5
Relax Frankie_Goes_To_Hollywood 3 54
Purple_Rain Prince 5 48
Enjoy_The_Silence Depeche_Mode 4 13

Ce format facilite leur lecture. On vous rappelle que la méthode split() permet de séparer un string contenant des espaces en mots individuels.

Il est plus que jamais important de bien tester votre code, étant donné que les classes que vous définissez pourront être utilisées dans des usages multiples. Au sein de votre binôme, pendant qu'un étudiant se concentre sur le développement d'une classe, l'autre pourrait préparer les tests pour cette classe. Les spécifications des méthodes étant donné par avance, il est en effet tout à fait possible de préparer des tests en même temps que (voire avant) la classe à tester. Il s'agit en quelque sorte d'un jeu: le développeur parviendra-t-il à écrire une classe qui fonctionnera correctement sous toutes les attaques du testeur? Le testeur parviendra-t-il à trouver le test qui causera un fonctionnement incorrect?

Remarque: Lors de cette mission vous utiliserez encore les instructions 'assert' pour tester votre programme orienté objet. Dans une mission futur nous introduirons le mécanisme des 'tests unitaires' qui sera encore mieux approprié pour tester du code orienté objets.

2 Etapes

2.1 Fichiers

Chargez les fichiers "music-db.txt", "mission8.py" et "test.py".

"music-db.txt" contient une liste de plus de 300 chansons, au format décrit ci-dessus.
"mission8.py" contient la définition des 3 classes Duree, Chanson et Album à compléter, mais avec une implémentation vide.
"test.py" contient une ébauche (à compléter par vous) d'un ensemble de fonctions test pour tester le bon comportement des 3 classes et du programme à réaliser.

2.2 La classe `Duree`

Commencez par définir la classe Duree qui représente une durée exprimée en heures (h), minutes (m) et secondes (s).

Ajoutez d'abord la méthode d'initialisation __init__(self, h, m, s), qui requiert que m et s soient dans l'intervalle [0..60[ et crée un nouveau temps de h heures, m minutes et s secondes. Ajoutez une spécification à cette méthode et vérifiez que les conditions requises soient bien respectées.

def __init__(self,h,m,s):
    """
    @pre: h, m et s sont des entiers positifs (ou zéro)
          m et s sont < 60
    @post: Crée une nouvelle durée en heures, minutes et secondes.
    """

Ajoutez ensuite les méthodes correspondant aux spécifications suivantes:

def to_secondes(self):
    """
    @pre:  -
    @post: Retourne le nombre total de secondes de cette instance de Duree (self).
    Par exemple, une durée de 8h 41m 25s compte 31285 secondes.
    """

def delta(self,d) :
    """
    @pre:  d est une instance de la classe Duree
    @post: Retourne la différence en secondes entre cette durée (self)
           et la durée d passée en paramètre.
           Cette valeur renovoyée est positif si cette durée (self)
           est plus grand que la durée d, négatif sinon.
    Par exemple, si cette durée (self) est 8h 41m 25s (donc 31285 secondes)
    et la durée d est 0h 1m 25s, la valeur retournée est 31200.
    Inversement, si cette durée (self) est 0h 1m 25s et la durée
    d est 8h 41m 25s, alors la valeur retournée est -31200.
    """

def apres(self,d):
    """
    @pre:  d est une instance de la classe Duree
    @post: Retourne True si cette durée (self) est plus grand que la durée
           d passée en paramètre; retourne False sinon.
    """

def ajouter(self,d):
    """
    @pre:  d est une instance de la classe Duree
    @post: Ajoute une autre durée d à cette durée (self),
           corrigée de manière à ce que les minutes et les secondes soient
           dans l'intervalle [0..60[, en reportant au besoin les valeurs
           hors limites sur les unités supérieures
           (60 secondes = 1 minute, 60 minutes = 1 heure).
           Ne retourne pas une nouvelle durée mais modifié la durée self.
    """

def __str__(self):
    """
    @pre:  -
    @post: Retourne cette durée sous la forme de texte "heures:minutes:secondes".
    Astuce: l'expression "{:02}:{:02}:{:02}".format(heures, minutes, secondes)
    retourne le string désiré avec les nombres en deux chiffres en ajoutant
    les zéros nécessaires.
    """

2.3 Tester la classe `Duree`

Dans le fichier test.py, ajoutez ou complétez au fur et à mesure des fonctions tests pour tester la classe Duree. Exécutez ces tests régulièrement et assurez-vous que les résultats sont conformes aux spécifications, en corrigeant au besoin.

Il est une bonne idée d'avoir un ou plusieurs tests, avec différents scénarios de test, par méthode de la classe Duree. Par exemple, pour la méthode ajouter() de votre classe Duree, vous pourrez implémenter une fonction test_Duree_ajouter() pour tester les différents scénarios d'utilisation de la méthode ajouter() de cette classe. Vous pouvez vous inspirer des quelques tests qui se trouvent déjà dans le fichier test.py.

2.4 La classe `Chanson`

Définissez maintenant la classe Chanson représentant une chanson, caractérisée par un titre t (string), un auteur a (string) et une durée d (Duree). Implémentez la méthode d'initialisation __init__ ainsi que la méthode de conversion __str__ correspondant aux spécifications suivantes:

 def __init__(self,t,a,d):
     """
     @pre:  t et a sont des string, d est une instance de la classe Duree
     @post: Crée une nouvelle chanson, caractérisée par un titre t,
            un auteur a et une durée d.
     """

def __str__(self):
    """
    @pre:  -
    @post: Retourne un string décrivant cette chanson sous le format
           "TITRE - AUTEUR - DUREE".
           Par exemple: "Let's_Dance - David_Bowie - 00:04:05"
    """

2.5 Tester la classe `Chanson`

Ajoutez au fichier test.py une série de tests pour tester les différentes méthodes de la classe Chanson.

2.6 La classe `Album`

Définissez maintenant la classe Album représentant un album contenant une ou plusieurs chansons.

Implémentez d'abord la méthode d'initialisation __init__ pour créer un album vide:

def __init__(self, numero):
    """
    @pre:  numero est un entier identifiant de facon unique cet album
    @post: Crée un nouvel album, avec comme identifiant le numero,
           et avec une liste de chansons vide.
    """

Implémentez également une méthode add(self,chanson) pour ajouter une chanson à un album. Cette méthode retourne False et ne modifie rien si lors de l'ajout de la chanson l'album aurait atteint 100 chansons ou sa durée aurait dépassé 75 minutes. Sinon la chanson est rajoutée à la fin de la liste des chansons de cet album, la durée totale de l'album est augmentée avec la durée de la chanson, et la méthode add retourne True.

Finalement, implémentez la méthode de conversion __str__ pour imprimer la description d'un album selon le format suivant:

Album 21 (12 chansons, 00:47:11)
01: White_Wedding - Billy_Idol - 00:04:12
02: Stand_And_Deliver - Adam_&_The_Ants - 00:03:33
03: You_Spin_Me_Around - Dead_Or_Alive - 00:03:14
04: Wired_For_Sound - Cliff_Richard - 00:03:38
05: Some_Like_It_Hot - The_Power_Station - 00:03:45
06: 99_Luftballons - Nena - 00:03:50
07: Keep_On_Loving_You - Reo_Speedwagon - 00:03:22
08: Seven_Into_The_Sea - In_Tua_Nua - 00:03:51
09: Love_Is_A_Battlefield - Pat_Benatar - 00:05:20
10: Etienne - Guesch_Patti - 00:04:07
11: This_Is_Not_A_Love_Song - Public_Image_Limited - 00:04:12
12: Love_Missile_F1-11 - Sigue_Sigue_Sputnik - 00:04:07

2.7 Tester la classe `Album`

Ajoutez au fichier test.py une série de tests pour tester la classe Album.

2.8 Le programme

Finalement, complétez votre programme par une série d'instructions qui:

lit dans le fichier music-db.txt, ligne par ligne, des descriptifs de chanson au format décrit en tête de cette section;
pour chaque ligne lue, construite une instance de Chanson;
stocke ses chansons dans un album avec identifiant le numéro 1;
lorsque le nombre de chansons stockés dans cet album a atteint 100 chansons ou la durée dépasserait 75 minutes, imprime à la console un descriptif de cet album avec les chansons accumulées, suivant l'exemple donné ci-dessus;
poursuit la lecture du fichier et l'ajout des chansons dans un album suivant (incrémentez le numéro identifiant l'album de 1 pour chaque nouvel album);
répète ces étapes jusqu'à ce que le fichier est vide et imprime le dernier album.

Si tout va bien votre programme final produira l'output suivant

Album 1 (17 chansons, 01:10:55)
01: Let's_Dance - David_Bowie - 00:04:05
02: Relax - Frankie_Goes_To_Hollywood - 00:03:54
03: Purple_Rain - Prince - 00:05:48
04: Enjoy_The_Silence - Depeche_Mode - 00:04:13
05: Chacun_Fait_C'Qui_Lui_Plait - Chagrin_D'amour - 00:04:08
06: Love_Missile_F1-11 - Sigue_Sigue_Sputnik - 00:04:06
07: Spaceman - Babylon_Zoo - 00:03:59
08: Hijo_De_La_Luna - Mecano - 00:04:19
09: 7_Seconds - Youssou_N'Dour_&_Neneh_Cherry - 00:03:48
10: Osez_Josephine - Alain_Bashung - 00:02:57
11: Dejeuner_En_Paix - Stephan_Eicher - 00:03:27
12: New_Gold_Dream - Simple_Minds - 00:05:31
13: Missing - Everything_But_The_Girl - 00:04:44
14: Nineteen - Paul_Hardcastle - 00:03:38
15: Killer - Adamski - 00:04:13
16: Unbelievable - EMF - 00:03:29
17: Overload - Sugababes - 00:04:36

Album 2 (17 chansons, 01:11:24)
01: Ice_Ice_Baby - Vanilla_Ice - 00:04:29
02: Do_You_Really_Want_To_Hurt_Me - Culture_Club - 00:04:23
03: Under_The_Milky_Way - The_Church - 00:04:57
04: Shout - Tears_For_Fears - 00:06:29
05: Pure_Morning - Placebo - 00:04:15
06: Porcelain - Moby - 00:04:00
07: Toi_Mon_Toit - Elli_Medeiros - 00:03:37
08: Just_A_Friend_Of_Mine - Vaya_Con_Dios - 00:03:22
09: Sleeping_Satellite - Tasmin_Archer - 00:04:36
10: I_Won't_Let_You_Down - DPH - 00:04:05
11: A_Girl_Like_You - The_Smithereens - 00:04:36
12: Ready_To_Go - Republica - 00:03:39
13: Oh_Carolina - Shaggy - 00:03:10
14: La_Sonora - Starflam - 00:03:49
15: Tombe_Pour_La_France - etienne_Daho - 00:04:13
16: The_Captain_Of_My_Heart - Double - 00:03:58
17: Human - Human_League - 00:03:46

...

Album 21 (12 chansons, 00:47:11)
01: White_Wedding - Billy_Idol - 00:04:12
02: Stand_And_Deliver - Adam_&_The_Ants - 00:03:33
03: You_Spin_Me_Around - Dead_Or_Alive - 00:03:14
04: Wired_For_Sound - Cliff_Richard - 00:03:38
05: Some_Like_It_Hot - The_Power_Station - 00:03:45
06: 99_Luftballons - Nena - 00:03:50
07: Keep_On_Loving_You - Reo_Speedwagon - 00:03:22
08: Seven_Into_The_Sea - In_Tua_Nua - 00:03:51
09: Love_Is_A_Battlefield - Pat_Benatar - 00:05:20
10: Etienne - Guesch_Patti - 00:04:07
11: This_Is_Not_A_Love_Song - Public_Image_Limited - 00:04:12
12: Love_Missile_F1-11 - Sigue_Sigue_Sputnik - 00:04:07

2.9 Tester le programme

Complétez le fichier test.py avec quelques tests pour démontrer que vos 3 classes Duree, Chanson et Album collaborent correctement et peuvent être utilisés pour créer des albums de chansons.

3 Diagramme de classes

Le diagramme de classes suivant résume les différentes classes et méthodes à implémenter lors de cette mission :

/syllabus/info1-exercises/assets/class_diagram_mission8.png

4 Remise de votre solution

Pour cette mission, vous devez soumettre votre programme mission8.py, le fichier test.py avec vos fonctions de tests pour les différentes classes que vous avez implémenté et votre fichier README.txt au serveur de soumissions de programmes du cours.

Votre fichier mission8.py doit contenir une définition des classes Duree, Chanson et Album, ainsi qu'une série d'instructions pour lire le fichier et créer et imprimer les albums.

Votre fichier test.py doit au moins contenir des tests pour les différentes méthodes des classes Duree, Chanson et Album, ainsi qu'une série d'instructions pour lancer tous les tests.

L'exécution de votre programme mission8.py doit imprimer l'output ci-dessus sur base du fichier original music-db.txt. Il ne vous est pas permis de faire des modifications à ce fichier.

Questions complémentaires

1 SMS Store

2 Création d'objets depuis un fichier

3 Personne

Créer une classe Personne décrivant des personnes physiques ayant un nom (un string), un attribut booléen 'desire_enfant' et une liste d'enfants (d'autres instances de la même classe) et comme méthodes:

les méthodes magiques __init__ et __str__ ;
avoir_enfant_avec(autre) crée une nouvelle personne avec un nom inconnu (None), à condition que la personne même et l'autre personne désirent un enfant ;
une méthode auxiliaire ajoute_enfant(bebe) utilisée par avoir_enfant_avec(autre) pour ajouter un enfant à la liste des enfants de chacun des deux parents ;
renommer(nom) donne un nouveau nom à la personne ;
premier_ne() retourne le premier enfant de la personne.

Utilisez et testez cette classe pour créer une grande famille de personnes.

Table des matières

Mission 9 - Héritage

Phase de démarrage

Phase de réalisation

Questions complémentaires

Mission 9 : Héritage

1 Introduction

Le traitement de données commerciales et financières est un des champs majeurs d'application de l'informatique. De nos jours, la moindre PME utilise l'informatique pour gérer sa comptabilité, ses commandes et sa facturation, et l'infrastructure informatique est devenue un élément critique de toute grande entreprise, dont la supervision représente un poste clé au sein de l'exécutif, celui de Chief Information Officer ou CIO.

Invoice Manager, un logiciel de facturation pour PME. (© Hillstone Software)

PCLine s.p.r.l., une société de vente de matériel et de service informatique locale de Louvain-la-Neuve, fait appel à vos services pour développer ses applications informatisées de facturation. Les gérants de PCLine disposent déjà d'un programme pour imprimer leurs factures et calculer la TVA et les totaux. Ils désirent développer également la livraison des articles et de pièces, en intégrant l'impression des bordereaux de livraison dans leur logiciel de facturation existant, sans devoir écrire complètement leur logiciel existant. Heureusement, leur logiciel étant écrit en Python dans un style orienté objets, leur consultant de l'UCLouvain leur a confirmé qu'il était possible de l'étendre sans le modifier au moyen des mécanismes d'héritage de Python. Ils ont donc confié aux étudiants de 1er Bac la tâche d'ébaucher la représentation des pièces en catalogue, leur intégration dans la facturation, ainsi que l'impression des bordereaux de livraison en plus de l'impression des factures.

2 Objectifs

A l'issue de cette mission, chacun d'entre vous :

pourra masquer les variables d'instance d'une classe et écrire des méthodes pour y accéder;
aura appris la notion de variable de classe et son utilité;

pourra expliquer en ses propre mots et illustrer par l'exemple les principes de l'héritage en Python:

* l'héritage d'une classe;
* la redéfinition de méthodes;
* l'utilisation de ``self`` et ``super()``;

sera capable d'utiliser l'héritage pour étendre un programme Python;

pourra utiliser les méthodes magiques comme

* ``__init__`` pour initialiser les objets d'une classe;
* ``__str__`` pour retourner une représentation textuelle d'un instance d'une classe;
* ``__eq__`` pour définir l'égalité entres objets d'une classe.

3 Préparation, étude et apprentissage

La matière relative à cette mission est décrite dans les sections suivantes de la partie Objects du syllabus en ligne:

ainsi que les annexes:

4 Questionnaire de démarrage

4.1 Questions à choix multiple

Les questions à choix multiples de cette mission sont accessibles en ligne depuis https://inginious.info.ucl.ac.be/course/LSINF1101-PYTHON/Session10_QCM

4.2 Questions ouvertes

4.2.1 Egalité

Considérez une classe Pair :

class Pair:

    def __init__(self, x, y):
        self.a = x
        self.b = y

    def __str__(self):
        return str(self.a) + ", " + str(self.b)

Maintenant considérez le code suivant :

p1 = Pair(9, 42)
p2 = Pair(9, 42);
print(p1 == p2)

La dernière instruction affichera False. (Pourquoi?)

Ajoutez une méthode __eq__(self, p) à la classe Pair qui compare la valeur de deux paires, de manière à ce que print(p1 == p2) imprimera True au lieu de False.

Dans l'implémentation de votre méthode pensez également à gérer le cas où p == None.

4.2.2 L'héritage

L'héritage est un principe de base de la programmation orientée objet. Considérons les classes A, B, C et D ci-dessous :

class A :

  def m1(self) :
      print("A 1")

  def m2(self) :
      print("A 2")

  def m3(self) :
      self.m1()   # appel à la méthode m1 sur la même instance

  def nom(self) :
      return "A"

class B(A) :

  def m2(self):
      print("B 2")

class C(A):

    def m1(self) :
        print("C 1")

    def nom(self):
        return "C"

class D(C) :

    def m2(self) :
        print("D 2")

Considérant ces quatre classes, on vous demande de :

Expliquez ce que représente le mot self dans la définition de ces différentes méthodes.

Dessiner un diagramme reprenant ces quatre classes.

Expliquer ce qui sera affiché lors de l'exécution des instructions Python ci-dessous :

a = A()
print(a.nom())
a.m1()
a.m2()
a.m3()
b = B()
print(b.nom())
b.m1()
b.m2()
b.m3()
c = C()
print(c.nom())
c.m1()
c.m2()
c.m3()
d = D()
print(d.nom())
d.m1()
d.m2()
d.m3()

4.2.3 C'est super !

Expliquez le rôle de la fonction spécial super() dans le langage Python. Donnez un exemple.

Considérons les classes E et F ci-dessous :

class E :

    def m(self) :
        print("E 1")

    def n(self) :
        print("E 2")

    def p(self) :
        self.n()   # appel à la méthode n sur la même instance

class F(E) :

   def q(self) :
       print("F 1")

   def n(self) :
       super().n() # appeler la méthode définie sur la classe mère
       print("F 2")

   def r(self) :
        self.m() # appel à la méthode m sur la même instance

Expliquer ce qui sera affiché lors de l'exécution des instructions Python suivantes :

f = F()
f.q()
f.m()
f.r()
f.n()
f.p()

4.2.4 Rectangle

Considérons la classe Figure reprise ci-dessous :

class Figure:

    def __init__(self,x,y,visible=False) :
        """
        @pre x, y sont des entiers représentant des positions sur l'écran
        @post Une figure a été créée avec centre de gravité aux coordonnées x,y.
              Cette figure n'est initialement pas visible.
        """
        self.x = x
        self.y = y
        self.__visible = visible

    def est_visible(self) :
        """
        @pre -
        @post a retourné la visibilité de cette figure
        """
        return self.__visible

    def surface(self) :
        """
        @pre -
        @post la surface (un float) de la figure a été calculé et retournée
        """
        pass            # code non fourni

Cette classe Figure est la classe mère d'un ensemble de classes permettant de représenter des figures géométriques. Chaque figure géométrique est placée à une position (x,y) (centre de gravité) sur l'écran et la classe contient des variables d'instance et des méthodes permettant de manipuler cette figure géométrique (notamment des méthodes permettant d'afficher la figure à l'écran, mais ces méthodes ne sont pas reprises dans les extraits présentés dans cet exercice). Parmi ces figures géométriques, on trouve notamment la classe Rectangle qui hérite de la classe Figure et dont un fragment est repris ci-dessous :

class Rectangle(Figure):

    def __init__(self,longueur,largeur,x,y) :
        """
        @pre longueur et largeur sont des entiers positifs
             x, y sont des entiers représentant des positions sur l'écran
        @post un rectangle dont le centre de gravite est en x,y
              et ayant comme longueur lo et comme largeur la a été créé
        """
        super().__init__(x,y)
        self.longueur = longueur
        self.largeur = largeur

    def __str__(self) :
        return str((self.longueur,self.largeur,self.x,self.y,self.est_visible()))

>>> r = Rectangle(10,20,0,0)
>>> print(r)
(10, 20, 0, 0, False)

Maintenant expliquez :

Quelles sont les variables d'instance qu'une instance de la classe Rectangle peut utiliser ?
Que se passe-t il lorsqu'une instance r de la classe Rectangle est créé?
Que fait l'appel à super() dans la méthode __init__ de la classe Rectangle ?
Que se passe-t il si on met cet appel à super() comme dernière instruction dans la méthode __init__ de la classe Rectangle ?

Dans la classe Rectangle, faut-il redéfinir les méthodes suivantes (si oui, écrivez le code de la nouvelle méthode - si non, expliquez pourquoi ):

surface()

est_visible()

4.2.5 Variables privés

4.2.6 Carré

Comment feriez-vous maintenant pour définir une classe Carre qui étend la classe Rectangle et permet de représenter un carré ?

Ecrivez la méthode d'initialisation de la classe Carre (un carré se construit en indiquant les coordonnées de son centre de gravité et la longueur de son côté)

Quelles sont les méthodes que vous devez redéfinir dans la classe "Carre" ?

Soient deux classes Circle et Ellipse. Quelles relations peut-on envisager entre ces deux classes ?

Ecrivez une méthode perimetre() de la classe Rectangle qui retourne le périmètre du rectangle.

Que faudrait-il faire pour avoir une méthode perimetre de la classe Carre?

4.2.7 Similitude

Définissez une méthode __eq__ pour la classe Figure, telle que deux figures sont égales si leur surface est égale.

Que se passe-t il si on veut comparer deux rectangles ayant la même surface? Par exemple:

>>> r1 = Rectangle(10,40,0,0)
>>> r2 = Rectangle(2,200,0,0)
>>> r1 == r2

Que se passe-t il si on veut comparer un rectangle avec un carré ayant la même surface? Par exemple:

>>> r = Rectangle(10,40,0,0)
>>> c = Carre(20,0,0)
>>> print(r == c)

4.2.8 Variable de classe

Et voici finalement une dernière question pour illustrer l'utilisation d'une variable de classe.

Complétez la classe Ticket ci-dessous:

"""
Un ticket de parking
"""
class Ticket :

    __prochain_numero = 1  # variable de classe pour générer le numéro du ticket

    def __init__(self) :
        """
        @pre  -
        @post Crée un ticket avec un nouveau numéro.
              Les numéros sont attribués séquentiellement à partir de 1.
        """
            # A COMPLETER

    def numero(self):
        """
        @pre  -
        @post retourne le numero de billet
        """
        return self.__numero

Mission 9 : Héritage

1 Description

Pour cette mission, vous disposez au départ d'un programme simple mission9.py permettant d'imprimer des factures. Ce programme comporte principalement deux classes:

l'une représente un Article, c'est-à-dire une ligne dans la facture (correspondant à l'achat d'un article comme un laptop, ou les frais pour une service comme l'installation d'un réseau wifi);
l'autre représente une Facture sous forme d'une liste d'articles (ou de services) et offre des méthodes permettant de l'imprimer.

Un fichier de test initiale test.py est également fournie. Exécuter ce fichier test produira l'exemple de facture suivant:

Facture PC Store - 22 novembre
===================================================================================
| Description                              |  prix HTVA |        TVA |  prix TVAC |
===================================================================================
| laptop 15" 8GB RAM                       |     743.79 |     156.20 |     899.99 |
| installation windows                     |      66.11 |      13.88 |      79.99 |
| installation wifi                        |      45.22 |       9.50 |      54.72 |
| carte graphique                          |     119.49 |      25.09 |     144.58 |
===================================================================================
| T O T A L                                |     974.61 |     204.67 |    1179.28 |
===================================================================================

Partant de ce code déjà fonctionnel, l'objectif principal de cette mission est de développer des classes qui héritent de la classe Article , en offrant des fonctionnalités supplémentaires tout en restant utilisables par la classe Facture . Dans un deuxième temps, vous ajouterez aussi une méthode à la classe Facture qui exploite ces nouvelles fonctionnalités.

Votre programme final devrait être capable de calculer et générer des factures plus complets comme

Facture No 1 : Facture PC Store - 22 novembre
===================================================================================
| Description                              |  prix HTVA |        TVA |  prix TVAC |
===================================================================================
| laptop 15" 8GB RAM                       |     743.79 |     156.20 |     899.99 |
| installation windows                     |      66.11 |      13.88 |      79.99 |
| installation wifi                        |      45.22 |       9.50 |      54.72 |
| carte graphique                          |     119.49 |      25.09 |     144.58 |
| Réparation (0.75 heures)                 |      46.25 |       9.71 |      55.96 |
| 1 * disque dur 350 GB @ 49.99            |      49.99 |      10.50 |      60.49 |
| 3 * souris bluetooth @ 15.99             |      47.97 |      10.07 |      58.04 |
| 5 * adaptateur DVI - VGA @ 12.00         |      60.00 |      12.60 |      72.60 |
| 2 * Java in a Nutshell @ 24.00           |      48.00 |       2.88 |      50.88 |
| 5 * souris bluetooth @ 15.99             |      79.95 |      16.79 |      96.74 |
===================================================================================
| T O T A L                                |    1306.77 |     267.22 |    1573.99 |
===================================================================================

et des bordereaux de livraison tels que celui-ci

Livraison - Facture No 1 : PC Store - 22 novembre
===================================================================================
| Description                              |  poids/pce |     nombre |      poids |
===================================================================================
| disque dur 350 GB @ 49.99 (!)            |    0.355kg |          1 |    0.355kg |
| souris bluetooth @ 15.99                 |    0.176kg |          3 |    0.528kg |
| adaptateur DVI - VGA @ 12.00             |    0.000kg |          5 |    0.000kg |
| Java in a Nutshell @ 24.00               |    0.321kg |          2 |    0.642kg |
| souris bluetooth @ 15.99                 |    0.176kg |          5 |    0.880kg |
===================================================================================
| 5 articles                               |            |         16 |    2.405kg |
===================================================================================
 (!) *** livraison fragile ***

2 Etapes

Voici les étapes à suivre.

2.1 Fichiers

Chargez les fichiers mission9.py et test.py et étudiez leurs contenus. Vous disposez des classes et fonctions suivants:

Article : cette classe représente un article de la facture. Elle contient une description et un prix et offre des méthodes permettant d'obtenir ces données et de calculer le prix de l'article avec TVA. Analysez attentivement le code de cette classe. Remarquez comment les différentes méthodes font appel à la méthode prix() . Ceci est important quand on hérite de cette classe: en redéfinissant la méthode prix() on modifiera aussi indirectement les autres méthodes qui y font appel.
Facture : cette classe représente une facture. Elle contient une liste d'articles. Elle offre principalement une méthode __str__ qui retourne un string détaillé représentant la facture, qui peut être imprimé avec la méthode print(), ainsi que plusieurs méthodes auxiliaires utilisées par cette méthode __str__.
test_articles(l) : une fonction de test de la classe Article qui imprime une liste d'articles l.
test_facture(f) : une fonction de test de la classe Facture qui produit l'impression d'une facture reprise dans le premier exemple ci-dessus.

Vous devrez vous-mêmes créer au moins deux classes ArticleReparation et ArticlePiece qui héritent de la classe Article, une classe Piece (utilisée par la classe ArticlePiece), ainsi que deux méthodes supplémentaires dans Facture , selon les instructions qui suivent.

2.2 La classe `ArticleReparation`

Au fichier mission9.py , ajoutez une nouvelle classe ArticleReparation qui hérite de la classe Article . Cette nouvelle classe représente une prestation de réparation de durée donnée (un float, en heures).
Définissez une méthode d'initialisation avec la durée en paramètre.
Re-définissez la méthode description() pour fournir un descriptif adéquat comme Reparation (0.75 heures).
Re-définissez la méthode prix() pour calculer un coût fixe de 20 euro plus un coût variable de 35 euro/h. Pour une réparation de 0.75 heures ça donne donc un coût de 20 + 35*0.75 = 46.25 euro HTVA.

Dans le fichier test.py , ajoutez des tests pour tester cette nouvelle classe et son utilisation dans une facture. Par exemple, vérifiez que la ligne correspondant à une réparation soit affiché comme:

Facture PC Store - 22 novembre
===================================================================================
| Description                              |  prix HTVA |        TVA |  prix TVAC |
===================================================================================
| ...                                                                             |
| Réparation (0.75 heures)                 |      46.25 |       9.71 |      55.96 |
===================================================================================
| T O T A L                                |    1020.86 |     214.38 |    1235.24 |
===================================================================================

2.3 Les classes `ArticlePiece` et `Piece`

Créez une nouvelle classe ArticlePiece qui hérite de Article et qui représente l'achat pas d'un seul article mais d'un nombre donné d'une pièce donnée. (Par exemple, 3 souris Bluetooth à 15.99 EUR par pièce.)

Implémentez d'abord une nouvelle classe Piece qui représente la pièce dont on veut facturer plusieurs exemplaires. Elle comporte les données suivantes:

- une description (string), p.ex. 'souris bluetooth';
- un prix unitaire (float), p.ex. 15.99 Euro;

et, optionnellement

- un poids unitaire en kg (float), p.ex. 0,154 kg;
- un indicateur booléen indiquant si la pièce est fragile, p.ex. un disque dur est fragile mais pas une souris;
- un indicateur booléen indiquant si la pièce est à taux de TVA réduit, p.ex. les livres bénéficient de TVA réduite.

Ajoutez une méthode d'initialisation permettant d'initialiser toutes ces données. Cette méthode d'initialisation doit aussi être utilisable avec seulement les deux paramètres obligatoires (description et prix) pour les pièces de poids négligeable, non fragiles et à taux de TVA normal (en assignant des valeurs par défaut pour les autres paramètres dans ce cas).
Ajoutez des méthodes accèsseurs (description() , prix() , poids() , fragile() , tva_reduit()) pour toutes ces données.
Ajoutez une méthode magique __eq__ afin que deux pièces sont considérées égales ( == ) si elles ont la même description et le même prix (les autres données sont ignorées pour la comparaison).

Ensuite implémentez la classe ArticlePiece qui hérite de Article

Ajoutez une méthode d'initialisation prenant le nombre et la pièce en paramètres.
Ajoutez des méthodes accèsseurs pour ces deux attributs.
Re-définissez la méthode description() pour fournir un texte reprenant la description de la pièce, le nombre souhaité de cette pièce et son prix unitaire, par exemple: 3 * souris bluetooth @ 15.99 .
Re-définissez la méthode prix() pour faire le produit du prix unitaire de la pièce par le nombre de pièces souhaité.
Re-définissez la méthode taux_tva() pour appliquer un taux de 6% aux pièces à taux de TVA réduit, tout en gardant le taux de TVA original pour d'autres pièces.

Finalement, dans le fichier test.py , ajoutez des tests pour tester ces nouvelles classes et leur utilisation dans une facture. Par exemple, vérifiez que les lignes correspondant aux articles pièces soient affichés comme:

Facture PC Store - 22 novembre
===================================================================================
| Description                              |  prix HTVA |        TVA |  prix TVAC |
===================================================================================
| ...                                                                             |
| 3 * souris bluetooth @ 15.99             |      47.97 |      10.07 |      58.04 |
| 2 * Java in a Nutshell @ 24.00           |      48.00 |       2.88 |      50.88 |
| ...                                                                             |
===================================================================================
| T O T A L                                |    1306.77 |     267.22 |    1573.99 |
===================================================================================

2.4 Numérotation des factures

Modifiez la classe Facture pour que chaque nouvelle facture reçoive un numéro séquentiel unique, qui apparait dans l'en-tête de la facture.

2.5 Compter le nombre de pièces

Dans la classe Facture, ajoutez une méthode def nombre(self,pce) qui retourne le nombre d'exemplaires d'une Piece pce dans la facture, en totalisant sur tous les articles qui concernent cette pièce. (Vous pouvez utiliser le fait que le comparateur ``==`` a été redéfinie dans la classe ``Piece`` (via la méthode magique ``__eq__`` que vous avez ajoutée).)

2.6 Bordereau de livraison

Dans la classe Facture, ajoutez une méthode print_livraison() qui imprime un bordereau de livraison comme

Livraison - Facture No 1 : PC store 22 octobre
===================================================================================
| Description                              |  poids/pce |     nombre |      poids |
===================================================================================
| disque dur 350 GB (!)                    |    0.355kg |          1 |    0.355kg |
| souris bluetooth                         |    0.176kg |          3 |    0.528kg |
| adaptateur DVI - VGA                     |    0.000kg |          5 |    0.000kg |
| Java in a Nutshell                       |    0.321kg |          2 |    0.642kg |
| souris bluetooth                         |    0.176kg |          5 |    0.880kg |
===================================================================================
| 5 articles                               |            |         16 |    2.405kg |
===================================================================================
 (!) *** livraison fragile ***

Ce bordereau:

imprime une en-tête avec la description de la facture;
imprime toutes les pièces dans la facture avec, pour chacune, sa description, son poids unitaire, le nombre facturé et le poids correspondant;
ajoute une marque (!) dans la description des pièces fragiles;
totalise et imprime à la fin le nombre d'articles, le nombre de pièces et le poids total;
imprime un message supplémentaire (!) *** livraison fragile *** si (et seulement si) la livraison contient une ou plusieurs pièces fragiles.

Remarquez que les détails imprimés dans ce bordereau de livraison ne concernent que les articles de type ArticlePiece; les autres articles sont ignorés. Pour faciliter le formatage du texte, vous pouvez utiliser la méthode format, déjà utilisée à plusieurs endroits dans la classe Facture. Si vous ne la connaissez pas, n'hésitez pas à chercher en-ligne comment cette méthode format fonctionne exactement. Pour implémenter la méthode print_livraison() , réutiliser un maximum de méthodes déjà existantes de la classe Facture .

Finalement, modifiez le fichier test.py pour tester votre nouvelle méthode. En particulier, vérifiez qu'un bordereau de livraison soit affiché comme:

Livraison - Facture No 1 : PC Store - 22 novembre
===================================================================================
| Description                              |  poids/pce |     nombre |      poids |
===================================================================================
| disque dur 350 GB @ 49.99 (!)            |    0.355kg |          1 |    0.355kg |
| souris bluetooth @ 15.99                 |    0.176kg |          3 |    0.528kg |
| adaptateur DVI - VGA @ 12.00             |    0.000kg |          5 |    0.000kg |
| Java in a Nutshell @ 24.00               |    0.321kg |          2 |    0.642kg |
| souris bluetooth @ 15.99                 |    0.176kg |          5 |    0.880kg |
===================================================================================
| 5 articles                               |            |         16 |    2.405kg |
===================================================================================
 (!) *** livraison fragile ***

3 Diagramme de classes

Le diagramme de classes suivant résume les différentes classes et méthodes à implémenter lors de cette mission :

/syllabus/info1-exercises/assets/class_diagram_mission9.png

4 Remise de votre solution

Pour cette mission, vous devez soumettre toutes les classes de votre programme dans un seul fichier mission9.py, vos classes tests dans un fichier test.py, ainsi que votre fichier README.txt qui décrit comment on peut tester votre code.

Votre fichier mission9.py doit contenir les classes Facture, Article, ArticleReparation, ArticlePiece et Piece.

Votre fichier test.py doit contenir des tests pour chacune des classes et étappes de cette mission, ainsi qu'une série d'instructions à la fin pour lancer tous les tests automatiquement lors de l'exécution du fichier.

L'exécution de votre programme mission9.py doit imprimer une facture et un bon de livraison comme illustré plus haut dans ce document.

5 Challenge

Il est possible d'ajouter de multiples variantes d'article à ce programme. Par exemple:

étendre ArticlePiece en ArticlePieceGros qui applique une dégression sur les prix en fonction du nombre commandé;
ajouter une extension d'Article qui fait référence à une configuration de PC et calcule le prix correspondant (taille mémoire, CPU, écran, capacité disque, etc);
étendre ArticleReparation en ArticleReparationUrgente avec des tarifs plus élevés;
ajouter une extension d'Article pour des frais de déplacement;
...

On peut également ajouter des calculs supplémentaires sur les factures, par exemple un bilan des frais de main d'oeuvre. Un peu plus difficile, modifier la méthode printLivraison() de la classe Facture pour n'imprimer qu'une seule ligne par pièce qui cumule les articles correspondants, comme dans la méthode nombre() .

Questions complémentaires

1 Variables d'instance

Quelqu'un a programmé une classe Compte représentant un compte bancaire avec 2 attributs privés __titulaire (représentant le titulaire du compte) et __solde (représentant le montant sur le compte, initialement zéro) et 1 attribut publique représentant la banque du compte.

class Compte :

    def __init__(self, banque, titulaire, solde = 0) :
        self.banque = banque
        self.__titulaire = titulaire
        self.__solde = solde

    def banque(self) :
        return self.banque

    def titulaire(self):
        return self.__titulaire

    def solde(self):
        return self.__solde

    def __str__(self) :
        return "Banque: " + self.banque() \
           + " Compte: " + self.titulaire() \
           + " Solde: " + str(self.solde())

a = Compte("ShittyBank","Kim")
print(a)

Malheureusement, quand on exécute l'instruction print(a), une erreur se produit:

Traceback (most recent call last):
  > print(a)
  > print(self.banque())
  > TypeError: 'str' object is not callable

Quel est le problème? Pouvez-vous corriger le code?

2 Variable de classe

Table des matières

Mission 10 - Polymorphisme

Phase de démarrage

Phase de réalisation

Questions complémentaires

Mission 10

1 Introduction

1.1 Objectifs

Dans cette mission, vous allez approfondir votre compréhension de concepts importants de la programmation orientée objets déjà abordés dans les deux missions précédentes, ainsi que quelques nouveaux concepts :

les classes, objets, variables et méthodes d'instance ;
les variables et méthodes de classe ;
les variables et méthodes privés, les méthodes accesseurs et mutateurs ;
la portée des variables d'instance ;
l'héritage, la redéfinition et l'écrasement de méthodes, le polymorphisme ;
la liaison dynamique et les subtilités de la sémantique de self et super().

Vous apprendrez également à écrire des tests unitaires pour vos programmes orientés objets.

1.2 Préparation, étude et apprentissage

Si vous n'avez pas encore eu le temps de relire en détail les différents chapitres de la partie Objects du syllabus en ligne, maintenant est venu le moment de rattraper votre retard. Le syllabus explique bien différents concepts, sur un autre exemple que les exemples utilisés dans le cours magistral :

On vous conseille également de tester et de jouer avec les différents exemples de code qui se trouvent dans les annexes suivantes, venant soit du syllabus en ligne soit correspondant aux exemples du cours magistral :

Dans cette mission, vous devrez également utiliser le framework unittest pour produire des classes de test. En préparation de cette mission, consultez donc la documentation de ce cadre de test, et essayez de faire quelques classes test simple en utilisant cet approche. Un bon tutoriel couvrant, entre autres, les tests unitaires avec unittest se trouve ici .

2 Questionnaire de démarrage

2.1 Questions à choix multiple

Les questions à choix multiples de cette mission sont accessibles en ligne depuis https://inginious.info.ucl.ac.be/course/LSINF1101-PYTHON/Session10_2019_QCM

2.2 Questions ouvertes

2.2.1 Vocabulaire

On vous donne le code suivant qui teste certaines fonctionnalités du module random.

import unittest
import random

class RandomTest(unittest.TestCase):
    """Classe de tests utilisée pour tester les fonctions du module 'random'"""

    def setUp(self):
        """Initialisation des tests."""
        self.l = list(range(10))

    def test_choice(self):
        """Test de fonctionnement de la fonction random.choice"""
        e = random.choice(self.l)
        # Vérifie que 'e' est dans 'l'
        self.assertIn(e,self.l)

    def test_shuffle(self):
        """Test le fonctionnement de la fonction random.shuffle"""
        random.shuffle(self.l)
        self.l.sort()
        self.assertEqual(self.l, list(range(10)))

    def test_sample(self):
        """Test le fonctionnement de la fonction random.sample"""
        extrait = random.sample(self.l, 5)
        for element in extrait:
            self.assertIn(element,self.l)
        self.assertRaises(ValueError, random.sample, self.l, 20)

# Pour lancer automatique ces tests quand on exécute ce fichier
if __name__ == '__main__':
    unittest.main()

Considérant cette classe, on vous demande de :

Expliquez cet extrait de code

if __name__ == '__main__':
    unittest.main()

Expliquez le rôle de import unittest et pourquoi c'est indispensable.

Expliquez cette ligne class RandomTest(unittest.TestCase): et pourquoi c'est indispensable.

Sur base du contenu du cours ou en lisant https://docs.python.org/3/library/unittest.html pour plus d'information, expliquez ce que font ces méthodes :

def setUp(self)

self.assertEqual()

self.assertIn()

self.assertRaises()

2.2.2 Tests unitaires

Implémentez une classe de tests unitaires MyClassTest qui hérite de unittest.TestCase qui teste la fonction carre_parfait du module totest. (En mathématiques, un carré parfait est le carré d'un entier.)

Soit la fonction carre_parfait du module totest ayant pour spécifications :

def carre_parfait (x) :
    '''
    retourne true si l'entier en argument est un carré parfait, false sinon
    '''
# CODE NON FOURNI

Complétez la classe de test ci-dessous :

import totest
import unittest

class MyClassTest(unittest.TestCase) :

    # todo

if __name__ == '__main__':
    unittest.main()

Ecrivez au moins trois tests unitaires pour vérifier l'implémentation de cette fonction

Que donnent-vos tests unitaires pour les implémentations suivantes :

```
def carre_parfait (x) :
   return True
```

def carre_parfait (x) :
    return False

def carre_parfait (x) :
    cur = 0
    while not cur*cur == x :
        cur += 1
    return True

import math
def carre_parfait (x) :
    root = math.sqrt(x)
    return root.is_integer()

import math
def carre_parfait (x) :
    if x < 0 : return False
    root = math.sqrt(x)
    return root.is_integer()

2.2.3 Centre d'expédition d'Amazon

Mission 10

1 Description

L'objectif de cette mission est de créer des robots virtuels maintenant un état représentant leur position à l'écran et des opérations permettant de les faire bouger sur l'écran. On peut se baser sur plusieurs bibliothèques graphiques pour implémenter de tels robots. Cette mission vise à illustrer que, grace au polymorphisme, il devient relativement facile de remplacer une telle bibliothèque par une autre sans devoir modifier beaucoup de code.

On vous fournira une première implémentation basé sur la bibliothèque graphics.py de Python. A vous de proposer une implémentation alternative en utilisant la bibliothèque turtle. Ces deux types de robots sont polymorphe: ils comprennent exactement les mêmes messages, mais l'un est implémenté avec des positions absolues sur un plan XY, tandis que l'autre utilise des positions relatives.

Ensuite on vous demandera d'étendre davantage la fonctionnalité de ces robots, ce qui vous permettra de découvrir la puissance du concept de l'héritage pour la réutilisation du code.

Il sera aussi important de bien tester à la fois les classes qui vous sont fournies et que vous implémenterez, avec des tests unitaires. C'est-à-dire que vous créerez, par classe à tester, une classe test correspondante, avec des méthodes tests pour chacune des méthodes de la classe à tester. Ceci vous permet de tester, à une granularité fine, les différents unités (les classes et les méthodes) de votre code orienté objet.

Les différents concepts traités dans cette mission seront, entre autres : le polymorphisme, la composition, la délégation, l'héritage, la duplication et la réutilisation de code, la substitutabilité, l'utilisation de self et de super(), et les tests unitaires. Vous travaillerez par groupes de deux.

2 Etapes

2.1 Avant de commencer...

Avant de commencer, installez le package graphics.py permettant de dessiner des figures simples dans une fenêtre graphique. Ce package sera utilisée par la classe XYRobot. Vous pouvez installer ce package facilement depuis Thonny en suivant les étapes suivantes: (1) Sélectionner le menu Tools > Manage Packages... en Thonny; (2) taper graphics.py dans le champs de recherche pour retrouver le bon package et appuyez sur Install . (On a besoin du package graphics.py développé par John Zelles pour utilisation avec son livre Python Programming: An Introduction to Computer Science. La documentation pour ce package se trouve ici .)

2.2 La classe `XYRobot`

La classe XYRobot vous est fournie dans le fichier XYRobot.py sur le site inginious où vous pouvez remettre votre solution. Analysez le code de cette classe attentivement. Elle :

Utilise le package graphics.py que vous avez installé dans l'étape prédédente.
Utilise des fonctions goniométriques comme cos et sin ainsi que la constante mathématique pi, fournies par le module math.
Représente un robot virtuel ayant un nom, une position (x, y), et une direction (angle). Quand il bouge, ce robot dessine ses mouvements dans une fenêtre représentant un plan XY.
En plus des méthodes habituelles __init__ et __str__ ainsi que des méthodes accesseurs et mutateurs, cette classe implémente des méthodes comme:
- move_forward(distance) : fait avancer le robot de distance pixels et trace une ligne lors de ce mouvement
- move_backward(distance) : fait reculer le robot de distance pixels et trace une ligne lors de ce mouvement
- turn_left() : fait tourner le robot de 90 degrés vers la gauche (dans le sens contraire des aiguilles d'une montre)
- turn_right() : fait tourner le robot de 90 degrés vers la droite (dans le sens des aiguilles d'une montre)

Appeler ces méthodes fait bouger le robot et dessine des figures sur un plan XY. Il suffit d'exécuter le code fourni dans le fichier pour avoir un exemple concret. N'oubliez pas d'installer la bibliothèque graphics.py avant d'exécuter ce fichier.

2.3 Tester la classe `XYRobot`

Tandis que l'implémentation de la classe XYRobot vous est fournie, il manque une classe avec des tests unitaires afin de vérifier que le robot bouge et met à jour ses attributs correctement. L'objectif de cette étape sera donc de créer une classe test avec des tests unitaires pour la classe qui vous est fournie.

Implémentez cette classe de test TestXYRobot afin de vérifier le comportement correct des différentes méthodes de la classe XYRobot. Pour réaliser vos tests, il est important à savoir que le package ``graphics.py`` considère que le point avec position (x=0,y=0) se trouve dans le coin supérieur gauche de la fenêtre.

Position de l'origine et orientation du plan XY pour la bibilothèque ``graphics``

Par exemple, quand on crée un nouveau robot r2d2 = XYRobot("R2-D2") il se trouvera à la position (x=0,y=0) avec comme angle 0 (direction Est). Après avoir exécuté r2d2.move_forward(50) le robot devrait se trouver à la position (x=50, y=0), approximativement, à cause des arrondis dans les calculs. Ensuite, après avoir exécuté r2d2.turn_right() l'angle du robot sera 90° (approximativement), etc.

Soyez le plus complet possible dans vos tests. Mettez votre classe test TestXYRobot dans un fichier séparé TestXYRobot.py qui s'occupera de charger le fichier XYRobot.py et d'exécuter les différents tests sur la classe XYRobot.

2.4 La classe `TurtleBot`

Maintenant c'est à vous d'implémenter une classe TurtleBot qui est polymorphe avec la clase XYRobot de l'étape précédente. C'est-à-dire que, en plus des méthodes __init__ et __str__ et des méthodes accesseurs (dont angle() et position()) et mutateurs, elle doit implémenter les mêmes méthodes :

move_forward(distance) : fait avancer le robot de distance pixels et trace une ligne lors de ce mouvement

move_backward(distance) : fait reculer le robot de distance pixels et trace une ligne lors de ce mouvement

turn_left() : fait tourner le robot de 90 degrés vers la gauche (dans le sens contraire des aiguilles d'une montre)

turn_right() : fait tourner le robot de 90 degrés vers la droite (dans le sens des aiguilles d'une montre)

La différence majeure est que la classe TurtleBot fait ces dessins via un objet de type Turtle. Cette classe sera donc assez facile à implémenter en utilisant un objet de type Turtle comme attribut. Le travail d'avancer, tourner et dessiner pourra alors être délégué à cette tortue. Pour rappel, la classe Turtle du package turtle.py fournit des méthodes comme position, heading, forward, backward, right et left. (Voici la documentation pour ce package.)

Pour implémenter la classe ``TurtleBot`` et effectuer vos tests, il est important à savoir que dans la fenêtre graphique du turtle, la position (x=0,y=0) se trouve au milieu de la fenêtre, l'axe X pointe vers la droite et l'axe Y vers le haut.

Position de l'origine et orientation du plan XY pour la bibilothèque ``turtle``

2.5 Tester la classe `TurtleBot`

Pour tester le comportement correct de la classe TurtleBot, on vous fournit un fichier TestTurtleBot.py (ce fichier se trouve sur le site inginious où vous pouvez remettre votre solution.) Ce fichier test contient des tests unitaires pour votre classe TurtleBot qui doit se trouver dans un fichier TurtleBot.py.

Vous pouvez aussi vérifier que le comportement de votre robot est correct en vérifiant que ce qu'il dessine sur l'écran correspond à ce que vous attendez.

2.6 Etendre les classes `XYRobot` et `TurtleBot`

Maintenant, on veut étendre la fonctionnalité des robots. A vos deux classes XYRobot et TurtleBot , ajoutez des méthodes pour:

garder une trace des actions exécutées auparavant par ce robot;
rejouer ces actions à l'envers (c'est-à-dire de défaire ces actions).

Plus spécifiquement, il faut ajouter les deux méthodes suivantes:

history() : retourne l'historique des actions précédentes, comme une liste du style: [('forward', 50), ('left', 90), ('forward', 50), ...]

unplay() : rejouer les actions précédentes dans le sens inverse et vider l'historique après avoir rejoué ces actions.

Même si faire du copier-coller de code entre ces deux classes est encore permis pour cette exercice, dans l'étapes suivantes on utilisera l'héritage pour éviter ce copier-coller en ajoutant une classe mère avec le code commun entre ces deux classes.

2.7 Tester les classes `XYRobot` et `TurtleBot`

Ajouter aux deux classes de test TestXYRobot et TestTurtleBot les tests unitaires nécessaires pour tester si les deux classes XYRobot et TurtleBot, avec la fonctionnalité historique et la fonctionnalité pour défaire les actions, marchent correctement.

2.8 Restructurer les classes `XYRobot` et `TurtleBot`

Si vous n'avez pas encore utilisé l'héritage lors de l'étape précédente, il est fort probable que vous ayez créé des méthodes très similaires dans les deux classes XYRobot et TurtleBot. Ces deux classes représentent tous les deux un robot ayant une mémoire contenant les actions déjà effectuées ainsi qu'une méthode pour défaire ces actions. Une bonne manière d'éviter le code redondant (recopié/dupliqué dans les deux classes) est de le mettre dans un classe mère Robot commune à ces deux classes, et de déclarer XYRobot et TurtleBot comme des classes filles de cette classe. En particulier, la classe mère peut contenir tout le code pour retenir les actions effectuées et de les refaire dans le sens inverse.

Lors de cet étape on vous demande donc de :

Créer une nouvelle classe mère Robot qui doit se trouver dans un fichier Robot.py.
Réécrivez les classes XYRobot et TurtleBot comme sous-classes de Robot.
Bouger le code qui est commun entre les classes filles XYRobot et TurtleBot vers la classe mère Robot.

2.9 Retester les classes `XYRobot` et `TurtleBot`

Rejouez les tests unitaires TestXYRobot et TestTurtleBot de l'étape précédente sur la nouvelle version des classes XYRobot et TurtleBot qui héritent de leur nouvelle clases mère. Si tout va bien ces tests doivent toujours fonctionner. Si ce n'est pas le cas, adapter le code ou les tests où nécessaire.

3 Diagramme de classes

Le diagramme de classes suivant résume les différentes classes et méthodes à implémenter lors de cette mission :

/syllabus/info1-exercises/assets/class_diagram_mission10.png

4 Remise de votre solution

Un fichier Robot.py qui contient la classe mère Robot avec le code de gestion de l'historique.

(Si vous n'êtes pas arrivé à cette étape, remettez simplement un fichier vide ici.)
Un fichier XYRobot.py qui contient la classe XYRobot qui hérite de Robot.

(Si vous n'êtes pas arrivé à l'étape avec l'héritage de la classe Robot, remettez la version de votre classe XYRobot sans héritage ici.)
Un fichier TurtleBot.py qui contient la classe TurtleBot qui hérite de Robot.

(Si vous n'êtes pas arrivé à l'étape avec l'héritage de la classe Robot, remettez la version de votre classe TurtleBot sans héritage ici.)
Un fichier TestXYRobot.py qui contient les tests unitaires pour votre classe XYRobot.

Ce fichier TestXYRobot.py doit charger le fichier XYRobot.py et exécuter les différents tests unitaires sur la classe XYRobot.
Un fichier TestTurtleBot.py qui contient les tests unitaires pour votre classe TurtleBot.

Ce fichier TestTurtleBot.py doit charger le fichier TurtleBot.py et exécuter les différents tests unitaires sur la classe TurtleBot.

Questions complémentaires

Héritage

Table des matières

Mission 11 - Listes chainées

Phase de démarrage

Phase de réalisation

Questions complémentaires

Mission 11 : Les listes chaînées

/syllabus/info1-exercises/assets/linkedtrain.jpg

1 Introduction

Le Service des sports fait appel à vous dans le cadre du développement d'un système informatique pour la gestion des résultats de la course des 24h Vélo de Louvain-la-Neuve. Vous devez réaliser un programme Python permettant d'encoder et de manipuler les différentes données nécessaires (coureurs, résultats, classements) pour tenir à jour les classements en cours de course. Par exemple, il faut pouvoir afficher en temps réel, sur des écrans disposés dans la ville et sur internet, le classement des meilleurs temps pour le tour du circuit.

Un classement par temps (Tour de France 2013)

Pour cette mission, vous allez devoir implémenter une classe Python permettant de manipuler un tel classement et de le mettre à jour avec de nouveaux résultats. Le classement doit être ordonné, et on ne désire pas refaire le tri pour chaque nouveau résultat: il faut donc une structure de liste ordonnée avec des opérations qui maintiennent cet ordre. Vous utiliserez pour cela une liste chaînée.

2 Objectifs

A l'issue de cette mission, chacun d'entre vous :

sera en mesure d'exploiter les listes chaînées ;
aura eu l'occasion d'écrire des tests unitaires pour ses programmes.

3 Préparation, étude et apprentissage

Comment bien préparer la mission?

Assister au cours et regarder les capsules vidéos pour comprendre les notions et concepts qui seront abordés.
Lire attentivement et comprendre le chapitre sur Linked lists dans la partie Objects du syllabus théorie :
- 7 - Linked lists
  Embedded references
  
  The Node class
  
  Linked lists as collections
  
  Linked lists and recursion
  
  Infinite lists
  
  Ambiguity between lists and nodes
  
  Modifying lists
  
  Wrappers and helpers
  
  The LinkedList class
Essayer et comprendre le code développé dans le syllabus et qui se trouve aussi dans l'annexe correspondant :
- Appendix - Source code of linked lists
  LinkedList class
  
  Node class
  
  Creating and using LinkedList objects
Dans cette mission, vous devrez de nouveau utiliser le framework unittest pour produire des classes de test. Relisez la documentation si vous aviez du mal à créer des tests unitaires lors de la mission précédente.
Répondre aux questions à choix multiples et aux autres questions de démarrage.

4 Questionnaire de démarrage

Ces questions supposent que vous avez lu le chapitre du syllabus théorique sur les listes chaînées et que vous avez lu et testé le code des classes LinkedList et Node dans l'annexe code des classes LinkedList et Node dans l'annexe correspondante.

4.1 Questions à choix multiples

Les questions à choix multiples de cette mission sont accessibles en ligne depuis https://inginious.info.ucl.ac.be/course/LSINF1101-PYTHON/Session11_QCM.

4.2 Questions ouvertes

4.2.1 Notions théoriques

Répondez aux questions suivantes:

Qu'est-ce qu'une liste chaînée?
Qu'est-ce qu'une structure de données? Donnez un exemple.
Expliquez la différence entre un noeud (Node) et sa cargaison (cargo).
Expliquez la différence entre un noeud (Node) et une liste chainée (LinkedList).
Dans le livre et le cours magistral, la notion d'une liste chaînée a d'abord été expliqué sans la classe LinkedList, simplement en chaînant des noeuds l'un à l'autre. Pourquoi avons nous alors besoin d'une classe LinkedList?
Expliquez et donnez un exemple du caractère ambiguë d'un noeud.

4.2.2 Utilisation d'une `LinkedList`

Question 1 : Manipuler une liste vide

Cette question concerne l'utilisation de la classe LinkedList dont le code se trouve dans l'annexe suivante du syllabus : Appendix - Source code of linked lists

Utilisez la classe LinkedList pour créer une liste chaînée vide l.

Donnez une instruction Python pour imprimer le contenu de cette liste l.

Quel résultat sera affiché si on essaie d'imprimer la liste l avec l'instruction print(l)? Expliquez.

Donnez une instruction Python pour imprimer la taille de cette liste l .

Quel résultat sera affiché si on essaie d'imprimer la taille avec l'instruction print(l.__length)? Expliquez.

Question 2 : Remplir la liste

Pour ajouter des éléments à une liste vide, quelqu'un a écrit les instructions suivantes:

l = LinkedList()
l.add(3)
l.add(2)
l.add(1)
l.print()

Mais quelqu'un d'autre à écrit:

l = LinkedList()
l.add(Node(3))
l.add(Node(2))
l.add(Node(1))
l.print()

Dans les deux cas, exécuter l'instruction l.print() affichera [ 1 2 3 ].

Lequel des deux fragments de code ci-dessus vous semble correct? Pourquoi l'autre imprime quand-même le même résulat?

Indice : qu'est-ce qui se passe si on exécute l'instruction print(Node(Node(Node(1))))? Pouvez-vous expliquer?

4.2.3 Imprimer une liste chaînée

Dans le code donné dans l'annexe Appendix - Source code of linked lists la méthode print() de la classe LinkedList imprime les éléments d'une liste chaînée, séparés par une espace. Par exemple:

>>> l = LinkedList()
>>> l.add(3)
>>> l.add(2)
>>> l.add(1)

>>> l.print()
[ 1 2 3 ]

Or, normalement la convention est de séparer les éléments d'une liste par des virgules. Ajoutez une nouvelle méthode print_avec_virgule() dans la classe LinkedList qui imprime la liste comme suite:

>>> l.print_avec_virgule()
[ 1, 2, 3 ]

Attention: il n'y a pas de virgule après le dernier élément ou si on imprime une liste vide.

>>> l = LinkedList()
>>> l.print_avec_virgule()
[ ]

4.2.4 Imprimer une liste chaînée (généralisation)

Généralisez la méthode print_avec_virgule de l'exercice précédente par une méthode print_avec_separateur qui peut prendre n'importe quelle séparateur. Par exemple:

>>> l = LinkedList()
>>> l.add(3)
>>> l.add(2)
>>> l.add(1)

>>> l.print_avec_separateur(", ")
[ 1, 2, 3 ]
>>> l.print_avec_separateur(" ")
[ 1 2 3 ]
>>> l.print_avec_separateur(" - ")
[ 1 - 2 - 3 ]

4.2.5 Initialiser une liste chaînée

4.2.6 Supprimer un élément

4.2.7 Ajouter un élément à la fin

Ajoutez à la classe LinkedList une méthode add_to_end(self, cargo) pour ajouter un noeud en queue de la liste. Ajoutez d'abord un nouvel attribut last dans la méthode d'initialisation pour garder une référence vers ce dernier élément. Changez ensuite la méthode add pour assigner cette référence lors de l'ajout du premier noeud, et la méthode remove pour remettre cette référence à None lorsque la liste est de nouveau vide. Implémentez ensuite la méthode add_to_end.

Étapes de l'ajout d'un noeud dans une liste chainée :

Créer un nouveau nœud (new_node) composé de la valeur à ajouter dans la liste.
Parcourir la structure pour identifier le nœud précédant l’emplacement où insérer new_node.
Pour ne pas perdre la référence vers le nœud suivant, faire pointer new_node.next vers le nœud qui suit le nœud courant .
Insérer new_node (cas général, attention aux cas particuliers), en faisant pointer le nœud courant vers new_node.
Mettre à jour les attributs de la classe le cas échéant (taille, tête de liste, etc.).

Pour plus de détails sur les étapes, allez voir le catalogue : Ajout d'un noeud dans une liste chainée .

4.2.8 Supprimer un élément à la fin

Est-ce facile d'implémenter une méthode remove_from_end(self, cargo) pour supprimer un élément de la queue d'une LinkedList? Expliquez en mots comment vous feriez.

4.2.9 Imbriquer une classe dans une autre

En Python il est possible d'imbriquer une classe dans une autre. Ceci peut être utile si une classe n'est utilise que par une seule autre classe. C'est le cas ici avec la classe Node. Ce n'est qu'une classe auxiliaire pour la classe LinkedList. Adaptez le code de votre classe LinkedList en imbriquant le code de la classe Node dedans. Il suffit d'indenter le code de la classe Node et de changer chaque référence à la classe Node à l'interieur de la classe LinkedList par self.Node.

Quels sont les avantages et désavantages d'imbriquer la classe Node dans la classe LinkedList?

4.2.10 Insérer un élément

Considérez qu'on désire utiliser la classe LinkedList pour stocker une liste de strings. On souhaite qu'elle soit en permanence en ordre alphabétique croissant.

Dessinez complètement une telle liste chainée contenant les trois strings "abc", "def" et "xyz".
```
 
 
 
 
 
 
 
 
```
Expliquez en français et dessinez les opérations à effectuer pour ajouter un Node contenant "aaa" dans cette liste.
```
 
 
 
 
 
 
 
 
```
Même question avec un Node contenant "ghi".
```
 
 
 
 
 
 
 
 
```
Même question avec un Node contenant "def".
```
 
 
 
 
 
 
 
 
```
Même question avec un Node contenant "zzz".
```
 
 
 
 
 
 
 
 
```

4.2.11 Tests unitaires

Lors de la mission précédente, les tests unitaires avec unittest ont été introduits. Créez un test unitaire pour tester la classe LinkedList. Ce test doit contenir des tests pour les différentes méthodes de la classe LinkedList comme size(), first() ou add(valeur) (code original), remove() (question 4.2.6), add_to_end(valeur) (question 4.2.7) ou insert(valeur) (question 4.2.10). Pour vous mettre sur le bon chemin, votre classe test aura la structure suivante:

import unittest

class LinkedListTest(unittest.TestCase):
    """Classe de test utilisé pour tester la classe LinkedList"""

    def test_size(self):
        """Test de la methode size() de la classe LinkedList."""
        # ... assert*(...) ...

    def test_first(self):
        """Test de la methode first() de la classe LinkedList."""
        # ... assert*(...) ...

    def test_add(self):
        """Test de la methode add(valeur) de la classe LinkedList."""
        # ... assert*(...) ...

    def test_remove(self):
        """Test de la methode remove() de la classe LinkedList."""
        # ... assert*(...) ...

    def test_add_to_end(self):
        """Test de la methode add_to_end(valeur) de la classe LinkedList."""
        # ... assert*(...) ...

    def test_insert(self):
        """Test de la methode insert(valeur) de la classe LinkedList."""
        # ... assert*(...) ...

if __name__ == '__main__':
    unittest.main()

Mission

1 Description

Lors de cette dernière mission, vous allez implémenter un classement de résultats de coureurs, chaque résultat représenté par un coureur (ayant un certain nom et âge) et le temps effectué par ce coureur. Ces résultats doivent être ordonnés selon leur temps dans une liste chaînée ordonnée. Le meilleur résultat (le coureur avec le meilleur temps) se trouve en tête de la liste. Le résultat du coureur le plus lent se trouve en queue de la liste.

Pour compléter cette mission vous trouverez sur INGInious déjà une grande partie du code nécessaire, sauf l'implémentation complète de la classe Classement que vous devez produire, ainsi que la classe OrderedLinkedList qu'elle doit utiliser. Vous devez également écrire des classes de test détaillées (ClassementTest et OrderedLinkedListTest) en utilisant le framework de test unittest, pour vérifier votre implémentation de la classe Classement.

Vous aurez accès à une implémentation assez complète d'une classe LinkedList sur laquelle vous pouvez vous baser, ou que pouvez étendre, pour implémenter la classe OrderedLinkedList. L'archive qu'on vous fournira contient également une implémentation primitive de la classe Classement à base d'un dictionnaire. Néanmoins, cette implémentation est encore incomplète (elle ne gère pas correctement la position des coureurs dans le classement). Vous devez la remplacer par votre implémentation. Elle permet toutefois au programme de fonctionner. Il suffit d'exécuter la méthode de classe main() de la classe Main dans le fichier main.py: le programme simulera à la console l'ajout d'un nouveau résultat aléatoire toute seconde.

2 Etapes

Avant de commencer lisez bien le code qui vous a été fourni afin que vous comprenez bien sa structure et son comportement.
Vous allez utiliser une liste chaînée ordonnée (OrderedLinkedList ) pour implémenter un tel classement de coureurs. Réfléchissez aux différentes opérations qu'on peut effectuer sur un classement et comment on devrait les implémenter en utilisant une liste chaînée ordonnée.
Avant de commencez à implémenter cette classe Classement, représentez la structure de votre classement comme liste chaînée ordonnée graphiquement, et montrez ce qu'il se passe lorsque, successivement:
- Vous créez un classement vide;
- Vous ajoutez un résultat pour le coureur A en tête de classement (méthode add);
- Vous ajoutez un résultat pour le coureur B en fin de classement (méthode add);
- Vous ajoutez un résultat pour le coureur C en milieu de classement (méthode add);
- Vous recherchez les résultats des coureurs A, B et C (méthode get);
- Vous recherchez les positions des coureurs A, B et C (méthode getPosition);
- Vous retirez le résultat du coureur B (méthode remove);
- Vous retirez le résultat du coureur A (méthode remove);
- Vous tentez de retirer le résultat d'un coureur D (méthode remove).
Implémentez la classe OrderedLinkedList dont vous aurez besoin pour implémenter votre classe Classement.
Implémentez une classe de test OrderedLinkedListTest pour tester le bon fonctionnement de votre classe OrderedLinkedList.

Sur base de notre implémentation incomplète de la classe Classement au moyen d'une dictionnaire, écrivez un squelette de votre classe Classement au moyen d'une liste chaînée ordonnée, qui remplacera la notre. Respectez bien les pré- et post-conditions des différentes méthodes de la classe :

class Classement :

    def __init__(self):
        """
        @pre: -
        @post: un classement vide de taille 0 a été créé
        """

    def size(self):
        """
        Méthode accesseur.
        Retourne la taille de ce classement.
        @pre:  -
        @post: Le nombre de résultats actuellement stockés dans ce classement a été retourné.
        """

    def add(self,r):
        """
        Ajoute un résultat r dans ce classement.
        @pre:  r est une instance de la classe Resultat
        @post: Le résultat r a été inséré selon l'ordre du classement.
               En cas d'ex-aequo, r est inséré après les autres résultats de même ordre.
        """

    def get(self,c):
        """
        Retourne le résultat d'un coureur donné.
        @pre c est un Coureur
        @post retourne le premier (meilleur) Resultat r du coureur c dans le
              classement. Retourne None si le coureur ne figure pas (encore)
              dans le classement.
        """

    def get_position(self,c):
        """
        Retourne la meilleure position d'un coureur dans ce classement.
        @pre c est un Coureur
        @post retourne un entier représentant la position du coureur c dans ce classement,
              à partir de 1 pour la tête de ce classement. Si le coureur figure plusieurs fois
              dans le classement, la première (meilleure) position est retournée.
              Retourne -1 si le coureur ne figure pas dans le classement.
        """

    def remove(self,c):
        """
        Retire un résultat du classement.
        @pre  c est un Coureur
        @post retire le premier (meilleur) résultat pour le coureur c du classement.
              c est comparé au sens de __eq__. Retourne c si un résultat a été retiré,
              of False si c n'est pas trouvé dans la liste.
        """

    def __str__(self):
        """
        Méthode magique
        Retourne une représentation string de cet objet.
        @pre:  -
        @post: Retourne une représentation de ce classement sous forme d'un string,
               avec une ligne par résultat.
        """

Ecrivez une classe de test ClassementTest, la plus complète possible permettant de vérifier le bon fonctionnement de votre implémentation de la classe Classement. Utilisez pour cela les méthodes comme assertEqual ou d'autres méthodes définies dans unittest.
Pensez à découper votre classe de test en plusieurs méthodes. Cela facilitera la visualisation des résultats des tests. Vous trouverez sur la tâche INGInious un exemple de classe de test CoureurTest pour la classe Coureur.
Justifiez vos tests dans le fichier README.TXT.
Remplacer votre classe Classement par celle qui vous est fourni et exécutez la méthode main() de la classe Main. Observez que vos classements sont correctement mis à jour. Félicitations!
N'oubliez pas de soumettre votre implémentation des classes OrderedLinkedList et Classement, vos classes de test OrderedLinkedListTest et ClassementTest et votre fichier README.TXT à votre tuteur.

3 Diagramme de classes

Le diagramme de classes suivant résume les différentes classes et attributs qui feront partie de votre solution finale :

/syllabus/info1-exercises/assets/class_diagram_mission11.png

4 Remise de votre solution

Pour cette mission, vous devez soumettre au serveur de soumissions de programmes du cours, vos classes OrderedLinkedList et Classement dans des fichier orderedlinkedlist.py et classement.py, vos classes test OrderedLinkedListTest et ClassementTest dans des fichiers orderedlinkedlisttest.py et classementtest.py, ainsi que votre fichier README.txt.

Questions complémentaires

1 Méthode `str` de la classe LinkedList

Ajoutez également une méthode test correspondante à votre classe test pour vérifier le bon comportement de la méthode __str__.

2 Méthode `remove_from_end` de la classe LinkedList

Ajoutez également une méthode test correspondante à votre classe test pour vérifier le bon comportement de la méthode remove_from_end.

3 Méthode `contains` de la classe `LinkedList`

Ajoutez une méthode contains(e) dans la classe LinkedList qui retourne True si la valeur e se trouve dans la liste et False autrement.

Ajoutez également une méthode test correspondante à votre classe test pour vérifier le bon comportement de la méthode contains(e). N'oubliez pas de prendre en compte différents cas comme:

* la liste est vide;
* la liste contient un seul élément égal à l'élément cherché;
* la liste contient un seul élément différente de l'élément cherché;
* la liste contient différents fois un même élément;
* la liste contient différents fois l'élément cherché.

4 Lost Children

5 Classe LinkedList

6 Turing Machine

7 Liste doublement chaînée

Adaptez le code de la classe LinkedList pour créer une classe DoubleLinkedList représentant une liste doublement chaînée. Pour chaque noeud, en plus d'avoir un lien vers le noeud suivant, on ajoute un lien vers le noeud précédent. Ceci permet de parcourir la liste dans les deux sens: avancer en suivant la référence vers le noeud suivant, ou reculer en suivant la référence vers le noeud précédent. Votre classe DoubleLinkedList doit au moins fournir les méthodes suivantes:

add(e) pour ajouter un élément e en tête de la liste;
add_to_end(e) pour ajouter un élément e en fin de la liste;
remove_at_start() pour supprimer l'élément en tête de la liste;
contains(e) pour vérifier si l'élément e se trouve dans la liste;
size() retourne la taille de la liste;
isEmpty() vérifie si la liste est actuellement vide.

Ecrivez également une classe test unitaire TestDoubleLinkedList pour vérifier le bon comportement des différentes méthodes de la classe DoubleLinkedList. Cette classe test doit contenir des tests pour les différentes méthodes de la classe DoubleLinkedList.

8 Méthode `remove` de la classe DoubleLinkedList

Au code de la liste doublement chaînée de la question complémentaire précédente, ajoutez une méthode remove(e) pour supprimer la première occurrence de e de la liste doublement chainée.

Ajoutez également une méthode test correspondante à votre classe test pour vérifier le bon comportement de la méthode remove.

Table des matières

Objects

Table des matières

Mission 8 - Classes et objets

Mission 8 : Classes et objets

1 Introduction

2 Objectifs

3 Préparation, étude et apprentissage

4 Questionnaire de démarrage

4.1 Questions à choix multiple

4.2 Questions ouvertes

4.2.1 Définitions

4.2.2 Classes et objets

4.2.3 Méthode de conversion de string

4.2.4 Création de classes

4.2.5 Une classe simple

4.2.6 Egalité

4.2.7 Une méthode simple

4.2.8 OrderedPair

Mission 8

1 Introduction

2 Etapes

2.1 Fichiers

2.2 La classe Duree

2.3 Tester la classe Duree

2.4 La classe Chanson

2.5 Tester la classe Chanson

2.6 La classe Album

2.7 Tester la classe Album

2.8 Le programme

2.9 Tester le programme

3 Diagramme de classes

4 Remise de votre solution

Questions complémentaires

1 SMS Store

2 Création d'objets depuis un fichier

3 Personne

Table des matières

Mission 9 - Héritage

Mission 9 : Héritage

1 Introduction

2 Objectifs

3 Préparation, étude et apprentissage

4 Questionnaire de démarrage

4.1 Questions à choix multiple

4.2 Questions ouvertes

4.2.1 Egalité

4.2.2 L'héritage

4.2.3 C'est super !

4.2.4 Rectangle

4.2.5 Variables privés

4.2.6 Carré

4.2.7 Similitude

4.2.8 Variable de classe

Mission 9 : Héritage

1 Description

2 Etapes

2.1 Fichiers

2.2 La classe ArticleReparation

2.3 Les classes ArticlePiece et Piece

2.4 Numérotation des factures

2.5 Compter le nombre de pièces

2.6 Bordereau de livraison

3 Diagramme de classes

4 Remise de votre solution

5 Challenge

Questions complémentaires

1 Variables d'instance

2 Variable de classe

Table des matières

Mission 10 - Polymorphisme

Mission 10

1 Introduction

1.1 Objectifs

1.2 Préparation, étude et apprentissage

2 Questionnaire de démarrage

2.1 Questions à choix multiple

2.2 Questions ouvertes

2.2.1 Vocabulaire

2.2.2 Tests unitaires

2.2 La classe `Duree`

2.3 Tester la classe `Duree`

2.4 La classe `Chanson`

2.5 Tester la classe `Chanson`

2.6 La classe `Album`

2.7 Tester la classe `Album`

2.2 La classe `ArticleReparation`

2.3 Les classes `ArticlePiece` et `Piece`

2.2 La classe `XYRobot`

2.3 Tester la classe `XYRobot`

2.4 La classe `TurtleBot`

2.5 Tester la classe `TurtleBot`

2.6 Etendre les classes `XYRobot` et `TurtleBot`

2.7 Tester les classes `XYRobot` et `TurtleBot`

2.8 Restructurer les classes `XYRobot` et `TurtleBot`

2.9 Retester les classes `XYRobot` et `TurtleBot`

4.2.2 Utilisation d'une `LinkedList`

1 Méthode `str` de la classe LinkedList

2 Méthode `remove_from_end` de la classe LinkedList

3 Méthode `contains` de la classe `LinkedList`

8 Méthode `remove` de la classe DoubleLinkedList