La Programmation Orientée Objet (POO) est une manière de structurer un programme en organisant les données et les comportements en objets. Ces objets sont comme des "entités" qui regroupent :
Imaginons que vous construisez un jeu qui simule un zoo. Dans ce zoo :
En POO, vous créez des "modèles" pour représenter ces animaux. Ces modèles sont appelés des classes.
Une classe est un modèle ou un plan pour créer des objets. Par exemple, la classe "Animal" définit ce que chaque animal possédera comme attributs et méthodes.
Un objet est une instance de cette classe. Par exemple, "Léo le lion" est un objet de la classe "Animal".
Les attributs sont des variables qui stockent les données spécifiques à chaque objet.
Ex. : Le nom, l’âge ou la couleur d’un animal.
Les méthodes sont des fonctions définies dans une classe, qui décrivent les actions possibles pour un objet.
Ex. : Manger, dormir ou rugir pour un animal.
En Python, une classe est définie avec le mot-clé class. Voici un exemple simple :
Exemple de classe vide :
# Définir une classe "Animal"
class Animal:
pass # Pour l'instant, la classe est videUne fois la classe définie, vous pouvez créer un objet (ou instance) de cette classe en l’appelant comme une fonction.
Exemple :
# Créer un objet de la classe Animal
mon_animal = Animal()
print(mon_animal)
>> <__main__.Animal object at 0x...>Pour ajouter des attributs à un objet, on peut les affecter directement après la création de l'objet.
Exemple :
# Ajouter des attributs à l'objet
mon_animal.nom = "Léo"
mon_animal.age = 5
# Afficher les attributs
print(f"Nom : {mon_animal.nom}, Âge : {mon_animal.age}")
>> Nom : Léo, Âge : 5Au lieu d’ajouter les attributs un par un, vous pouvez utiliser une méthode spéciale appelée constructeur pour les définir automatiquement à la création de l’objet. En Python, cette méthode est __init__.
Exemple :
class Animal:
def __init__(self, nom: str, age: int) -> None:
self.nom = nom # Attribut nom
self.age = age # Attribut âge
# Créer un objet avec des attributs directement
mon_animal = Animal("Léo", 5)
print(f"Nom : {mon_animal.nom}, Âge : {mon_animal.age}")
>> Nom : Léo, Âge : 5Les méthodes sont des fonctions définies dans une classe qui décrivent les actions d'un objet. Elles utilisent toujours self comme premier paramètre pour accéder aux attributs de l'objet.
Exemple :
class Animal:
def __init__(self, nom: str, age: int) -> None:
self.nom = nom
self.age = age
def parler(self) -> None:
print(f"{self.nom} fait un bruit.")
# Créer un objet et appeler une méthode
mon_animal = Animal("Léo", 5)
mon_animal.parler()
>> Léo fait un bruit.Exemple complet :
class Animal:
def __init__(self, nom: str, espece: str, age: int) -> None:
self.nom = nom
self.espece = espece
self.age = age
def manger(self) -> None:
print(f"{self.nom} est en train de manger.")
def se_presenter(self) -> None:
print(f"Je suis {self.nom}, un {self.espece} de {self.age} ans.")
# Créer des objets
animal1 = Animal("Léo", "lion", 5)
animal2 = Animal("Mimi", "chat", 2)
# Utiliser les objets
animal1.se_presenter()
animal2.manger()
>> Je suis Léo, un lion de 5 ans.
>> Mimi est en train de manger.selfself ?Dans une méthode d’une classe, le mot-clé self est une référence à l'objet actuel. Il permet d'accéder aux attributs et méthodes de l'objet à l'intérieur de la classe.
self doit être le premier paramètre de toutes les méthodes d'instance.self.Exemple :
class Animal:
def __init__(self, nom: str) -> None:
self.nom = nom # Attribut d'instance
def parler(self) -> None:
print(f"{self.nom} fait un bruit.")
# Créer un objet
chat = Animal("Mimi")
chat.parler()
>> Mimi fait un bruit.
# Ici, "chat" est passé automatiquement à la méthode comme self.Un attribut d’instance est lié à l’objet (avec self.nom). Il est accessible dans toutes les méthodes de l'objet.
Un attribut local est une variable définie à l’intérieur d’une méthode, et elle n’est pas accessible en dehors.
Exemple :
class Animal:
def __init__(self, nom: str) -> None:
self.nom = nom # Attribut d'instance
def description(self) -> None:
attribut_local = "temporaire" # Attribut local
print(f"{self.nom} a un attribut local : {attribut_local}")
chien = Animal("Rex")
chien.description()
>> Sortie : Rex a un attribut local : temporaire
print(attribut_local)
# Erreur : attribut_local n'existe pas en dehors de la méthode.__str__ pour personnaliser l'affichage__str__La méthode spéciale __str__ permet de définir ce qui sera affiché lorsque vous utilisez print() sur un objet.
Exemple :
class Animal:
def __init__(self, nom: str, espece: str) -> None:
self.nom = nom
self.espece = espece
def __str__(self) -> str:
return f"{self.nom} est un {self.espece}."
# Créer un objet
chien = Animal("Rex", "chien")
print(chien)
>> Sortie : Rex est un chien.__str__Une variable de classe est une variable partagée par toutes les instances d’une classe. Contrairement aux attributs d’instance, qui sont propres à chaque objet, une variable de classe est unique pour la classe entière.
Exemple :
class Animal:
population = 0 # Variable de classe
def __init__(self, nom: str) -> None:
self.nom = nom # Attribut d'instance
Animal.population += 1 # Incrémente la population
# Créer des instances
animal1 = Animal("Léo")
animal2 = Animal("Mimi")
print(f"Population totale : {Animal.population}")
# Sortie : Population totale : 2
# La variable de classe est partagée par toutes les instances
print(animal1.population)
print(animal2.population)
>> 2
>> 2Une méthode de classe agit sur la classe elle-même, pas sur une instance particulière. Pour définir une méthode de classe, on utilise le décorateur @classmethod et un paramètre cls (référence à la classe).
Exemple :
class Animal:
population = 0 # Variable de classe
def __init__(self, nom: str) -> None:
self.nom = nom
Animal.population += 1
@classmethod
def afficher_population(cls) -> None:
print(f"Population totale : {cls.population}")
# Appeler la méthode de classe
Animal.afficher_population()
lion = Animal("Léo")
Animal.afficher_population()
>> Population totale : 0
>> Population totale : 1L’héritage permet de créer une nouvelle classe (appelée classe enfant) à partir d’une classe existante (appelée classe parent). La classe enfant hérite des attributs et méthodes de la classe parent, mais peut aussi ajouter ou modifier des fonctionnalités.
Imaginons une classe parent Animal et une classe enfant Chien.
Exemple :
class Animal:
def __init__(self, nom: str) -> None:
self.nom = nom
def parler(self) -> None:
print(f"{self.nom} fait un bruit.")
# Classe enfant
class Chien(Animal):
def __init__(self, nom: str) -> None:
super().__init__(nom)
def parler(self) -> None:
print(f"{self.nom} aboie.")
# Créer des objets
animal = Animal("Léo")
chien = Chien("Rex")
animal.parler()
chien.parler()
>> Léo fait un bruit.
>> Rex aboie.Définissez une classe Personne avec les attributs nom et age.
Ajoutez une méthode se_presenter qui affiche : "Je m'appelle [nom] et j'ai [age] ans."
Créez deux objets Personne et appelez leur méthode se_presenter.
Ajoutez une méthode est_majeur qui retourne True si l’âge est supérieur ou égal à 18, sinon False.
Créez un objet et affichez un message indiquant si la personne est majeure.
Définissez une classe Voiture avec les attributs marque, modele et annee.
Ajoutez une méthode decrire qui affiche les informations sur la voiture.
Créez un objet Voiture et utilisez la méthode decrire.
Ajoutez un attribut distance à la classe Voiture pour stocker la distance parcourue.
Ajoutez une méthode avancer qui augmente la distance.
Affichez la distance totale parcourue après plusieurs appels à avancer.
Créez une classe Livre avec les attributs titre, auteur et disponible (booléen).
Ajoutez les méthodes :
emprunter : marque le livre comme emprunté si disponible.retourner : marque le livre comme disponible.Testez en créant plusieurs livres et en appelant ces méthodes.
Créez une classe CompteBancaire avec :
titulaire pour le nom du titulaire.solde initialisé à 0.Ajoutez les méthodes :
deposer pour ajouter de l'argent au solde.retirer pour retirer de l'argent si le solde est suffisant.afficher_solde pour afficher le solde actuel.Testez la classe avec plusieurs opérations.
Créez une classe Employe avec les attributs nom et salaire.
Ajoutez une variable de classe nombre_employes, initialisée à 0.
Dans le constructeur, augmentez la variable nombre_employes de 1 à chaque création d’un employé.
Ajoutez une méthode afficher_nombre_employes (méthode de classe) qui affiche le nombre total d’employés.
Créez plusieurs employés et utilisez la méthode pour afficher le nombre total d’employés créés.
Créez une classe Jouet avec :
nom (le nom du jouet).description() qui affiche : "Ceci est un jouet nommé [nom]".Créez deux classes enfants Peluche et Voiture qui héritent de Jouet :
Peluche :matiere (par exemple : "coton").serrer() qui affiche : "Vous serrez [nom] en peluche, en [matiere], c'est si doux !".Voiture :vitesse_max (en km/h).conduire() qui affiche : "Vous conduisez [nom], elle peut aller jusqu'à [vitesse_max] km/h !".Testez votre code :
description(), serrer() et conduire().Exemple de sortie attendue :
>> Ceci est un jouet nommé Ours
>> Vous serrez Ours en peluche, en coton, c'est si doux !
>> Ceci est un jouet nommé Ferrari
>> Vous conduisez Ferrari, elle peut aller jusqu'à 300 km/h !