madamasterclass.com
-
Connexion
Connexion
Exploration de la programmation orientée objet
La programmation orientée objet (POO) est un paradigme de programmation qui permet de structurer le code en utilisant des objets. En Python, la POO est largement utilisée et offre des fonctionnalités puissantes pour organiser et réutiliser du code.
Éducation
class MaClasse:
def __init__(self, parametres):
self.attribut1 = parametres1
self.attribut2 = parametres2
def methode(self, parametres):
# code de la méthode
mon_objet = MaClasse(parametres)
objet.attribut.objet.methode(parametres).class Animal:
def __init__(self, nom):
self.nom = nom
def parler(self):
raise NotImplementedError("La méthode parler doit être implémentée dans les classes dérivées.")
class Chien(Animal):
def parler(self):
return "Wouaf!"
class Chat(Animal):
def parler(self):
return "Miaou!"
mon_chien = Chien("Max")
mon_chat = Chat("Minou")
print(mon_chien.nom) # Affiche "Max"
print(mon_chat.nom) # Affiche "Minou"
print(mon_chien.parler()) # Affiche "Wouaf!"
print(mon_chat.parler()) # Affiche "Miaou!"
La programmation orientée objet en Python offre une manière robuste et efficace de concevoir des programmes. En comprenant les concepts fondamentaux tels que les classes, l'encapsulation, l'héritage et le polymorphisme, vous pouvez écrire un code plus modulaire, réutilisable et facile à comprendre.
Créez une classe Rectangle qui représente un rectangle. La classe doit avoir un constructeur prenant en paramètres la longueur et la largeur du rectangle, ainsi que des méthodes pour calculer l'aire et le périmètre du rectangle.
class Rectangle:
def __init__(self, longueur, largeur):
self.longueur = longueur
self.largeur = largeur
def calculer_aire(self):
return self.longueur * self.largeur
def calculer_perimetre(self):
return 2 * (self.longueur + self.largeur)
# Exemple d'utilisation
rectangle = Rectangle(5, 3)
aire = rectangle.calculer_aire()
perimetre = rectangle.calculer_perimetre()
print(aire) # Résultat : 15
print(perimetre) # Résultat : 16
Créez une classe Cercle qui représente un cercle. La classe doit avoir un constructeur prenant en paramètre le rayon du cercle, ainsi que des méthodes pour calculer l'aire et la circonférence du cercle.
import math
class Cercle:
def __init__(self, rayon):
self.rayon = rayon
def calculer_aire(self):
return math.pi * self.rayon ** 2
def calculer_circonference(self):
return 2 * math.pi * self.rayon
# Exemple d'utilisation
cercle = Cercle(2)
aire = cercle.calculer_aire()
circonference = cercle.calculer_circonference()
print(aire) # Résultat : 12.566370614359172
print(circonference) # Résultat : 12.566370614359172
Créez une classe Etudiant qui représente un étudiant. La classe doit avoir un constructeur prenant en paramètres le nom et l'âge de l'étudiant, ainsi que des méthodes pour afficher les informations de l'étudiant.
class Etudiant:
def __init__(self, nom, age):
self.nom = nom
self.age = age
def afficher_informations(self):
print(f"Nom : {self.nom}")
print(f"Age : {self.age}")
# Exemple d'utilisation
etudiant = Etudiant("Alice", 20)
etudiant.afficher_informations()
# Résultat :
# Nom : Alice
# Age : 20
Supposons que vous développiez un jeu vidéo de combat. Vous devez créer une classe Personnage qui représente un personnage du jeu. La classe doit avoir des attributs tels que nom, points_de_vie et attaque, ainsi que des méthodes pour attaquer un autre personnage et vérifier s'il est encore en vie.
class Personnage:
def __init__(self, nom, points_de_vie, attaque):
self.nom = nom
self.points_de_vie = points_de_vie
self.attaque = attaque
def attaquer(self, autre_personnage):
autre_personnage.points_de_vie -= self.attaque
print(f"{self.nom} attaque {autre_personnage.nom} !")
def est_en_vie(self):
return self.points_de_vie > 0
# Exemple d'utilisation
joueur1 = Personnage("Joueur 1", 100, 10)
joueur2 = Personnage("Joueur 2", 80, 15)
while joueur1.est_en_vie() and joueur2.est_en_vie():
joueur1.attaquer(joueur2)
joueur2.attaquer(joueur1)
if joueur1.est_en_vie():
print(f"{joueur1.nom} a gagné !")
else:
print(f"{joueur2.nom} a gagné !")
Supposons que vous développiez une application de gestion d'employés pour une entreprise. Vous devez créer une classe Employe qui représente un employé. La classe doit avoir des attributs tels que nom, salaire et departement, ainsi que des méthodes pour augmenter le salaire de l'employé et afficher ses informations.
class Employe:
def __init__(self, nom, salaire, departement):
self.nom = nom
self.salaire = salaire
self.departement = departement
def augmenter_salaire(self, pourcentage):
self.salaire *= (1 + pourcentage / 100)
def afficher_informations(self):
print(f"Nom : {self.nom}")
print(f"Salaire : {self.salaire}")
print(f"Département : {self.departement}")
# Exemple d'utilisation
employe1 = Employe("Alice", 5000, "Ressources humaines")
employe1.augmenter_salaire(10)
employe1.afficher_informations()
# Résultat :
# Nom : Alice
# Salaire : 5500.0
# Département : Ressources humaines
Supposons que vous développiez une application pour gérer une bibliothèque. Vous devez créer une classe de base Livre qui représente un livre, et une classe dérivée LivreEmpruntable qui représente un livre empruntable. La classe LivreEmpruntable doit hériter de la classe Livre et ajouter un attribut emprunteur ainsi que des méthodes pour emprunter et rendre le livre.
class Livre:
def __init__(self, titre, auteur):
self.titre = titre
self.auteur = auteur
def afficher(self):
print(f"Titre : {self.titre}")
print(f"Auteur : {self.auteur}")
class LivreEmpruntable(Livre):
def __init__(self, titre, auteur):
super().__init__(titre, auteur)
self.emprunteur = None
def emprunter(self, emprunteur):
if self.emprunteur is None:
self.emprunteur = emprunteur
print(f"{self.titre} a été emprunté par {emprunteur}.")
else:
print(f"{self.titre} est déjà emprunté.")
def rendre(self):
if self.emprunteur is not None:
print(f"{self.titre} a été rendu par {self.emprunteur}.")
self.emprunteur = None
else:
print(f"{self.titre} n'est pas emprunté.")
# Exemple d'utilisation
livre1 = Livre("Harry Potter et la Chambre des Secrets", "J.K. Rowling")
livre1.afficher()
livre2 = LivreEmpruntable("Le Seigneur des Anneaux", "J.R.R. Tolkien")
livre2.afficher()
livre2.emprunter("Alice")
livre2.rendre()
livre2.emprunter("Bob")Supposons que vous développiez une application de dessin. Vous devez créer une classe de base Forme qui représente une forme géométrique, et des classes dérivées Rectangle et Cercle qui héritent de Forme. Chaque classe doit avoir une méthode calculer_surface pour calculer la surface de la forme spécifique.
import math
class Forme:
def calculer_surface(self):
pass
class Rectangle(Forme):
def __init__(self, longueur, largeur):
self.longueur = longueur
self.largeur = largeur
def calculer_surface(self):
return self.longueur * self.largeur
class Cercle(Forme):
def __init__(self, rayon):
self.rayon = rayon
def calculer_surface(self):
return math.pi * self.rayon ** 2
# Exemple d'utilisation
rectangle = Rectangle(5, 3)
surface_rectangle = rectangle.calculer_surface()
print(f"Surface du rectangle : {surface_rectangle}")
cercle = Cercle(2)
surface_cercle = cercle.calculer_surface()
print(f"Surface du cercle : {surface_cercle}")Supposons que vous développiez une application pour gérer les véhicules d'une entreprise de location. Vous devez créer une classe de base Vehicule qui représente un véhicule, et des classes dérivées Voiture et Moto qui héritent de Vehicule. Chaque classe doit avoir des attributs spécifiques tels que nombre_de_portes pour une voiture et cylindree pour une moto.
class Vehicule:
def __init__(self, marque, modele):
self.marque = marque
self.modele = modele
class Voiture(Vehicule):
def __init__(self, marque, modele, nb_portes):
super().__init__(marque, modele)
self.nombre_de_portes = nb_portes
class Moto(Vehicule):
def __init__(self, marque, modele, cylindree):
super().__init__(marque, modele)
self.cylindree = cylindree
# Exemple d'utilisation
voiture = Voiture("Toyota", "Corolla", 4)
print(f"Voiture : {voiture.marque} {voiture.modele}, {voiture.nombre_de_portes} portes")
moto = Moto("Honda", "CBR500R", 500)
print(f"Moto : {moto.marque} {moto.modele}, {moto.cylindree} cc")Supposons que vous développiez une application pour simuler une collection de formes géométriques. Vous devez créer une classe de base Forme avec une méthode calculer_surface() et des classes dérivées Rectangle et Cercle qui héritent de Forme et implémentent calculer_surface() de manière spécifique.
import math
class Forme:
def calculer_surface(self):
pass
class Rectangle(Forme):
def __init__(self, longueur, largeur):
self.longueur = longueur
self.largeur = largeur
def calculer_surface(self):
return self.longueur * self.largeur
class Cercle(Forme):
def __init__(self, rayon):
self.rayon = rayon
def calculer_surface(self):
return math.pi * self.rayon ** 2
# Exemple d'utilisation
rectangle = Rectangle(5, 3)
surface_rectangle = rectangle.calculer_surface()
print(f"Surface du rectangle : {surface_rectangle}")
cercle = Cercle(2)
surface_cercle = cercle.calculer_surface()
print(f"Surface du cercle : {surface_cercle}")Les mathématiques ont souvent la réputation d'être une discipline austère et difficile, mais ...
Read more.Plongez dans l'univers fascinant des suites numériques, où chaque terme révèle des patterns surprenants et des applications pratiques dans les mathématiques et au-delà.
Read more.Découvrez comment les fonctions tissent des liens entre les nombres et les concepts, transformant des idées abstraites en outils puissants pour résoudre des problèmes du quotidien.
Read more.
