Exercice Corrigé: Les classes POO Python – Partie 2

# 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!

# 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

# 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

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

# 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.

# 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.

# 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)

Sortie:

1 + 2 = 3
10 - 5 = 5
3 * 2 = 6
100 / 2 = 50.0
12 / 0 = Impossible de diviser par zéro.

Explication:

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.

# 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.