Les bases de la programmation orienté objet - Notre lab

Les apports de l’objet¶

Modularité : le code est organisé en modules réutilisables.
Lisibilité : les objets reflètent les entités du monde réel, facilitant la compréhension.
Réutilisabilité : les classes peuvent être réutilisées dans différents projets.
Maintenance : les modifications sont localisées, réduisant les risques d’erreurs.
Extensibilité : il est facile d’ajouter de nouvelles fonctionnalités sans modifier l’existant.

Objets et classes¶

Classe : modèle définissant les attributs et comportements d’un type d’objet.
Objet : instance concrète d’une classe.
Attributs : variables associées à une classe ou un objet.
Méthodes : fonctions définies dans une classe, opérant sur ses objets.

Exercice : Gestion des utilisateurs¶

Exercise 1

Objectif

Comprendre la différence entre une classe (modèle) et un objet (instance).

Contexte

Tu travailles sur une application de gestion d’utilisateurs. Tu dois modéliser un utilisateur avec ses informations de connexion.

Instructions

Créer une classe Utilisateur avec les attributs suivants :
- nom_utilisateur
- mot_de_passe
Ajouter une méthode afficher_infos() qui affiche une phrase comme :
“Nom d’utilisateur : [nom_utilisateur], mot de passe : [mot_de_passe]”
Instancier trois objets de cette classe avec des informations différentes :
- Nom d’utilisateur : “alice”, mot de passe : “azerty123”
- Nom d’utilisateur : “bob”, mot de passe : “motdepasse”
- Nom d’utilisateur : “charlie”, mot de passe : “123456”
Appeler la méthode afficher_infos() pour chaque objet.

Solution to Exercise 1 #

class Utilisateur:
    nom_utilisateur = None
    mot_de_passe = None

    def __init__(self, nom_utilisateur, mot_de_passe):
        self.nom_utilisateur = nom_utilisateur
        self.mot_de_passe = mot_de_passe

    def afficher_infos(self):
        print(f"Nom d'utilisateur : {self.nom_utilisateur}, mot de passe : {self.mot_de_passe}")

# Création des objets
utilisateur1 = Utilisateur("alice", "azerty123")
utilisateur2 = Utilisateur("bob", "motdepasse")
utilisateur3 = Utilisateur("charlie", "123456")

# Appel de la méthode afficher_infos()
utilisateur1.afficher_infos()
utilisateur2.afficher_infos()
utilisateur3.afficher_infos()

Sortie attendue :

Nom d'utilisateur : alice, mot de passe : azerty123
Nom d'utilisateur : bob, mot de passe : motdepasse
Nom d'utilisateur : charlie, mot de passe : 123456

Définition de la classe Utilisateur :

Cette classe représente un modèle d’utilisateur. Elle contient deux attributs :

nom_utilisateur : le nom ou identifiant de l’utilisateur.
mot_de_passe : le mot de passe associé à cet utilisateur.

Méthode spéciale **__init__** :

C’est le constructeur de la classe. Il est automatiquement appelé lors de la création d’un objet. Il initialise les attributs avec les valeurs fournies.

Instanciation, destruction, encapsulation, agrégation¶

Instanciation : création d’un objet à partir d’une classe.
Destruction : libération des ressources utilisées par un objet (ex. : méthode __del__ en Python).
Encapsulation : protection des données internes d’un objet (attributs privés, getters/setters).
Agrégation : relation “a un” entre objets (ex. : une voiture a un moteur).

Exercice : Gestion d’un Utilisateur et de ses Sessions¶

Exercise 2

Objectif

Mettre en pratique les concepts de :

Instanciation : création d’objets à partir de classes.
Destruction : suivi de la suppression d’un objet.
Encapsulation : protection des données sensibles.
Agrégation : relation entre objets.

Contexte Tu développes un système de gestion d’utilisateurs pour une application web. Chaque utilisateur peut avoir plusieurs sessions actives (par exemple, sur différents appareils). Tu dois modéliser cette relation en respectant les principes de la programmation orientée objet.

Instructions

Créer une classe Session avec :
- Un identifiant de session (id_session)
- Une méthode afficher() qui affiche l’ID de la session.
- Une méthode spéciale __del__() qui affiche un message lors de la destruction de la session.
Créer une classe Utilisateur avec :
- Un nom d’utilisateur.
- Un mot de passe (encapsulé avec un attribut privé _mot_de_passe).
- Une liste de sessions (agrégation).
- Une méthode ajouter_session(session) pour associer une session à l’utilisateur.
- Une méthode afficher_sessions() pour afficher toutes les sessions actives.
- Une méthode changer_mot_de_passe(nouveau_mdp) pour modifier le mot de passe.
Créer un utilisateur et deux sessions, les associer, afficher les informations, puis supprimer une session pour observer la destruction.

Exemple de sortie attendue

Session abc123 ajoutée.
Session xyz789 ajoutée.
Sessions actives pour alice :
- abc123
- xyz789
Mot de passe modifié avec succès.
Destruction de la session : xyz789

Solution to Exercise 2 #

class Session:
    def __init__(self, id_session):
        self.id_session = id_session

    def afficher(self):
        print(f"Session active : {self.id_session}")

    def __del__(self):
        print(f"Destruction de la session : {self.id_session}")


class Utilisateur:
    def __init__(self, nom_utilisateur, mot_de_passe):
        self.nom_utilisateur = nom_utilisateur
        self._mot_de_passe = mot_de_passe  # Encapsulation
        self.sessions = []  # Agrégation

    def ajouter_session(self, session):
        self.sessions.append(session)
        print(f"Session {session.id_session} ajoutée.")

    def afficher_sessions(self):
        print(f"Sessions actives pour {self.nom_utilisateur} :")
        for session in self.sessions:
            print(f"- {session.id_session}")

    def changer_mot_de_passe(self, nouveau_mdp):
        self._mot_de_passe = nouveau_mdp
        print("Mot de passe modifié avec succès.")


# Instanciation
utilisateur = Utilisateur("alice", "azerty123")

session1 = Session("abc123")
session2 = Session("xyz789")

# Agrégation
utilisateur.ajouter_session(session1)
utilisateur.ajouter_session(session2)

# Affichage
utilisateur.afficher_sessions()

# Encapsulation
utilisateur.changer_mot_de_passe("nouveauMdp456")

# Destruction
del session2  # Déclenche __del__ pour cette session

Sortie attendue :

Session abc123 ajoutée.
Session xyz789 ajoutée.
Sessions actives pour alice :
- abc123
- xyz789
Mot de passe modifié avec succès.
Destruction de la session : xyz789

Polymorphisme et introspection¶

Polymorphisme : capacité à utiliser des objets de différentes classes via une interface commune.
- Exemple : une méthode afficher() peut être définie différemment selon les classes.
Introspection : capacité d’un programme à examiner ses objets à l’exécution.
- Exemple : type(), isinstance(), dir() en Python.

Exercice : Système d’authentification multi-rôle¶

Exercise 3

Objectif

Mettre en pratique les concepts de :

Polymorphisme : utiliser une même interface pour des comportements différents selon les classes.
Introspection : examiner dynamiquement les objets à l’exécution.

Contexte

Tu développes un système d’authentification pour une application. Il existe plusieurs types d’utilisateurs :

des utilisateurs standards,
des administrateurs,
des invités.

Chaque type d’utilisateur doit pouvoir s’authentifier, mais avec un comportement spécifique.

Instructions

Créer une classe de base Utilisateur avec :
- Un attribut nom_utilisateur.
- Une méthode authentifier() qui affiche un message générique.
Créer trois classes dérivées :
- UtilisateurStandard : affiche “Authentification standard pour [nom_utilisateur]”.
- Administrateur : affiche “Authentification sécurisée pour l’administrateur [nom_utilisateur]”.
- Invite : affiche “Accès limité pour l’invité [nom_utilisateur]”.
Créer une fonction authentifier_utilisateur(utilisateur) qui prend un objet et appelle sa méthode authentifier() (polymorphisme).
Utiliser l’introspection pour :
- Afficher le nom de la classe de chaque utilisateur.
- Vérifier si l’objet hérite bien de la classe Utilisateur.

Exemple de sortie attendue

Authentification standard pour alice
Authentification sécurisée pour l’administrateur bob
Accès limité pour l’invité charlie

alice est une instance de : UtilisateurStandard
bob est une instance de : Administrateur
charlie est une instance de : Invite

alice hérite de Utilisateur : True
bob hérite de Utilisateur : True
charlie hérite de Utilisateur : True

Solution to Exercise 3 #

# Classe de base
class Utilisateur:
    def __init__(self, nom_utilisateur):
        self.nom_utilisateur = nom_utilisateur

    def authentifier(self):
        print(f"Authentification générique pour {self.nom_utilisateur}")

# Classes dérivées
class UtilisateurStandard(Utilisateur):
    def authentifier(self):
        print(f"Authentification standard pour {self.nom_utilisateur}")

class Administrateur(Utilisateur):
    def authentifier(self):
        print(f"Authentification sécurisée pour l’administrateur {self.nom_utilisateur}")

class Invite(Utilisateur):
    def authentifier(self):
        print(f"Accès limité pour l’invité {self.nom_utilisateur}")

# Fonction polymorphe
def authentifier_utilisateur(utilisateur):
    utilisateur.authentifier()

# Instanciation
alice = UtilisateurStandard("alice")
bob = Administrateur("bob")
charlie = Invite("charlie")

# Polymorphisme
authentifier_utilisateur(alice)
authentifier_utilisateur(bob)
authentifier_utilisateur(charlie)

# Introspection
for utilisateur in [alice, bob, charlie]:
    print(f"{utilisateur.nom_utilisateur} est une instance de : {type(utilisateur).__name__}")
    print(f"{utilisateur.nom_utilisateur} hérite de Utilisateur : {isinstance(utilisateur, Utilisateur)}")

Sortie attendue :

Authentification standard pour alice
Authentification sécurisée pour l’administrateur bob
Accès limité pour l’invité charlie
alice est une instance de : UtilisateurStandard
alice hérite de Utilisateur : True
bob est une instance de : Administrateur
bob hérite de Utilisateur : True
charlie est une instance de : Invite
charlie hérite de Utilisateur : True