Cet exercice de programmation orientée objet (POO) a pour but de vous aider à apprendre et à pratiquer les concepts de la POO. Toutes les questions sont testées sur Python 3.
Python La programmation orientée objet (POO) est basée sur le concept d’« objets », qui peuvent contenir des données et du code : des données sous la forme de variables d’instance (souvent connues sous le nom d’attributs ou de propriétés), et du code, sous la forme de méthodes. En d’autres termes, la POO permet d’encapsuler des propriétés et des comportements connexes dans des objets individuels.
Exercice 1:
Écrire un programme pour créer un système simple de gestion des étudiants qui peut effectuer les opérations suivantes:
Accepter() – Cette méthode prend en compte les données de l’utilisateur telles que son nom, son numéro de matricule et ses notes pour deux matières différentes.
Display() – Cette méthode permet d’afficher les informations relatives à chaque étudiant.
Rechercher() – Cette méthode permet de rechercher un étudiant particulier dans la liste des étudiants. Cette méthode demande à l’utilisateur d’indiquer son numéro de matricule, puis effectue la recherche en fonction de ce numéro.
Delete() – Cette méthode permet de supprimer l’enregistrement d’un étudiant particulier dont le numéro de matricule correspond.
Update() – Cette méthode met à jour le numéro de matricule de l’étudiant. Cette méthode demande l’ancien et le nouveau numéro de matricule. Elle remplacera l’ancien numéro de matricule par le nouveau.
Solution:
# Créer la classe 'Etudiant'
class Etudiant:
# Constructeur
def __init__(self, nom, matricule, notes1, notes2):
self.nom = nom
self.matricule = matricule
self.notes1 = notes1
self.notes2 = notes2
# Fonction permettant de créer et d'ajouter un nouvel étudiant
def accepter(self, nom, matricule, notes1, notes2):
e = Etudiant(nom, matricule, notes1, notes2)
liste.append(e)
# Fonction permettant d'afficher les détails de l'étudiant
def display(self, e):
print("Nom : ", e.nom)
print("Matricule : ", e.matricule)
print("Notes1 : ", e.notes1)
print("Notes2 : ", e.notes2)
print("\n")
# Fonction de recherche
def rechercher(self, mat):
for i in range(liste.__len__()):
if(liste[i].matricule == mat):
return i
# Fonction de suppression
def delete(self, mat):
i = obj.rechercher(mat)
del liste[i]
# Fonction de mise à jour
def update(self, mat, No):
i = obj.rechercher(mat)
mat1 = No
liste[i].matricule = mat1
# Créer une liste pour ajouter des étudiants
liste = []
# un objet de la classe Etudiant
obj = Etudiant('', 0, 0, 0)
print("\nOpérations utilisées: ")
print("\n1.Accepter les détails de l'étudiant\n2.Afficher les détails de l'étudiant\n3.Rechercher les détails d'un étudiant\n4.Supprimer les détails de l'étudiant\n5.Mettre à jour les détails de l'étudiant\n6.Quitter")
# ch = int(input("Entrer un choix:"))
# if(ch == 1):
obj.accepter("Alex", 1, 98, 90)
obj.accepter("Bob", 2, 85, 45)
obj.accepter("Jean", 3, 70, 60)
# elif(ch == 2):
print("\n")
print("\nListe des étudiants\n")
for i in range(liste.__len__()):
obj.display(liste[i])
# elif(ch == 3):
print("\nÉtudiant trouvé:")
s = obj.rechercher(2)
obj.display(liste[s])
# elif(ch == 4):
obj.delete(2)
print(liste.__len__())
print("Liste après suppression:")
for i in range(liste.__len__()):
obj.display(liste[i])
# elif(ch == 5):
obj.update(3, 2)
print(liste.__len__())
print("Liste après mise à jour")
for i in range(liste.__len__()):
obj.display(liste[i])
# else:
print("Good Bye!")
Sortie:
Opérations utilisées:
1.Accepter les détails de l'étudiant
2.Afficher les détails de l'étudiant
3.Rechercher les détails d'un étudiant
4.Supprimer les détails de l'étudiant
5.Mettre à jour les détails de l'étudiant
6.Quitter
Liste des étudiants
Nom : Alex
Matricule : 1
Notes1 : 98
Notes2 : 90
Nom : Bob
Matricule : 2
Notes1 : 85
Notes2 : 45
Nom : Jean
Matricule : 3
Notes1 : 70
Notes2 : 60
Étudiant trouvé:
Nom : Bob
Matricule : 2
Notes1 : 85
Notes2 : 45
2
Liste après suppression:
Nom : Alex
Matricule : 1
Notes1 : 98
Notes2 : 90
Nom : Jean
Matricule : 3
Notes1 : 70
Notes2 : 60
2
Liste après mise à jour
Nom : Alex
Matricule : 1
Notes1 : 98
Notes2 : 90
Nom : Jean
Matricule : 2
Notes1 : 70
Notes2 : 60
Good Bye!
Exercice 2:
Écrire une classe nommée Rectangle qui comprend deux variables ‘x’ et ‘y’ et une méthode appelée calc_surface() qui renvoie la surface du rectangle.
Solution:
# Créer une classe nommée Rectangle
class Rectangle:
# Constructeur
def __init__ (self,x=0,y=0):
self.x=x
self.y=y
# Fonction pour calculer la surface du rectangle
def calc_surface(self):
return self.x * self.y
# un objet de la classe Rectangle
rec = Rectangle(6,2)
print("La surface est:",rec.calc_surface())
Sortie:
La surface est: 12
Exercice 3:
Écrire une classe nommée Rectangle dont le constructeur prend deux paramètres (width, length) et les fonctions suivantes:
Calcul du périmètre
Calcul de la surface
Affichage
Les accesseurs et mutateurs triviaux (lecture et modification du paramètres width et length).
Solution:
# Créer une classe nommée Rectangle
class Rectangle:
# Constructeur
def __init__(self,w,l):
self.width = w
self.length = l
# récupérer largeur du Rectangle
def getWidth(self):
return width
# récupérer longueur du Rectangle
def getLength(self):
return length
# modifier largeur du Rectangle
def setWidth(self,w):
self.width = w
# modifier longueur du Rectangle
def setLength(self,h):
self.length = l
# Calculer périmètre du Rectangle
def perimetre(self):
return 2*(self.width + self.length)
# Calculer surface du Rectangle
def surface(self):
return self.width * self.length
# Afficher les infos du Rectangle
def afficher(self):
print("Width :",self.width)
print("Length:",self.length)
# créer un objet de la classe Rectangle
rect = Rectangle(6,2)
rect.afficher()
print("La surface est",rect.surface())
print("Le périmètre est",rect.perimetre())
Sortie:
Width : 6
Height: 2
La surface est 12
Le périmètre est 16
Exercice 4:
Créer une classe fille Polyedre héritant de la classe Rectangle ci-dessus et qui inclut également d’un attribut height ainsi qu’une méthode volume() pour calculer le volume du Polyedre.
Solution:
class Polyedre(Rectangle):
def __init__(self, width, length, height):
# Appeler le constructeur de la classe mére Rectangle
Rectangle.__init__(self, width, length)
self.height = height
# Calculer le volume
def volume(self):
return self.width * self.length * self.height
rect = Rectangle(8,4)
pol = Polyedre(8,4,3)
print("Le périmètre du rectangle est:",rect.perimetre())
print("La surface du rectangle est:", rect.surface())
print("Le volume du polyedre est:", pol.volume())
Sortie:
Le périmètre du rectangle est: 24
La surface du rectangle est: 32
Le volume du polyedre est: 96
Exercice 5:
Écrivez un programme Python pour créer une classe Personne. Incluez des attributs tels que le nom, le pays et la date de naissance. Implémentez une méthode pour déterminer l’âge de la personne.
Solution:
# Importer la classe date du module datetime pour travailler avec des dates
from datetime import date
# Définir une classe appelée Personne
class Personne:
# Constructeur de la classe Personne
def __init__(self, nom, pays, date_naissance):
self.nom = nom
self.pays = pays
self.date_naissance = date_naissance
# Calculer l'âge de la personne en fonction de sa date de naissance
def calculer_age(self):
today = date.today()
age = today.year - self.date_naissance.year
if today < date(today.year, self.date_naissance.month, self.date_naissance.day):
age -= 1
return age
# Créer un objet Personne avec différents attributs
p1 = Personne("Alex Babtise", "France", date(1998, 8, 11))
# Accéder et afficher les attributs et l'âge calculé
print("Personne 1:")
print("Nom:", p1.nom)
print("Pays:", p1.pays)
print("Date de naissance:", p1.date_naissance)
print("Age:", p1.calculer_age())
Sortie:
Personne 1:
Nom: Alex Babtise
Pays: France
Date de naissance: 1998-08-11
Age: 26
Explication:
Dans l'exercice ci-dessus, nous définissons une classe appelée Personne avec une méthode init qui initialise les attributs nom, pays et date_de_naissance.
La méthode calculer_age utilise le module date de la bibliothèque datetime pour déterminer l'âge d'une personne. Elle se base sur la date actuelle et la date de naissance. Elle calcule la différence entre l'année en cours et l'année de naissance.
Ensuite, nous créons une instance de la classe Personne, personne1 avec des valeurs d'attribut. Ensuite, nous accédons aux attributs et les affichons à l'aide de la notation par points (nom_attribut_personne), et nous déterminons l'âge à l'aide de la fonction calculer_age.
Exercice 6:
Écrire un programme Python pour créer une classe représentant un cercle qui comprend l'attribut 'rayon' et incluez des méthodes pour calculer sa surface et son périmètre.
Solution:
# Importer le module math pour accéder à des fonctions mathématiques telles que pi
import math
# Définir une classe appelée Cercle pour représenter un cercle
class Cercle:
# Initialiser l'objet Cercle avec un rayon donné
def __init__(self, rayon):
self.rayon = rayon
# Calculez et donnez la surface du cercle à l'aide de la formule: π * r^2
def surface(self):
return math.pi * self.rayon**2
# Calculez et donnez le périmètre du cercle à l'aide de la formule: 2π * r
def perimeter(self):
return 2 * math.pi * self.rayon
# Inviter l'utilisateur à saisir le rayon du cercle et le convertir en un nombre à virgule flottante.
rayon = float(input("Saisir le rayon du cercle:"))
# Créer un objet Cercle avec le rayon fourni
c = Cercle(rayon)
# Calculer la surface du cercle
s = c.surface()
# Calculer le périmètre du cercle
p = c.perimeter()
# Afficher la surface et le périmètre calculés du cercle
print("Surface du cercle:", s)
print("Périmètre du cercle:", p)
Sortie:
Saisir le rayon du cercle: 5
Surface du cercle: 78.53981633974483
Périmètre du cercle: 31.41592653589793
Explication:
Dans l'exercice ci-dessus, nous définissons une classe appelée Circle avec une méthode init qui initialise l'attribut rayon. La classe comprend également deux méthodes: surface() et perimeter().
La méthode surface() utilise la formule pi * rayon ^ 2 pour calculer la surface du cercle. La méthode perimeter() utilise la formule 2 *pi * rayon pour calculer le périmètre du cercle.
Le programme invite l'utilisateur à saisir le rayon du cercle. Il crée ensuite une instance de la classe Circle en utilisant le rayon donné et calcule sa surface et son périmètre. Les valeurs calculées sont ensuite affichées à l'écran.
Exercice 7:
Écrire un programme Python pour créer une classe Calculatrice. Incluez des méthodes pour les opérations arithmétiques de base tels que: additionner, soustraire, multiplier et diviser.
Solution:
# Définir une classe appelée Calculatrice
class Calculatrice:
# Définir une méthode pour l'addition
def additionner(self, x, y):
return x + y
# Définir une méthode pour la soustraction
def soustraire(self, x, y):
return x - y
# Définir une méthode pour la multiplication
def multiplier(self, x, y):
return x * y
# Définir une méthode pour la division
def diviser(self, x, y):
if y != 0:
return x / y
else:
return ("Impossible de diviser par zéro.")
# Créer une instance de la classe Calculatrice
calc = Calculatrice()
# Effectuer l'addition et afficher le résultat
result = calc.additionner(1, 2)
print("1 + 2 =", result)
# Effectuer la soustraction et afficher le résultat
result = calc.soustraire(10, 5)
print("10 - 5 =", result)
# Effectuer la multiplication et afficher le résultat
result = calc.multiplier(3, 2)
print("3 * 2 =", result)
# Effectuer la division et afficher le résultat
result = calc.diviser(100, 2)
print("100 / 2 =", result)
# Tentative de division par zéro, ce qui provoque une erreur.
result = calc.diviser(12, 0)
print("12 / 0 =", result)
Dans l'exercice ci-dessus, nous définissons une classe appelée Calculatrice avec les méthodes ajouter, soustraire, multiplier et diviser, qui représentent les opérations arithmétiques de base.
La méthode additionner effectue l'addition de deux nombres, soustraire effectue la soustraction, multiplier effectue la multiplication et diviser effectue la division. Si le dénominateur est nul, la méthode diviser renvoie un message d'erreur pour éviter la division par zéro.
Ensuite, nous créons une instance de calculatrice, et l'utilisons pour effectuer diverses opérations arithmétiques.
Exercice 8:
Écrivez un programme Python pour créer une classe représentant un panier d'achat. Incluez des méthodes pour ajouter et supprimer des articles, et pour calculer le prix total.
Solution:
# Définir une classe appelée PanierAchat
class PanierAchat:
# Initialiser le panier avec une liste d'articles vide
def __init__(self):
self.articles = []
# Ajouter un article avec un nom et une quantité au panier d'achat
def ajouter_article(self, nom, qt):
article = (nom, qt)
self.articles.append(article)
# Supprimer du panier d'achat un article portant un nom spécifique
def supprimer_article(self, nom):
for article in self.articles:
if article[0] == nom:
self.articles.remove(article)
break
# Calculer et renvoyer la quantité totale d'articles dans le panier d'achat
def calculer_total(self):
total = 0
for article in self.articles:
total += article[1]
return total
# Créer une instance de la classe PanierAchat
panier = PanierAchat()
# Ajouter des articles au panier
panier.ajouter_article("Banane", 100)
panier.ajouter_article("Citron", 200)
panier.ajouter_article("Carotte", 150)
# Afficher les articles présents dans le panier et calculer la quantité totale
print("Articles actuels dans le panier:")
for article in panier.articles:
print(article[0], "-", article[1])
total_qt = panier.calculer_total()
print("Quantité totale:", total_qt)
# Supprimer un article du panier, afficher les articles mis à jour et recalculer la quantité totale.
panier.supprimer_article("Banane")
print("\nMise à jour des articles dans le panier après la suppression de Banane:")
for article in panier.articles:
print(article[0], "-", article[1])
total_qt = panier.calculer_total()
print("Quantité totale:", total_qt)
Sortie:
Articles actuels dans le panier:
Banane - 100
Citron - 200
Carotte - 150
Quantité totale: 450
Mise à jour des articles dans le panier après la suppression de Banane:
Citron - 200
Carotte - 150
Quantité totale: 350
Explication:
Dans l'exercice ci-dessus:
Nous définissons une classe PanierAchat représentant un panier d'achat. Elle possède un attribut appelé « articles », qui est initialement une liste vide.
La méthode « ajouter_article() » prend un nom d'article et une quantité comme arguments et les ajoute sous forme de tuple à la liste des articles. L'article est ainsi ajouté au panier.
La méthode « supprimer_article() » supprime de la liste des articles la première occurrence d'un article portant le nom spécifié. Elle parcourt la liste et vérifie si le nom de l'élément en cours correspond au nom spécifié. Si une correspondance est trouvée, elle supprime l'élément de la liste et sort de la boucle.
La méthode « calculer_total() » calcule et renvoie la quantité totale de tous les articles du panier. Elle parcourt la liste des articles et accumule la quantité de chaque article.
Ensuite, nous créons une instance de la classe PanierAchat appelée panier. Nous ajoutons plusieurs articles au panier à l'aide de la méthode « ajouter_article() » et affichons les articles présents dans le panier.
Nous calculons et affichons la quantité totale d'articles à l'aide de la méthode « calculer_total() ».
La méthode « supprimer_article() » est utilisée pour supprimer un article du panier et afficher les articles mis à jour.
Éditeur de code Python: Testez votre code en ligne!
QCM Python – Partie 1Bienvenue dans notre QCM Python ! Que vous soyez débutant ou déjà expérimenté en programmation, ce questionnaire à choix multiples est l’occasion parfaite de tester…Lire plus