À l'issue de ce chapitre, vous serez capable de créer vos propres classes Python avec des attributs et méthodes appropriés. Vous comprendrez les concepts fondamentaux de la programmation orientée objet et saurez instancier des objets pour les utiliser dans vos programmes. Vous maîtriserez également les bonnes pratiques d'encapsulation et l'utilisation des méthodes spéciales.
La programmation orientée objet (POO) est un paradigme de programmation qui permet de modéliser des concepts du monde réel en utilisant des "objets" qui contiennent à la fois des données et des comportements.
Une classe est un plan ou un modèle qui définit la structure et le comportement que auront les objets créés à partir de celle-ci.
# Définition d'une classe simple class Personne: # Attribut de classe (partagé par toutes les instances) espece = "Homo sapiens" # Méthode spéciale d'initialisation def __init__(self, nom, age): # Attributs d'instance (uniques à chaque objet) self.nom = nom self.age = age # Méthode d'instance def se_presenter(self): return f"Je m'appelle {self.nom} et j'ai {self.age} ans."
Un objet est une instance d'une classe. C'est une entité concrète créée à partir du modèle défini par la classe, avec ses propres données.
# Création d'objets (instances de la classe Personne) personne1 = Personne("Alice", 25) personne2 = Personne("Bob", 30) # Accès aux attributs print(personne1.nom) # Output: Alice print(personne2.age) # Output: 30 # Appel de méthodes presentation = personne1.se_presenter() print(presentation) # Output: Je m'appelle Alice et j'ai 25 ans. # Modification d'attributs personne1.age = 26 print(personne1.se_presenter()) # Output: Je m'appelle Alice et j'ai 26 ans.
La relation entre une classe et un objet est souvent comparée à celle entre un moule à gâteau et les gâteaux produits avec ce moule.
# La classe est le moule qui définit la forme class MouleGateau: forme = "cœur" def __init__(self, parfum, couleur): self.parfum = parfum self.couleur = couleur def decrire(self): return f"Un gâteau en forme de {self.forme}, au parfum {self.parfum} et de couleur {self.couleur}." # Les objets sont les gâteaux produits avec le moule gateau1 = MouleGateau("chocolat", "marron") gateau2 = MouleGateau("vanille", "blanc") gateau3 = MouleGateau("fraise", "rose") # Tous ont la même forme (attribut de classe) print(gateau1.forme) # Output: cœur print(gateau2.forme) # Output: cœur print(gateau3.forme) # Output: cœur # Mais des parfums et couleurs différents (attributs d'instance) print(gateau1.decrire()) # Output: Un gâteau en forme de cœur, au parfum chocolat et de couleur marron. print(gateau2.decrire()) # Output: Un gâteau en forme de cœur, au parfum vanille et de couleur blanc. print(gateau3.decrire()) # Output: Un gâteau en forme de cœur, au parfum fraise et de couleur rose.
En Python, la création d'une classe est le point de départ de la programmation orientée objet. Une classe définit la structure et le comportement que auront les objets créés à partir de celle-ci.
Pour créer une classe en Python, on utilise le mot-clé class suivi du nom de la classe et de deux points. Le corps de la classe contient ses attributs et méthodes.
# Syntaxe de base pour créer une classe class VilleMarocaine: # Corps de la classe # (peut contenir des attributs et des méthodes) pass # mot-clé pass pour une classe vide temporairement # Création d'une classe avec une méthode simple class MonumentMarocain: # Méthode spéciale d'initialisation def __init__(self): # Corps de la méthode (vide pour l'instant) pass # Méthode d'instance def decrire(self): return "Monument marocain important" # Une classe peut hériter d'autres classes class Mosquee(Mosquee): # Hérite de la classe MonumentMarocain pass
En Python, les conventions de nommage recommandent d'utiliser le PascalCase pour les noms de classes. Cela signifie que chaque mot commence par une majuscule, sans underscores.
# Bonnes pratiques de nommage (PascalCase) class VilleMarocaine: # ✓ Correct class PlatTraditionnel: # ✓ Correct class ArtisanatLocal: # ✓ Correct class SiteTouristique: # ✓ Correct class FestivalCulturel: # ✓ Correct # Exemples à éviter class ville_marocaine: # ✗ Éviter (snake_case) class Ville_marocaine: # ✗ Éviter (mélange de casse) class VILLEMAROCAINE: # ✗ Éviter (majuscules seulement) # Exemples de classes avec des noms marocains class HassanII: # ✓ Mosquée Hassan II class JardinMajorelle: # ✓ Jardin Majorelle à Marrakech class Casablanca: # ✓ Ville de Casablanca class Couscous: # ✓ Plat traditionnel class Tanjia: # ✓ Spécialité marrakchie class Fes: # ✓ Ville impériale class Meknes: # ✓ Ville impériale class Marrakech: # ✓ Ville ocre class Rabat: # ✓ Capitale du Maroc
Une classe peut exister sans attributs ni méthodes, bien que cela soit rare en pratique. On utilise le mot-clé pass pour indiquer que la classe est vide intentionnellement.
# Classe sans attributs ni méthodes class VilleMarocaine: pass # Indique que la classe est vide intentionnellement # Classe vide avec documentation class MonumentMarocain: """ Représente un monument marocain. Cette classe sera complétée ultérieurement. """ pass # Utilisation des classes vides casablanca = VilleMarocaine() marrakech = VilleMarocaine() koutoubia = MonumentMarocain() # On peut ajouter des attributs dynamiquement (mais ce n'est pas recommandé) casablanca.nom = "Casablanca" casablanca.population = 3370000 casablanca.region = "Casablanca-Settat" marrakech.nom = "Marrakech" marrakech.population = 928000 marrakech.region = "Marrakech-Safi" # Affichage des attributs print(f"{casablanca.nom}: {casablanca.population} habitants") print(f"{marrakech.nom}: {marrakech.population} habitants") # Vérification du type print(type(casablanca)) # Output: <class '__main__.VilleMarocaine'> print(isinstance(marrakech, VilleMarocaine)) # Output: True
pass temporairement pendant le développement__init__)Les attributs sont des variables qui stockent les données d'une classe ou d'un objet. Ils définissent l'état des objets et permettent de stocker des informations spécifiques.
Il existe deux types d'attributs : les attributs d'instance (spécifiques à chaque objet) et les attributs de classe (partagés par toutes les instances).
class VilleMarocaine: # Attribut de classe (partagé par toutes les instances) pays = "Maroc" continent = "Afrique" def __init__(self, nom, population, region): # Attributs d'instance (spécifiques à chaque objet) self.nom = nom self.population = population self.region = region # Création d'instances casablanca = VilleMarocaine("Casablanca", 3370000, "Casablanca-Settat") marrakech = VilleMarocaine("Marrakech", 928000, "Marrakech-Safi") fes = VilleMarocaine("Fès", 1112000, "Fès-Meknès") # Accès aux attributs d'instance (différents pour chaque objet) print(f"{casablanca.nom}: {casablanca.population} habitants") print(f"{marrakech.nom}: {marrakech.population} habitants") print(f"{fes.nom}: {fes.population} habitants") # Accès aux attributs de classe (identiques pour tous les objets) print(f"{casablanca.nom} est située en {casablanca.pays}, {casablanca.continent}") print(f"{marrakech.nom} est située en {marrakech.pays}, {marrakech.continent}") print(f"{fes.nom} est située en {fes.pays}, {fes.continent}") # Modification d'un attribut de classe affecte toutes les instances VilleMarocaine.continent = "Afrique du Nord" print(f"Après modification: {casablanca.continent}") print(f"Après modification: {marrakech.continent}") # Modification d'un attribut d'instance n'affecte que cet objet casablanca.population = 3500000 # Seulement Casablanca est affectée print(f"Nouvelle population de Casablanca: {casablanca.population}") print(f"Population de Marrakech: {marrakech.population}") # Inchangée
La méthode spéciale __init__() est le constructeur qui initialise les attributs d'instance lors de la création d'un objet.
class MonumentMarocain: # Attribut de classe pays = "Maroc" # Méthode __init__ pour initialiser les attributs d'instance def __init__(self, nom, ville, annee_construction, style_architectural): # Initialisation des attributs d'instance self.nom = nom self.ville = ville self.annee_construction = annee_construction self.style_architectural = style_architectural self.visiteurs_annuels = 0 # Attribut avec valeur par défaut def decrire(self): return f"{self.nom} à {self.ville} ({self.annee_construction}) - Style {self.style_architectural}" # Création d'instances avec initialisation koutoubia = MonumentMarocain( "Mosquée Koutoubia", "Marrakech", 1158, "Almoravide et Almohade" ) hassan_ii = MonumentMarocain( "Mosquée Hassan II", "Casablanca", 1993, "Arabo-andalou moderne" ) bahia = MonumentMarocain( "Palais de la Bahia", "Marrakech", 1894, "Arabo-andalou et marocain traditionnel" ) # Affichage des descriptions print(koutoubia.decrire()) print(hassan_ii.decrire()) print(bahia.decrire()) # Accès aux attributs print(f"La {koutoubia.nom} a été construite en {koutoubia.annee_construction}") print(f"Le {hassan_ii.nom} se trouve à {hassan_ii.ville}") print(f"Tous ces monuments sont situés au {bahia.pays}")
Les attributs peuvent être accédés et modifiés directement en utilisant la notation pointée. Python permet également d'ajouter dynamiquement des attributs.
class PlatMarocain: def __init__(self, nom, region, ingredients_principaux): self.nom = nom self.region = region self.ingredients_principaux = ingredients_principaux self.est_populaire = True # Attribut avec valeur par défaut # Création d'une instance couscous = PlatMarocain("Couscous", "Tout le Maroc", ["semoule", "légumes", "viande"]) # Accès aux attributs print(f"Nom: {couscous.nom}") print(f"Région: {couscous.region}") print(f"Ingrédients: {', '.join(couscous.ingredients_principaux)}") print(f"Populaire: {couscous.est_populaire}") # Modification des attributs existants couscous.region = "Afrique du Nord" couscous.ingredients_principaux.append("épices") couscous.est_populaire = True # Pas de changement print(f"Région après modification: {couscous.region}") print(f"Nouveaux ingrédients: {', '.join(couscous.ingredients_principaux)}") # Ajout dynamique d'un nouvel attribut couscous.temps_preparation = "2 heures" couscous.niveau_difficulte = "Moyen" print(f"Temps de préparation: {couscous
Les méthodes sont des fonctions définies à l'intérieur d'une classe qui décrivent le comportement des objets. Elles opèrent sur les données de l'objet et permettent d'implémenter sa logique métier.
Les méthodes sont définies comme des fonctions à l'intérieur de la classe, mais avec une différence cruciale : leur premier paramètre est toujours self, qui représente l'instance de l'objet.
class VilleMarocaine: def __init__(self, nom, population, region): self.nom = nom self.population = population self.region = region # Méthode simple sans paramètres (outre self) def afficher_nom(self): return f"Ville: {self.nom}" # Méthode avec paramètres supplémentaires def ajouter_habitants(self, nouveaux_habitants): self.population += nouveaux_habitants return f"Nouvelle population: {self.population}" # Méthode avec valeur de retour def est_grande_ville(self): return self.population > 1000000 # Méthode qui appelle d'autres méthodes def decrire(self): taille = "grande" if self.est_grande_ville() else "moyenne" return f"{self.afficher_nom()}, {taille} ville de la région {self.region}" # Utilisation des méthodes casablanca = VilleMarocaine("Casablanca", 3370000, "Casablanca-Settat") marrakech = VilleMarocaine("Marrakech", 928000, "Marrakech-Safi") # Appel des méthodes print(casablanca.afficher_nom()) # Ville: Casablanca print(marrakech.est_grande_ville()) # False print(casablanca.est_grande_ville()) # True # Méthode avec paramètre resultat = marrakech.ajouter_habitants(50000) print(resultat) # Nouvelle population: 978000 print(marrakech.est_grande_ville()) # False (toujours en dessous de 1M) # Méthode qui utilise d'autres méthodes print(casablanca.decrire()) # Ville: Casablanca, grande ville de la région Casablanca-Settat print(marrakech.decrire()) # Ville: Marrakech, moyenne ville de la région Marrakech-Safi
Le paramètre self est une référence à l'instance courante de la classe. Il est obligatoire comme premier paramètre des méthodes d'instance et permet d'accéder aux attributs et autres méthodes de l'objet.
class MonumentMarocain: def __init__(self, nom, ville, annee_construction): # self permet d'accéder aux attributs de l'instance self.nom = nom self.ville = ville self.annee_construction = annee_construction self.visiteurs_annuels = 0 # self est obligatoire pour les méthodes d'instance def ajouter_visiteurs(self, nombre): # self permet de modifier l'état de l'objet self.visiteurs_annuels += nombre def reinitialiser_visiteurs(self): # self permet de réinitialiser un attribut self.visiteurs_annuels = 0 def est_ancien(self): # self permet d'accéder aux attributs en lecture return (2023 - self.annee_construction) > 100 def decrire(self): # self permet d'appeler d'autres méthodes anciennete = "ancien" if self.est_ancien() else "moderne" return f"{self.nom} ({anciennete}) à {self.ville}" # Création d'instances koutoubia = MonumentMarocain("Mosquée Koutoubia", "Marrakech", 1158) hassan_ii = MonumentMarocain("Mosquée Hassan II", "Casablanca", 1993) # self est passé automatiquement par Python koutoubia.ajouter_visiteurs(1500000) hassan_ii.ajouter_visiteurs(2000000) # Appel des méthodes print(koutoubia.decrire()) # Mosquée Koutoubia (ancien) à Marrakech print(hassan_ii.decrire()) # Mosquée Hassan II (moderne) à Casablanca # self permet d'accéder aux attributs modifiés print(f"Visiteurs Koutoubia: {koutoubia.visiteurs_annuels}") print(f"Visiteurs Hassan II: {hassan_ii.visiteurs_annuels}") # Réinitialisation via une méthode koutoubia.reinitialiser_visiteurs() print(f"Visiteurs Koutoubia après réinitialisation: {koutoubia.visiteurs_annuels}")
Les méthodes d'instance sont les plus courantes et permettent de définir le comportement des objets. Elles peuvent modifier l'état de l'objet, retourner des informations ou effectuer des calculs.
class PlatMarocain: def __init__(self, nom, region, ingredients, temps_preparation): self.nom = nom self.region = region self.ingredients = ingredients self.temps_preparation = temps_preparation self.note = 0 self.nombre_notes = 0 # Méthode pour modifier l'état de l'objet def ajouter_note(self, nouvelle_note): if 0 <=
L'instanciation est le processus de création d'un objet à partir d'une classe. Une fois l'objet créé, on peut appeler ses méthodes et manipuler ses attributs pour interagir avec lui.
Pour créer une instance (objet) d'une classe, on utilise le nom de la classe suivi de parenthèses. Si la classe a un constructeur __init__, on passe les arguments nécessaires.
class VilleMarocaine: def __init__(self, nom, population, region): self.nom = nom self.population = population self.region = region def decrire(self): return f"{self.nom} ({self.region}) - {self.population} habitants" # Création d'instances de la classe VilleMarocaine casablanca = VilleMarocaine("Casablanca", 3370000, "Casablanca-Settat") marrakech = VilleMarocaine("Marrakech", 928000, "Marrakech-Safi") fes = VilleMarocaine("Fès", 1112000, "Fès-Meknès") rabat = VilleMarocaine("Rabat", 577000, "Rabat-Salé-Kénitra") # Affichage des objets créés print("Villes créées:") print(f" - {casablanca.decrire()}") print(f" - {marrakech.decrire()}") print(f" - {fes.decrire()}") print(f" - {rabat.decrire()}") # Vérification du type des instances print(f"\nType de casablanca: {type(casablanca)}") print(f"casablanca est une instance de VilleMarocaine: {isinstance(casablanca, VilleMarocaine)}") # Création d'une liste d'objets villes_maroc = [casablanca, marrakech, fes, rabat] print(f"\nNombre de villes dans la liste: {len(villes_maroc)}") # Parcours de la liste d'objets print("\nListe de toutes les villes:") for ville in villes_maroc: print(f" - {ville.nom}")
Pour appeler une méthode d'un objet, on utilise la notation pointée : objet.methode(). Les méthodes peuvent retourner des valeurs ou modifier l'état de l'objet.
class MonumentMarocain: def __init__(self, nom, ville, annee_construction): self.nom = nom self.ville = ville self.annee_construction = annee_construction self.visiteurs_annuels = 0 def ajouter_visiteurs(self, nombre): self.visiteurs_annuels += nombre return self.visiteurs_annuels def calculer_age(self, annee_courante=2023): return annee_courante - self.annee_construction def est_ancien(self): return self.calculer_age() > 100 def decrire(self): anciennete = "ancien" if self.est_ancien() else "moderne" return f"{self.nom} ({anciennete}) à {self.ville} - {self.visiteurs_annuels} visiteurs/an" # Création d'instances koutoubia = MonumentMarocain("Mosquée Koutoubia", "Marrakech", 1158) hassan_ii = MonumentMarocain("Mosquée Hassan II", "Casablanca", 1993) # Appel de méthodes sans paramètres supplémentaires age_koutoubia = koutoubia.calculer_age() est_ancien_koutoubia = koutoubia.est_ancien() description_koutoubia = koutoubia.decrire() print(f"Âge de la Koutoubia: {age_koutoubia} ans") print(f"Est ancien: {est_ancien_koutoubia}") print(f"Description: {description_koutoubia}") # Appel de méthodes avec paramètres age_hassan_2020 = hassan_ii.calculer_age(2020) print(f"Âge de Hassan II en 2020: {age_hassan_2020} ans") # Appel de méthodes qui modifient l'état de l'objet visiteurs_koutoubia = koutoubia.ajouter_visiteurs(1500000) visiteurs_hassan = hassan_ii.ajouter_visiteurs(2000000) print(f"Visiteurs Koutoubia: {visiteurs_koutoubia}") print(f"Visiteurs Hassan II: {visiteurs_hassan}") # Appel successif de méthodes (chaînage) hassan_ii.ajouter_visiteurs(500000).ajouter_visiteurs(300000) print(f"Nouveaux visiteurs Hassan II: {hassan_ii.visiteurs_annuels}") # Affichage des descriptions finales print(f"\n{koutoubia.decrire()}") print(f"{hassan_ii.decrire()}")
Les attributs d'un objet peuvent être accédés, modifiés, ajoutés ou supprimés dynamiquement en utilisant la notation pointée.
class PlatMarocain: def __init__(self, nom, region): self.nom = nom self.region = region self.ingredients = [] self.temps_preparation = 0 # Création d'instances couscous = PlatMarocain("Couscous", "Tout le Maroc") tagine = PlatMarocain("Tagine", "Tout le Maroc") pastilla = PlatMarocain("Pastilla", "Fès") # Accès aux attributs existants print
Les méthodes spéciales, aussi appelées "dunder methods" (double underscore), permettent de définir le comportement des objets avec les opérateurs natifs de Python. Elles sont encadrées par deux underscores (__).
La méthode __init__() est le constructeur qui initialise les attributs d'un objet lors de sa création. Elle est appelée automatiquement quand on crée une nouvelle instance.
class VilleMarocaine: # Méthode __init__ (constructeur) def __init__(self, nom, population, region, fondation=None): # Initialisation des attributs d'instance self.nom = nom self.population = population self.region = region self.fondation = fondation self.monuments = [] # Attribut avec valeur par défaut # Validation des données lors de l'initialisation if population <= 0: raise ValueError("La population doit être positive") def ajouter_monument(self, monument): self.monuments.append(monument) # Création d'instances avec le constructeur try: casablanca = VilleMarocaine("Casablanca", 3370000, "Casablanca-Settat", 1756) marrakech = VilleMarocaine("Marrakech", 928000, "Marrakech-Safi", 1070) fes = VilleMarocaine("Fès", 1112000, "Fès-Meknès") # fondation=None # Ajout de monuments casablanca.ajouter_monument("Mosquée Hassan II") marrakech.ajouter_monument("Mosquée Koutoubia") marrakech.ajouter_monument("Place Jemaa el-Fna") fes.ajouter_monument("Médina de Fès") # Affichage des informations print(f"{casablanca.nom}: {casablanca.population} habitants, fondée en {casablanca.fondation}") print(f"Monuments: {', '.join(casablanca.monuments)}") print(f"\n{marrakech.nom}: {marrakech.population} habitants, fondée en {marrakech.fondation}") print(f"Monuments: {', '.join(marrakech.monuments)}") print(f"\n{fes.nom}: {fes.population} habitants") print(f"Monuments: {', '.join(fes.monuments)}") except ValueError as e: print(f"Erreur: {e}") # Test de validation try: ville_invalide = VilleMarocaine("Test", -100, "Test") except ValueError as e: print(f"\nErreur de validation: {e}")
La méthode __str__() retourne une représentation lisible et conviviale de l'objet, utilisée par les fonctions comme print() et str().
class MonumentMarocain: def __init__(self, nom, ville, annee_construction, style): self.nom = nom self.ville = ville self.annee_construction = annee_construction self.style = style # Méthode __str__ pour une représentation lisible def __str__(self): age = 2023 - self.annee_construction return f"{self.nom} à {self.ville} ({self.style}, construit en {self.annee_construction}, âge: {age} ans)" # Méthode pour calculer l'âge def age(self, annee_courante=2023): return annee_courante - self.annee_construction # Création d'instances koutoubia = MonumentMarocain("Mosquée Koutoubia", "Marrakech", 1158, "Almoravide") hassan_ii = MonumentMarocain("Mosquée Hassan II", "Casablanca", 1993, "Arabo-andalou moderne") bahia = MonumentMarocain("Palais de la Bahia", "Marrakech", 1894, "Arabo-andalou") # Utilisation de __str__ avec print() print("Représentation des monuments:") print(koutoubia) # Appel automatique de __str__() print(hassan_ii) print(bahia) # Utilisation avec str() description_koutoubia = str(koutoubia) print(f"\nDescription formatée: {description_koutoubia}") # Utilisation dans les f-strings print(f"\nMonument visité: {hassan_ii}") # Comparaison avec la représentation par défaut (sans __str__) class MonumentSansStr: def __init__(self, nom): self.nom = nom monument_simple = MonumentSansStr("Test") print(f"\nSans __str__: {monument_simple}") print(f"Avec __str__: {koutoubia}")
La méthode __repr__() retourne une représentation technique et non ambiguë de l'objet, idéalement une chaîne qui permet de recréer l'objet avec la même valeur.
class VilleMarocaine: def __init__(self, nom, population, region, fondation=None): self.nom = nom self.population = population self.region = region self.fondation = fondation # Représentation lisible (pour les utilisateurs) def __str
L'encapsulation est un principe fondamental de la POO qui consiste à restreindre l'accès direct aux données internes d'un objet et à fournir des méthodes contrôlées pour y accéder et les modifier.
En Python, tous les attributs et méthodes sont publics par défaut, c'est-à-dire accessibles directement depuis l'extérieur de la classe.
class VilleMarocaine: def __init__(self, nom, population): # Attributs publics (accessibles directement) self.nom = nom self.population = population self.monuments = [] # Méthode publique def ajouter_monument(self, monument): self.monuments.append(monument) # Méthode publique def afficher_info(self): return f"{self.nom}: {self.population} habitants" # Utilisation des membres publics casablanca = VilleMarocaine("Casablanca", 3370000) # Accès direct aux attributs publics print(f"Nom: {casablanca.nom}") print(f"Population: {casablanca.population}") # Modification directe des attributs publics casablanca.population = 3500000 casablanca.nom = "Casablanca Centre" # Possible mais pas recommandé # Appel des méthodes publiques casablanca.ajouter_monument("Mosquée Hassan II") casablanca.ajouter_monument("Place des Nations Unies") print(f"Après modification: {casablanca.afficher_info()}") print(f"Monuments: {casablanca.monuments}") # Problème: on peut modifier les attributs sans contrôle casablanca.population = -1000 # Valeur invalide mais acceptée print(f"Population invalide: {casablanca.population}") # Problème!
Python utilise des conventions de nommage avec des underscores pour indiquer la visibilité des membres :
_attribut : Protégé (accessible mais conventionnellement réservé à un usage interne)__attribut : Privé (name mangling appliqué pour restreindre l'accès)class VilleMarocaine: def __init__(self, nom, population): # Attribut public self.nom = nom # Attribut protégé (convention) self._population = population # Attribut privé (name mangling) self.__code_postal = None # Méthode privée self.__generer_code_postal() # Méthode privée def __generer_code_postal(self): # Simulation de génération de code postal if "Casablanca" in self.nom: self.__code_postal = "20000" elif "Marrakech" in self.nom: self.__code_postal = "40000" else: self.__code_postal = "10000" # Méthode publique pour accéder à l'attribut privé def get_code_postal(self): return self.__code_postal # Méthode publique pour modifier l'attribut protégé avec validation def set_population(self, nouvelle_population): if nouvelle_population > 0: self._population = nouvelle_population else: print("Erreur: La population doit être positive") def get_population(self): return self._population # Utilisation casablanca = VilleMarocaine("Casablanca", 3370000) marrakech = VilleMarocaine("Marrakech", 928000) # Accès aux attributs publics print(f"Nom: {casablanca.nom}") # Accès aux attributs protégés (possible mais déconseillé) print(f"Population (accès direct): {casablanca._population}") # Déconseillé # Utilisation des méthodes publiques pour accéder aux données print(f"Population (via getter): {casablanca.get_population()}") print(f"Code postal: {casablanca.get_code_postal()}") print(f"Code postal Marrakech: {marrakech.get_code_postal()}") # Modification via setter avec validation casablanca.set_population(3500000) # Valide casablanca.set_population(-1000) # Rejetée # Tentative d'accès direct à un attribut privé (échoue) try: print(casablanca.__code_postal) # AttributeError except AttributeError as e: print(f"Erreur d'accès: {e}") # Accès via name mangling (possible mais fortement déconseillé) print(f"Accès forcé: {casablanca._VilleMarocaine__code_postal}") # Déconseillé!
Le décorateur @property permet de créer des propriétés qui se comportent comme des attributs mais qui appellent en réalité des méthodes (getters, setters, deleters).
class VilleMarocaine: def __init__(self, nom, population): self.nom = nom self._population = population self._monuments = [] # Propriété en lecture seule @property def population(self
Cette section propose des exercices pratiques pour mettre en application les concepts de programmation orientée objet vus précédemment, avec des exemples inspirés du contexte marocain.
Créez des classes simples pour représenter des entités du monde réel avec des attributs de base et des méthodes simples.
# Exercice 1: Classe Personne class Personne: def __init__(self, nom, age, ville): self.nom = nom self.age = age self.ville = ville def se_presenter(self): return f"Je m'appelle {self.nom}, j'ai {self.age} ans et je vis à {self.ville}." def est_majeur(self): return self.age >= 18 # Exercice 2: Classe Voiture class Voiture: def __init__(self, marque, modele, annee, kilometrage=0): self.marque = marque self.modele = modele self.annee = annee self.kilometrage = kilometrage def description(self): return f"{self.marque} {self.modele} ({self.annee}) - {self.kilometrage} km" def rouler(self, km): if km > 0: self.kilometrage += km return f"La voiture a roulé {km} km. Nouveau kilométrage: {self.kilometrage} km" else: return "Distance invalide" # Tests des classes simples print("=== EXERCICE 1: CLASSE PERSONNE ===") personne1 = Personne("Fatima", 25, "Casablanca") personne2 = Personne("Mehdi", 17, "Marrakech") print(personne1.se_presenter()) print(f"Est majeur: {personne1.est_majeur()}") print(personne2.se_presenter()) print(f"Est majeur: {personne2.est_majeur()}") print("\n=== EXERCICE 2: CLASSE VOITURE ===") dacia = Voiture("Dacia", "Sandero", 2020, 35000) renault = Voiture("Renault", "Clio", 2022) print(dacia.description()) print(renault.description()) print(dacia.rouler(150)) print(dacia.rouler(-50)) # Test distance invalide print(dacia.description())
Créez des classes avec des méthodes métier plus complexes qui implémentent une logique spécifique.
# Exercice 3: Classe CompteBancaire class CompteBancaire: def __init__(self, titulaire, solde_initial=0): self.titulaire = titulaire self._solde = solde_initial self.devise = "MAD" self.historique = [] def deposer(self, montant): if montant > 0: self._solde += montant self.historique.append(f"Dépôt: +{montant} {self.devise}") return f"Dépôt de {montant} {self.devise} effectué. Nouveau solde: {self._solde} {self.devise}" else: return "Montant de dépôt invalide" def retirer(self, montant): if montant > 0 and montant <= self._solde: self._solde -= montant self.historique.append(f"Retrait: -{montant} {self.devise}") return f"Retrait de {montant} {self.devise} effectué. Nouveau solde: {self._solde} {self.devise}" elif montant > self._solde: return "Fonds insuffisants" else: return "Montant de retrait invalide" def afficher_solde(self): return f"Solde actuel: {self._solde} {self.devise}" def afficher_historique(self): if not self.historique: return "Aucune opération effectuée" return "\n".join(self.historique) # Exercice 4: Classe Restaurant class Restaurant: def __init__(self, nom, specialite, ville): self.nom = nom self.specialite = specialite self.ville = ville self.plats = [] self.notes = [] def ajouter_plat(self, nom_plat, prix): self.plats.append({"nom": nom_plat, "prix": prix}) return f"Plat '{nom_plat}' ajouté au menu" def noter(self, note, commentaire=""): if 1 <= note <= 5: self.notes.append({"note": note, "commentaire": commentaire}) return f"Note de {note}/5 enregistrée" else: return "Note invalide (doit être entre 1 et 5)" def moyenne_notes(self): if not self.notes: return 0 return sum(note["note"] for note in self.notes) / len(self.notes) def afficher_menu(self): if not self.plats: return "Menu vide" menu_str = f"Menu de {self.nom}:\n" for plat in self.plats: menu_str += f"- {plat['nom']}: {plat['prix']} MAD\n" return menu_str # Tests des classes métier print("=== EXERCICE 3: CLASSE COMPTE BANCAIRE ===") compte = CompteBancaire("Ahmed", 1000) print(compte.afficher_solde()) print(compte.deposer(500)) print(compte.retirer(200)) print(compte.retirer(2000)) # Fonds insuffisants print(compte.afficher_solde()) print("\nHistorique des opérations:") print(compte.afficher_historique()) print("\n=== EXERCICE 4: CLASSE RESTAURANT ===") restaurant = Restaurant("Le Marrakchi", "Cuisine marocaine", "Marrakech") print(restaurant.ajouter_plat("Tagine poulet", 60)) print(restaurant.ajouter_plat("Couscous royal", 80)) print(restaurant.ajouter_plat("Pastilla", 70)) print(restaurant.noter(4, "Très bon service")) print(restaurant.noter(5, "Excellente cuisine")) print(restaurant.noter(6)) # Note invalide print(restaurant.afficher_menu()) print(f"Moyenne des notes: {restaurant.moyenne_notes():.1f}/5")
Créez un système complet de gestion d'une agence de voyage marocaine avec plusieurs classes qui interagissent entre elles.
# Projet fil rouge: Système de gestion d'agence de voyage class Destination: def __init__(self, nom, pays, type_destination, prix_moyen): self.nom = nom self.pays = pays self.type_destination = type_destination # plage, montagne, désert, ville self.prix_moyen = prix_moyen def __str__(self): return f"{self.nom} ({self.pays}) - {self.type_destination} - {self.prix_moyen} MAD/jour" class Client: def __init__(self, nom, email, telephone): self.nom = nom self.email = email self.telephone = telephone self.reservations = [] def ajouter_reservation(self, reservation): self.reservations.append(reservation) def afficher_reservations(self): if not self.reservations: return "Aucune réservation" return "\n".join(str(r) for r in self.reservations) class Reservation: def __init__(self, client, destination, date_depart, duree, nombre_personnes): self.client = client self.destination = destination self.date_depart = date_depart self.duree = duree self.nombre_personnes = nombre_personnes self.prix_total = destination.prix_moyen * duree * nombre_personnes def __str__(self): return f"Réservation pour {self.destination.nom} ({self.date_depart}, {self.duree} jours, {self.nombre_personnes} pers.) - Total: {self.prix_total} MAD" class AgenceVoyage: def __init__(self, nom): self.nom = nom self.destinations = [] self.clients = [] def ajouter_destination(self, destination): self.destinations.append(destination) def ajouter_client(self, client): self.clients.append(client) def rechercher_destination(self, type_destination=None, prix_max=None): resultats = self.destinations if type_destination: resultats = [d for d in resultats if d.type_destination == type_destination] if prix_max: resultats = [d for d in resultats if d.prix_moyen <= prix_max] return resultats def creer_reservation(self, client, destination_nom, date_depart, duree, nombre_personnes): destination = next((d for d in self.destinations if d.nom == destination_nom), None) if not destination: return "Destination non trouvée" reservation = Reservation(client, destination, date_depart, duree, nombre_personnes) client.ajouter_reservation(reservation)
Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.
Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!