img
Apprenez la programmation où que vous soyez avec Rachid Saad
📞 Appelez maintenant !

Python - Programmation orientée objet
Chapitre 2 : Classes et objets

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

Introduction aux concepts objets

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.

Qu'est-ce qu'une classe ?

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.

classe_definition.py
# 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."

Qu'est-ce qu'un objet ?

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.

objet_utilisation.py
# 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 classe-objet (analogie du moule et du gâteau)

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.

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

? Points clés à retenir

  • Une classe est un modèle ou blueprint qui définit la structure et le comportement
  • Un objet est une instance concrète créée à partir d'une classe
  • La relation classe-objet est similaire à celle entre un moule et les objets produits avec ce moule
  • Les attributs de classe sont partagés par toutes les instances
  • Les attributs d'instance sont spécifiques à chaque objet

Création d'une classe simple

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.

Syntaxe de base avec le mot-clé class

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

Convention de nommage (PascalCase)

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.

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

Première classe sans attributs ni méthodes

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

? Bonnes pratiques pour créer des classes

  • Utilisez toujours le PascalCase pour nommer vos classes
  • Donnez des noms clairs et descriptifs à vos classes
  • Évitez les classes vides dans du code de production
  • Utilisez pass temporairement pendant le développement
  • Documentez vos classes avec des docstrings
  • Évitez d'ajouter des attributs dynamiquement (préférez __init__)

Les attributs

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.

Attributs d'instance vs attributs de classe

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

types_attributs.py
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

Initialisation avec __init__()

La méthode spéciale __init__() est le constructeur qui initialise les attributs d'instance lors de la création d'un objet.

initialisation_init.py
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}")

Accès et modification des attributs

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.

acces_attributs.py
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

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.

Définition et syntaxe des méthodes

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.

definition_methodes.py
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

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.

parametre_self.py
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}")

Méthodes d'instance courantes

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.

methodes_courantes.py
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 <=
		

Instanciation et utilisation des objets

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.

Créer une instance d'une classe

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.

creation_instance.py
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}")

Appeler les méthodes d'un objet

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.

appel_methodes.py
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()}")

Manipuler les attributs d'un objet

Les attributs d'un objet peuvent être accédés, modifiés, ajoutés ou supprimés dynamiquement en utilisant la notation pointée.

manipulation_attributs.py
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

Méthodes spéciales (dunder methods)

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 (__).

__init__() - Le constructeur

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.

init_constructeur.py
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}")

__str__() - Représentation lisible

La méthode __str__() retourne une représentation lisible et conviviale de l'objet, utilisée par les fonctions comme print() et str().

str_representation.py
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}")

__repr__() - Représentation technique

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.

repr_representation.py
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
			

Encapsulation et visibilité

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.

Attributs et méthodes publics

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.

public_members.py
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!

Convention des underscores (privé/protégé)

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)
underscore_convention.py
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é!

Propriétés avec @property

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

property_decorator.py
class VilleMarocaine:
    def __init__(self, nom, population):
        self.nom = nom
        self._population = population
        self._monuments = []
    
    # Propriété en lecture seule
    @property
    def population(self
	

Exercices pratiques

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.

Classe simple (ex: Personne, Voiture)

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.

classe_simple.py
# 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())

Classe avec méthodes métier

Créez des classes avec des méthodes métier plus complexes qui implémentent une logique spécifique.

classe_metier.py
# 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")

Projet fil rouge

Créez un système complet de gestion d'une agence de voyage marocaine avec plusieurs classes qui interagissent entre elles.

projet_voyage.py
# 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)
				
Contact

📚 Cours à distance

Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.

Appelez-maintenant
By Rachid Saad

Rejoignez notre communauté d'apprentissage à distance

Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!

Revenir aux chapitres : Python - Programmation orientée objet | Allez au cours gratuits