Université de Monastir Faculté des Sciences de Monastir Département d’informatique

Semestre 2 – 2022/2023

Classe : . . . . . . . . . 2ème année LGLSI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Matière : . . . . . . . . . TP Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Proposé par : . . . . . . . . .Haffar Nafaa et Hmida Imen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Héritage, Polymorphisme et Abstraction

Objectif pédagogique: Ce TP a pour but de familiariser les étudiants avec le concept d'héritage, de
polymorphisme et d’abstraction en python. Les étudiants apprendront comment créer des classes enfants qui
héritent des propriétés de la classe parent, ainsi que comment créer des interfaces qui définissent les
méthodes nécessaires pour implémenter certaines fonctionnalités.

Exercice 1 : Niveau de difficulté: Débutant

1. Taper et exécuter le code suivant afin de comprendre le fonctionnement des classes Animal, CanFly,
CanSwim, Dog et Duck. Expliquer pourquoi la méthode speak() est différente pour chaque classe
enfant.
Code Python :
class Animal:
def __init__(self, name):
[Link] = name

def speak(self):
print("L'animal fait un bruit.")

class CanFly:
def fly(self):
print("L'animal peut voler.")

class CanSwim:
def swim(self):
print("L'animal peut nager.")

class Dog(Animal):
def speak(self):
print("Le chien aboie.")

class Duck(Animal, CanFly, CanSwim):

def speak(self):
print("Le canard cancane.")

# Utilisation des classes

my_dog = Dog("Rex")
my_dog.speak() # Affiche "Le chien aboie."

my_duck = Duck("Donald")
my_duck.speak() # Affiche "Le canard cancane."
my_duck.fly() # Affiche "L'animal peut voler."
my_duck.swim() # Affiche "L'animal peut nager." 1
 2. Créer une nouvelle classe enfant nommée "Fish" qui hérite de la classe Animal et implémente la
méthode swim(). La méthode speak() doit afficher "Le poisson fait des bulles.".

3. Créer une interface nommée "CanWalk" qui définit une méthode walk(). Ensuite, demander aux
étudiants de modifier la classe Animal pour implémenter CanWalk et de modifier la méthode
speak() pour afficher "L'animal marche.".

4. Créer une nouvelle classe enfant nommée "Bird" qui hérite de la classe Animal et implémente la
méthode fly(). La méthode speak() doit afficher "L'oiseau chante.".

Exercice 2 : Niveau de difficulté: avancé

1. Les classes sont souvent utilisées pour modéliser des objets dans le monde réel. Nous pouvons
représenter les données sur une personne dans un programme par une classe Personne, contenant le
nom de la personne, son prénom, son numéro de téléphone, et son email. Une méthode __str__ peut
imprimer les données de la personne.

Exemples :
>>> flen = Personne('Ben Foulen, Flen, '12345678', " flen @[Link]")
>>> print(flen)
Ben Floulen, Flen -- Telephone: 12345678 -- Email: flen @[Link]

Travail à faire : Implémentez la classe Personne.

2. Un travailleur est une personne ayant un emploi. Dans un programme, un travailleur est
naturellement représenté comme une classe Travailleur dérivée de la classe Personne, parce qu’un
travailleur est une personne, c’est-à-dire, nous avons une relation est-un. La classe Travailleur étend
la classe Personne avec des données supplémentaires, par exemple le nom de l'entreprise, l'adresse
de l’entreprise et le numéro de téléphone du travail. La fonctionnalité d'impression (la méthode
spéciale __str__) doit être modifiée en conséquence.

Travail à faire : Mettre en œuvre cette classe Travailleur.

3. Un scientifique est un type spécial de travailleur. La classe Scientifique peut donc être dérivée de la
classe Travailleur. Ajouter des données sur la discipline scientifique (physique, chimie,
mathématiques, informatique, …). On peut aussi ajouter le type de scientifique : théorique,
expérimental ou informatique. La valeur d’un tel attribut de type ne doit pas être limitée à une seule
catégorie, car un scientifique peut être classé comme, par exemple, à la fois expérimental et
informatique (c’est-à-dire, vous pouvez représenter la valeur sous la forme d’une liste ou d’un
tuple).

Travail à faire : Mettre en œuvre la classe Scientifique.

4. Enfin, faites un programme principal de démonstration où vous Créer et imprimez des instances de
classes Personne, Travailleur et Scientifique. Imprimez le contenu des attributs de chaque instance.

Exercice 3 : Niveau de difficulté: avancé

Supposons que nous ayons différents types d'animaux, tels que des chats, des chiens, des oiseaux et des
serpents, qui ont chacun des caractéristiques et des comportements différents.

2
 1. Définisser une classe abstraite `Animal` qui a deux méthodes abstraites : `parler()` et `manger()`.
Ces méthodes ne sont pas implémentées dans la classe `Animal` car chaque type d'animal les
implémentera différemment.

2. Créer une sous-classe `Chien` de la classe `Animal` qui implémente les méthodes `parler()` et
`manger()` pour représenter les comportements d'un chien.

3. Créer une sous-classe `Chat` de la classe `Animal` qui implémente les méthodes `parler()` et
`manger()` pour représenter les comportements d'un chat.

4. Créer une sous-classe `Oiseau` de la classe `Animal` qui implémente les méthodes `parler()` et
`manger()` pour représenter les comportements d'un oiseau.

5. Créer une sous-classe `Serpent` de la classe `Animal` qui implémente les méthodes `parler()` et
`manger()` pour représenter les comportements d'un serpent.

6. Dans le programme principal, instancier au moins un objet de chaque sous-classe et appelez leurs
méthodes `parler()` et `manger()`.

Exercice 4 : Niveau de difficulté: avancé

Imaginons que nous devons créer une application de gestion de magasin capable de calculer le prix pour
différents types d'articles. Nous avons trois catégories d'articles : les livres, les vêtements et les jouets,
qui sont soumis à des règles de tarification distinctes. Les livres sont tarifés à 10 euros par unité, les
vêtements à 20 euros par unité plus 2 euros par taille, et les jouets à 5 euros par unité plus 1 euro par
tranche d'âge recommandé.

1. Créer une classe abstraite `Article` avec une méthode abstraite `calculer_prix()`.

2. Créer des sous-classes pour chaque type d'article : `Livre`, `Vetement` et `Jouet`. Chaque sous-
classe doit hériter de la classe `Article` et implémenter la méthode `calculer_prix()` selon les règles
de tarification spécifiques à chaque type d'article.

3. Tester votre application en créant des instances de chaque sous-classe et en appelant la méthode
`calculer_prix()` pour chacune d'elles. Vérifier que les prix sont correctement calculés selon les
règles de tarification spécifiques à chaque type d'article.

Exercice 5 : Niveau de difficulté: avancé

Supposons que nous voulions créer des classes pour représenter des nombres entiers, des nombres à
virgule flottante et des nombres complexes. Nous voulons que chaque classe ait une méthode pour
convertir le nombre en chaîne de caractères.

Votre tâche consiste à créer une interface appelée Conversion qui définit cette méthode. Vous devez
ensuite créer trois classes : Entier, Flottant et Complexe qui implémentent cette interface et qui ont une
méthode pour convertir chaque type de nombre en chaîne de caractères.

Dans votre programme principal, vous devez créer une instance de chaque classe et appeler sa méthode
de conversion pour afficher le nombre sous forme de chaîne de caractères. Vous devez également
surcharger l'opérateur + pour pouvoir ajouter des nombres de types différents (par exemple, un entier et
un flottant).

3
Exercice 6 : Niveau de difficulté: avancé
Vous êtes en charge de développer un jeu de simulation de ville qui comporte plusieurs types de
bâtiments : maisons, immeubles, magasins et usines. Chaque type de bâtiment a des propriétés
communes telles que l'adresse et la surface, ainsi que des propriétés spécifiques à leur type. Par
exemple, les maisons ont un nombre de chambres et une superficie de jardin, les immeubles ont un
nombre d'étages et un nombre d'appartements, les magasins ont un type de commerce et une superficie
de vitrine, et les usines ont un nombre d'employés et une capacité de production.

Pour cela, vous devez créer une classe abstraite appelée `Batiment` qui représente les propriétés
communes de tous les types de bâtiments. Ensuite, vous devez créer des sous-classes concrètes pour
chaque type de bâtiment qui héritent de la classe `Batiment`. Enfin, vous devez utiliser le
polymorphisme pour pouvoir manipuler tous les types de bâtiments de manière uniforme.

Etapes à suivre :

1. Créer une classe abstraite appelée `Batiment` qui contient les propriétés communes telles que
l'adresse et la surface. N'oubliez pas de définir la méthode abstraite `calculer_prix()`.

2. Créer des sous-classes pour chaque type de bâtiment, telles que `Maison`, `Immeuble`, `Magasin` et
`Usine`, qui héritent de la classe `Batiment`. Définissez les propriétés spécifiques de chaque type de
bâtiment dans leurs constructeurs respectifs.

3. Implémenter la méthode `calculer_prix()` pour chaque sous-classe. Chaque type de bâtiment aura
son propre calcul de prix basé sur ses propriétés spécifiques.

4. Utiliser le polymorphisme pour pouvoir manipuler tous les types de bâtiments de manière uniforme.
Par exemple, créez une liste de bâtiments et utilisez une boucle pour afficher les adresses et les prix
de chaque bâtiment.

5. Tester votre code en créant plusieurs instances de chaque type de bâtiment et en affichant leurs
propriétés et prix.