Les classes et objets en Python

Pourquoi classes et objets en Python ?

Les classes et les objets sont des concepts fondamentaux en programmation orientée objet (POO) et sont largement utilisés dans le développement de logiciels modernes. Dans un contexte réel, un développeur a besoin de ces concepts pour créer des applications complexes et maintenir du code organisé et modulaire. Par exemple, lors du développement d'une application web, vous aurez besoin de classes pour représenter les utilisateurs, les tâches, et les articles, tandis que les objets seront les instances spécifiques de ces classes.

Prerequis

• Connaissances en programmation Python de base
• Compétence en gestion des packages avec pip
• Familiarité avec la structure d'un projet Python

Outils à installer :

• Python 3.x (version recommandée : 3.9)
• Un environnement de développement intégré (IDE) comme PyCharm, VSCode ou Sublime Text
• pip pour installer les packages requis

Concepts fondamentaux

1. Définition d'une classe

Une classe est une définition qui décrit comment créer un objet et ce qu'il peut faire. Elle sert de modèle ou de plan.

class Voiture:
    # Méthode initiale pour initialiser les attributs
    def __init__(self, marque, modele):
        self.marque = marque
        self.modele = modele
    
    # Méthode pour afficher des informations sur la voiture
    def afficher_info(self):
        print(f"Voiture {self.marque} {self.modele}")

2. Création d'un objet

Un objet est une instance de classe. Lorsqu'on crée un objet, on appelle cela "instantiation".

ma_voiture = Voiture("Toyota", "Corolla")
ma_voiture.afficher_info()  # Affiche : Voiture Toyota Corolla

3. Attributs et méthodes

Les attributs sont les données associées à un objet, tandis que les méthodes sont des fonctions qui définissent le comportement de l'objet.

class Personne:
    def __init__(self, nom, age):
        self.nom = nom  # Attribut public
        self._age = age  # Attribut privé
        
    def get_age(self):  # Méthode pour accéder à l'attribut privé
        return self._age

personne = Personne("Alice", 30)
print(personne.nom)  # Accès à l'attribut public
## 

4. Héritage

L'héritage permet de créer une classe qui est basée sur une autre classe existante. La nouvelle classe hérite des attributs et méthodes de la classe parente.

class Employe(Personne):
    def __init__(self, nom, age, employeur):
        super().__init__(nom, age)
        self.employeur = employeur
    
    def afficher_info(self):
        super().afficher_info()
        print(f"Employé chez {self.employeur}")

employe = Employe("Bob", 40, "TechCorp")
employe.afficher_info()  # Affiche : Voiture Bob 40

5. Polymorphisme

Le polymorphisme permet de redéfinir les méthodes d'une classe parente dans une classe enfant pour changer leur comportement.

class Animal:
    def parler(self):
        pass

class Chien(Animal):
    def parler(self):
        return "Woof!"

class Chat(Animal):
    def parler(self):
        return "Meow!"

def faire_parler(animal):
    print(animal.parler())

chien = Chien()
chat = Chat()

faire_parler(chien)  # Affiche : Woof!
faire_parler(chat)   # Affiche : Meow!

Mise en pratique : projet fil rouge

Nous allons créer un simple gestionnaire de tâches. Ce projet comprendra une classe Tache pour représenter chaque tâche et une classe GestionnaireTaches pour gérer une collection de tâches.

Étape 1 : Définir la classe Tache

class Tache:
    def __init__(self, titre, description):
        self.titre = titre
        self.description = description
        self.terminée = False
    
    def marquer_en tant_qu_terminée(self):
        self.terminée = True
    
    def __str__(self):
        return f"{self.titre} - {self.description} (Terminée: {'Oui' if self.terminée else 'Non'})"

Étape 2 : Définir la classe GestionnaireTaches

from typing import List

class GestionnaireTaches:
    def __init__(self):
        self.taches: List[Tache] = []
    
    def ajouter_tache(self, tache: Tache):
        self.taches.append(tache)
    
    def marquer_tache_en_tant_qu_terminée(self, titre):
        for t in self.taches:
            if t.titre == titre:
                t.marquer_en_tant_qu_terminée()
                break
    
    def afficher_toutes_les_taches(self):
        for t in self.taches:
            print(t)

## 
g = GestionnaireTaches()
t1 = Tache("Faire les courses", "Acheter du lait, du pain et des œufs.")
g.ajouter_tache(t1)
g.marquer_tache_en_tant_qu_terminée("Faire les courses")
g.afficher_toutes_les_taches()

Étape 3 : Exécuter le code

python gestionnaires_taches.py

Erreurs frequentes et debugging

1. Tentative d'accéder à un attribut privé

Code incorrect :

class Personne:
    def __init__(self, nom):
        self._nom = nom
    
    def get_nom(self):
        return self._nom

personne = Personne("Alice")
print(personne._nom)  # Tentative d'accéder à l'attribut privé directement

Code correct :

class Personne:
    def __init__(self, nom):
        self._nom = nom
    
    def get_nom(self):
        return self._nom

personne = Personne("Alice")
print(personne.get_nom())  # Utilisation de la méthode pour accéder à l'attribut privé

2. Tentative d'appeler une méthode non définie

Code incorrect :

class Personne:
    def __init__(self, nom):
        self.nom = nom
    
    def afficher(self):
        print(f"Nom : {self.nom}")

personne = Personne("Alice")
personne.imprimer()  # Méthode non définie

Code correct :

class Personne:
    def __init__(self, nom):
        self.nom = nom
    
    def afficher(self):
        print(f"Nom : {self.nom}")

personne = Personne("Alice")
personne.afficher()  # Correction de la méthode appelée

3. Erreur d'héritage

Code incorrect :

class Animal:
    pass

class Chien(Animal):
    def aboyer(self):
        return "Woof!"

chien = Chien()
print(chien.aboyer())

Code correct :

class Animal:
    def aboyer(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Chien(Animal):
    def aboyer(self):
        return "Woof!"

chien = Chien()
print(chien.aboyer())  # Correction de l'héritage

Pour aller plus loin

1. Interfaces et abstraction : Apprenez à utiliser les interfaces pour définir des méthodes sans implémentations, ce qui permet une meilleure séparation des concerns.
2. Décors : Explorez la puissance des décorateurs en Python pour modifier le comportement de fonctions ou de méthodes.
3. Patrons de conception avancés : Enseignez-vous les patron de conception comme le Singleton, l'Observer et l'Adapter pour résoudre des problèmes complexes.

Défi pratique

Créez une application simple en ligne qui permet aux utilisateurs de créer, mettre à jour et supprimer des notes. Utilisez des classes Note et GestionnaireNotes pour gérer les notes et implémentez l'interface utilisateur avec un script Python.