À l'issue de ce chapitre, vous serez capable de comprendre les principes fondamentaux de la programmation orientée objet et leur application en Python. Vous maîtriserez la création de classes simples, l'instanciation d'objets, ainsi que la définition d'attributs et de méthodes. Ce chapitre vous permettra d'appréhender les avantages de la POO par rapport à la programmation procédurale.
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.
La POO organise le code autour d'objets plutôt que d'actions et de logique. Les quatre piliers fondamentaux sont :
# Exemple simple d'une classe en Python class Personne: # Constructeur def __init__(self, nom, age): self.nom = nom # Attribut d'instance self.age = age # Méthode d'instance def se_presenter(self): return f"Je m'appelle {self.nom} et j'ai {self.age} ans." # Création d'une instance personne1 = Personne("Alice", 30) print(personne1.se_presenter()) # Je m'appelle Alice et j'ai 30 ans.
La programmation orientée objet offre plusieurs avantages significatifs :
# Exemple de réutilisabilité avec l'héritage class Employe(Personne): # Hérite de Personne def __init__(self, nom, age, salaire): # Appel du constructeur parent super().__init__(nom, age) self.salaire = salaire def se_presenter(self): # Surcharge de méthode (polymorphisme) presentation = super().se_presenter() return f"{presentation} Mon salaire est {self.salaire}€." # Utilisation de la classe héritée employe1 = Employe("Bob", 35, 3000) print(employe1.se_presenter()) # Je m'appelle Bob et j'ai 35 ans. Mon salaire est 3000€.
Contrairement à la programmation procédurale qui se concentre sur les fonctions et procédures, la POO se concentre sur les objets et leurs interactions :
| Aspect | Programmation Procédurale | Programmation Orientée Objet |
|---|---|---|
| Approche | Diviser le programme en fonctions | Diviser le programme en objets |
| Accès aux données | Les fonctions opèrent sur des données séparées | Les méthodes opèrent sur les données de l'objet |
| Réutilisabilité | Limitée, basée sur les fonctions | Élevée, basée sur les classes et l'héritage |
| Sécurité des données | Faible, données accessibles globalement | Élevée, encapsulation des données |
# Approche procédurale def calculer_surface_rectangle(longueur, largeur): return longueur * largeur def calculer_perimetre_rectangle(longueur, largeur): return 2 * (longueur + largeur) # Utilisation longueur = 5 largeur = 3 surface = calculer_surface_rectangle(longueur, largeur) perimetre = calculer_perimetre_rectangle(longueur, largeur) # Approche orientée objet class Rectangle: def __init__(self, longueur, largeur): self.longueur = longueur self.largeur = largeur def calculer_surface(self): return self.longueur * self.largeur def calculer_perimetre(self): return 2 * (self.longueur + self.largeur) # Utilisation rect = Rectangle(5, 3) surface = rect.calculer_surface() perimetre = rect.calculer_perimetre()
La Programmation Orientée Objet repose sur quatre concepts fondamentaux qui permettent de structurer le code de manière modulaire, réutilisable et maintenable.
Une classe est un modèle ou un plan qui définit la structure et le comportement d'objets. Un objet est une instance spécifique d'une classe, avec ses propres valeurs d'attributs.
# Définition d'une classe class Voiture: # Attribut de classe (partagé par toutes les instances) roues = 4 # Constructeur (méthode spéciale) def __init__(self, marque, modele, couleur): # Attributs d'instance (spécifiques à chaque objet) self.marque = marque self.modele = modele self.couleur = couleur self.km = 0 # Valeur par défaut # Méthode d'instance def rouler(self, distance): self.km += distance return f"La voiture a roulé {distance} km. Total: {self.km} km" # Méthode spéciale pour l'affichage def __str__(self): return f"{self.marque} {self.modele} ({self.couleur})" # Création d'objets (instances de la classe) ma_voiture = Voiture("Renault", "Clio", "rouge") ta_voiture = Voiture("Peugeot", "208", "bleue") # Utilisation des objets print(ma_voiture) # Renault Clio (rouge) print(ta_voiture) # Peugeot 208 (bleue) print(ma_voiture.rouler(100)) # La voiture a roulé 100 km. Total: 100 km print(f"Toutes les voitures ont {Voiture.roues} roues") # Toutes les voitures ont 4 roues
L'encapsulation est le mécanisme qui restreint l'accès direct à certains composants d'un objet et regroupe les données et les méthodes qui opèrent sur ces données.
class CompteBancaire: def __init__(self, titulaire, solde_initial=0): self.titulaire = titulaire self._solde = solde_initial # Attribut "protégé" (convention) self.__code_secret = "1234" # Attribut "privé" (name mangling) # Méthode publique pour accéder au solde def get_solde(self): return self._solde # Méthode publique pour modifier le solde de manière contrôlée def deposer(self, montant): if montant > 0: self._solde += montant return True return False # Méthode publique pour retirer de l'argent def retirer(self, montant, code): if code == self.__code_secret and montant > 0 and montant <= self._solde: self._solde -= montant return True return False # Méthode pour changer le code secret def changer_code(self, ancien_code, nouveau_code): if ancien_code == self.__code_secret: self.__code_secret = nouveau_code return True return False # Utilisation de la classe compte = CompteBancaire("Alice", 1000) print(compte.get_solde()) # 1000 compte.deposer(500) print(compte.get_solde()) # 1500 compte.retirer(200, "1234") print(compte.get_solde()) # 1300 # Tentative d'accès direct aux attributs protégés/privés print(compte._solde) # Possible mais déconseillé (1300) # print(compte.__code_secret) # Erreur: AttributeError # print(compte._CompteBancaire__code_secret) # Accès possible mais fortement déconseillé
L'héritage permet à une classe (classe enfant) d'hériter des attributs et méthodes d'une autre classe (classe parent), favorisant la réutilisabilité du code.
# Classe parent (superclasse) class Animal: def __init__(self, nom, age): self.nom = nom self.age = age def se_decrire(self): return f"{self.nom} a {self.age} an(s)" def parler(self): return "Je ne sais pas quel son faire" # Classe enfant (sous-classe) - Héritage simple class Chien(Animal): def __init__(self, nom, age, race): # Appel du constructeur de la classe parent super().__init__(nom, age) self.race = race # Surcharge de méthode (method overriding) def parler(self): return "Woof!" # Méthode spécifique à la classe Chien def remuer_la_queue(self): return f"{self.nom} remue la queue joyeusement!" # Autre classe enfant class Chat(Animal): def parler(self): return "Miaou!" # Méthode spécifique à la classe Chat def ronronner(self): return "Rrrrrr..." # Héritage multiple class AnimalDomestique: def __init__(self, proprietaire): self.proprietaire = proprietaire def saluer_proprietaire(self): return f"Bonjour {self.proprietaire}!" class ChienDomestique(Chien, AnimalDomestique): def __init__(self, nom, age, race, proprietaire): Chien.__init__(self, nom, age, race) AnimalDomestique.__init__(self, proprietaire) # Utilisation des classes mon_chien = Chien("Rex", 3, "Labrador") mon_chat = Chat("Misty", 2) print(mon_chien.se_decrire()) # Rex a 3 an(s) (hérité de Animal) print(mon_chien.parler()) # Woof! (surchargé dans Chien) print(mon_chien.remuer_la_queue()) # Rex remue la queue joyeusement! (spécifique à Chien) print(mon_chat.parler()) # Miaou! (surchargé dans Chat) print(mon_chat.ronronner()) # Rrrrrr... (spécifique à Chat) # Héritage multiple chien_familial = ChienDomestique("Buddy", 5, "Golden Retriever", "Alice") print(chien_familial.saluer_proprietaire()) # Bonjour Alice! (hérité de AnimalDomestique) print(chien_familial.parler()) # Woof! (hérité de Chien)
Le polymorphisme permet à des objets de différentes classes de répondre à la même méthode de manière différente, offrant une interface commune.
# Polymorphisme avec héritage class Forme: def aire(self): pass def __str__(self): return "Forme géométrique" class Rectangle(Forme): def __init__(self, longueur, largeur): self.longueur = longueur self.largeur = largeur def aire(self): return self.longueur * self.largeur def __str__(self): return f"Rectangle({self.longueur}x{self.largeur})" class Cercle(Forme): def __init__(self, rayon): self.rayon = rayon def aire(self): return 3.14 * self.rayon * self.rayon def __str__(self): return f"Cercle(rayon={self.rayon})" # Polymorphisme sans héritage (duck typing) class Triangle: def __init__(self, base, hauteur): self.base = base self.hauteur = hauteur def aire(self): return (self.base * self.hauteur) / 2 def __str__(self): return f"Triangle(base={self.base}, hauteur={self.hauteur})" # Fonction utilisant le polymorphisme def afficher_aire(forme): print(f"L'aire de {forme} est {forme.aire()}") # Utilisation du polymorphisme formes = [ Rectangle(5, 3), Cercle(4), Triangle(6, 2) # Duck typing: n'hérite pas de Forme mais a une méthode aire() ] for forme in formes: afficher_aire(forme) # L'aire de Rectangle(5x3) est 15 # L'aire de Cercle(rayon=4) est 50.24 # L'aire de Triangle(base=6, hauteur=2) est 6.0 # Méthodes spéciales et polymorphisme class Vecteur: def __init__(self, x, y): self.x = x self.y = y # Surcharge de l'opérateur + def __add__(self, autre): return Vecteur(self.x + autre.x, self.y + autre.y) # Surcharge de l'opérateur * def __mul__(self, scalaire): return Vecteur(self.x * scalaire, self.y * scalaire) def __str__(self): return f"Vecteur({self.x}, {self.y})" # Utilisation des opérateurs surchargés v1 = Vecteur(2, 3) v2 = Vecteur(1, 4) v3 = v1 + v2 # Appelle v1.__add__(v2) v4 = v1 * 3 # Appelle v1.__mul__(3) print(v3) # Vecteur(3, 7) print(v4) # Vecteur(6, 9)
Python est un langage qui supporte pleinement la programmation orientée objet tout en restant flexible et accessible. Il implémente tous les concepts clés de la POO avec une syntaxe claire et concise.
Python présente plusieurs caractéristiques distinctives dans son implémentation de la POO :
# Duck typing - On se soucie du comportement, pas du type class Canard: def nager(self): return "Canard nage" def voler(self): return "Canard vole" class Bateau: def nager(self): return "Bateau navigue" def faire_nager(objet): print(objet.nager()) # Les deux objets peuvent être utilisés interchangeables faire_nager(Canard()) # Canard nage faire_nager(Bateau()) # Bateau navigue # Tout est objet en Python nombre = 42 chaine = "hello" liste = [1, 2, 3] print(type(nombre)) # <class 'int'> print(type(chaine)) # <class 'str'> print(type(liste)) # <class 'list'> # Properties pour contrôler l'accès aux attributs class Temperature: def __init__(self, celsius=0): self._celsius = celsius def to_fahrenheit(self): return (self._celsius * 9/5) + 32 # Getter def get_celsius(self): print("Getting value") return self._celsius # Setter def set_celsius(self, value): if value < -273.15: raise ValueError("Temperature below absolute zero") print("Setting value") self._celsius = value # Property celsius = property(get_celsius, set_celsius) temp = Temperature(25) print(temp.celsius) # Appelle get_celsius() temp.celsius = 30 # Appelle set_celsius(30) print(temp.to_fahrenheit()) # 86.0
La définition d'une classe en Python suit une syntaxe simple mais puissante :
# Syntaxe de base pour définir une classe class MaClasse: # Variable de classe (partagée par toutes les instances) variable_classe = "valeur partagée" # Constructeur (méthode spéciale __init__) def __init__(self, param1, param2): # Variables d'instance (spécifiques à chaque objet) self.param1 = param1 self.param2 = param2 self._variable_protegee = "protégée" # Convention pour protégé self.__variable_privee = "privée" # Name mangling pour privé # Méthode d'instance (premier paramètre: self) def methode_instance(self): return f"Instance avec param1={self.param1}, param2={self.param2}" # Méthode de classe (décorateur @classmethod) @classmethod def methode_classe(cls): return f"Méthode de classe, variable_classe={cls.variable_classe}" # Méthode statique (décorateur @staticmethod) @staticmethod def methode_statique(): return "Méthode statique, pas d'accès à self ni cls" # Méthode spéciale pour la représentation en string def __str__(self): return f"MaClasse(param1={self.param1}, param2={self.param2})" # Property avec décorateur (manière moderne) @property def variable_protegee(self): return self._variable_protegee @variable_protegee.setter def variable_protegee(self, value): self._variable_protegee = value # Héritage class MaSousClasse(MaClasse): def __init__(self, param1, param2, param3): super().__init__(param1, param2) self.param3 = param3 # Surcharge de méthode def __str__(self): return f"MaSousClasse(param1={self.param1}, param2={self.param2}, param3={self.param3})" # Classes abstraites (à partir de Python 3.4+) from abc import ABC, abstractmethod class FormeAbstraite(ABC): @abstractmethod def aire(self): pass @abstractmethod def perimetre(self): pass class CercleConcret(FormeAbstraite): def __init__(self, rayon): self.rayon = rayon def aire(self): return 3.14159 * self.rayon * self.rayon def perimetre(self): return 2 * 3.14159 * self.rayon
La création d'instances (objets) en Python est simple et intuitive :
# Définition d'une classe simple class Personne: def __init__(self, nom, age): self.nom = nom self.age = age def se_presenter(self): return f"Je m'appelle {self.nom} et j'ai {self.age} ans." # Création d'instances (objets) personne1 = Personne("Alice", 30) # Appel du constructeur personne2 = Personne("Bob", 25) personne3 = Personne("Charlie", 35) # Accès aux attributs et méthodes print(personne1.nom) # Alice print(personne2.age) # 25 print(personne3.se_presenter()) # Je m'appelle Charlie et j'ai 35 ans. # Modification des attributs personne1.age = 31 print(personne1.se_presenter()) # Je m'appelle Alice et j'ai 31 ans. # Création dynamique d'attributs (possible en Python) personne1.ville = "Paris" print(personne1.ville) # Paris # Vérification du type print(type(personne1)) # <class '__main__.Personne'> print(isinstance(personne1, Personne)) # True # Comparaison d'objets personne4 = Personne("Alice", 31) print(personne1 == personne4) # False (ce sont des objets différents) print(personne1.nom == personne4.nom and personne1.age == personne4.age) # True # Création d'objets avec des valeurs par défaut class Voiture: def __init__(self, marque, modele, couleur="blanc"): self.marque = marque self.modele = modele self.couleur = couleur self.kilometrage = 0 # Toujours initialisé à 0 def rouler(self, km): self.kilometrage += km return self.kilometrage # Instanciation avec paramètres par défaut voiture1 = Voiture("Renault", "Clio") # Couleur par défaut: blanc voiture2 = Voiture("Peugeot", "208", "bleu") print(voiture1.couleur) # blanc print(voiture2.couleur) # bleu # Utilisation des méthodes voiture1.rouler(100) voiture1.rouler(50) print(voiture1.kilometrage) # 150 # Création d'une liste d'objets personnes = [ Personne("Alice", 30), Personne("Bob", 25), Personne("Charlie", 35) ] # Parcours de la liste d'objets for personne in personnes: print(personne.se_presenter()) # Filtrage d'objets jeunes = [p for p in personnes if p.age < 30] print(f"Jeunes: {len(jeunes)}") # Jeunes: 1 (Bob)
Créer sa première classe en Python est une étape fondamentale pour comprendre la programmation orientée objet. Une classe est un modèle qui définit les attributs et méthodes que posséderont les objets créés à partir d'elle.
La structure de base d'une classe en Python comprend le mot-clé class, le nom de la classe (en PascalCase par convention), et une suite d'attributs et méthodes.
# Structure de base d'une classe Python class MaPremiereClasse: # Variable de classe (partagée par toutes les instances) type_objet = "Générique" compteur = 0 # Compteur partagé # Constructeur (méthode spéciale) def __init__(self, nom, valeur=0): # Variables d'instance (uniques à chaque objet) self.nom = nom self.valeur = valeur self.est_actif = False # Valeur par défaut # Incrémentation du compteur à chaque création d'instance MaPremiereClasse.compteur += 1 # Méthode d'instance (premier paramètre: self) def afficher_info(self): return f"Objet {self.nom} de type {self.type_objet} avec valeur {self.valeur}" # Méthode pour modifier l'état def activer(self): self.est_actif = True return f"{self.nom} est maintenant activé" # Méthode de classe (décorateur @classmethod) @classmethod def afficher_compteur(cls): return f"Nombre total d'instances créées: {cls.compteur}" # Méthode statique (décorateur @staticmethod) @staticmethod def description(): return "Ceci est une classe de démonstration pour apprendre la POO en Python" # Méthode spéciale pour l'affichage def __str__(self): return f"{self.nom} (valeur: {self.valeur}, actif: {self.est_actif})" # Exemple d'utilisation print("=== Structure d'une classe simple ===") print(MaPremiereClasse.description()) # Méthode statique # Création d'instances objet1 = MaPremiereClasse("Premier", 10) objet2 = MaPremiereClasse("Second") # Valeur par défaut: 0 print(objet1.afficher_info()) # Objet Premier de type Générique avec valeur 10 print(objet2.afficher_info()) # Objet Second de type Générique avec valeur 0 print(objet1.activer()) # Premier est maintenant activé print(objet1) # Premier (valeur: 10, actif: True) print(MaPremiereClasse.afficher_compteur()) # Nombre total d'instances créées: 2
Le constructeur __init__ est une méthode spéciale appelée automatiquement à la création d'une nouvelle instance. Il permet d'initialiser les attributs de l'objet.
# Exemples détaillés du constructeur __init__ class Personne: # Constructeur avec paramètres obligatoires def __init__(self, nom, prenom): self.nom = nom self.prenom = prenom self.age = 0 # Attribut avec valeur par défaut self.email = "" # Attribut vide initialement self._id = id(self) # Utilisation de la fonction id() # Appel d'une méthode depuis le constructeur self._generer_email() def _generer_email(self): # Méthode interne pour générer un email self.email = f"{self.prenom.lower()}.{self.nom.lower()}@entreprise.com" def __str__(self): return f"{self.prenom} {self.nom} ({self.email})" class Livre: # Constructeur avec paramètres optionnels et valeurs par défaut def __init__(self, titre, auteur, annee_publication=2023, est_disponible=True): self.titre = titre self.auteur = auteur self.annee_publication = annee_publication self.est_disponible = est_disponible self.nombre_pages = 0 # À définir plus tard # Validation des données dans le constructeur if annee_publication > 2023: raise ValueError("L'année de publicatioLes attributs d'instancen ne peut pas être dans le futur") def definir_pages(self, pages): if pages > 0: self.nombre_pages = pages else: raise ValueError("Le nombre de pages doit être positif") def __str__(self): disponibilité = "Disponible" if self.est_disponible else "Indisponible" return f"'{self.titre}' par {self.auteur} ({self.annee_publication}) - {disponibilité}" class CompteBancaire: # Constructeur avec attribution conditionnelle def __init__(self, titulaire, solde_initial=0, type_compte="Courant"): self.titulaire = titulaire self.solde = solde_initial self.type_compte = type_compte self.est_actif = True self.numero_compte = self._generer_numero() # Logique conditionnelle dans le constructeur if type_compte == "Épargne" and solde_initial < 100: print("Attention: solde minimum recommandé de 100€ pour un compte épargne") def _generer_numero(self): # Génération d'un numéro de compte (simulé) import random return "FR76" + "".join(str(random.randint(0, 9)) for _ in range(12)) def afficher_solde(self): return f"Solde du compte {self.numero_compte}: {self.solde}€" # Utilisation des différents constructeurs print("\n=== Exemples de constructeurs ===") # Personne - constructeur avec paramètres obligatoires personne = Personne("DUPONT", "Marie") print(personne) # Marie DUPONT (marie.dupont@entreprise.com) # Livre - constructeur avec paramètres optionnels livre1 = Livre("Python pour les nuls", "John Doe", 2022) livre2 = Livre("Apprendre la POO", "Jane Smith", est_disponible=False) print(livre1) # 'Python pour les nuls' par John Doe (2022) - Disponible print(livre2) # 'Apprendre la POO' par Jane Smith (2023) - Indisponible # CompteBancaire - constructeur avec logique conditionnelle compte1 = CompteBancaire("Pierre Martin", 500, "Courant") compte2 = CompteBancaire("Sophie Leroy", 50, "Épargne") # Affiche un avertissement print(compte1.afficher_solde()) print(compte2.afficher_solde())
Les attributs d'instance sont des variables spécifiques à chaque objet créé à partir d'une classe. Ils définissent l'état de l'objet.
# Exemples détaillés des attributs d'instance class Voiture: # Attribut de classe (partagé) nombre_roues = 4 def __init__(self, marque, modele, annee, couleur="blanc"): # Attributs d'instance (uniques à chaque objet) self.marque = marque self.modele = modele self.annee = annee self.couleur = couleur self.kilometrage = 0 # Attribut avec valeur par défaut self.est_en_marche = False self.proprietaire = "Inconnu" # À définir ultérieurement def demarrer(self): self.est_en_marche = True return f"La {self.marque} {self.modele} a démarré" def arreter(self): self.est_en_marche = False return f"La {self.marque} {self.modele} s'est arrêtée" def rouler(self, km): if self.est_en_marche: self.kilometrage += km return f"La voiture a roulé {km} km. Total: {self.kilometrage} km" else: return "La voiture doit d'abord démarrer" def changer_proprietaire(self, nouveau_proprietaire): ancien_proprietaire = self.proprietaire self.proprietaire = nouveau_proprietaire return f"Propriétaire changé de {ancien_proprietaire} à {nouveau_proprietaire}" def peindre(self, nouvelle_couleur): ancienne_couleur = self.couleur self.couleur = nouvelle_couleur return f"Voiture repeinte de {ancienne_couleur} à {nouvelle_couleur}" def age(self, annee_actuelle): return annee_actuelle - self.annee def __str__(self): statut = "en marche" if self.est_en_marche else "arrêtée" return f"{self.marque} {self.modele} ({self.annee}, {self.couleur}) - {self.kilometrage} km - {statut}" # Utilisation des attributs d'instance print("\n=== Attributs d'instance ===") # Création d'une instance ma_voiture = Voiture("Renault", "Clio", 2020, "bleue") ta_voiture = Voiture("Peugeot", "208", 2022) # Couleur par défaut: blanc # Accès aux attributs print(f"Marque: {ma_voiture.marque}") print(f"Modèle: {ma_voiture.modele}") print(f"Couleur: {ma_voiture.couleur}") print(f"Kilométrage initial: {ma_voiture.kilometrage} km") # Modification des attributs print(ma_voiture.peindre("rouge")) # Voiture repeinte de bleue à rouge print(ma_voiture.changer_proprietaire("Alice Dupont")) # Propriétaire changé de Inconnu à Alice Dupont # Utilisation des méthodes qui modifient l'état print(ma_voiture.demarrer()) # La Renault Clio a démarré print(ma_voiture.rouler(150)) # La voiture a roulé 150 km. Total: 150 km print(ma_voiture.rouler(50)) # La voiture a roulé 50 km. Total: 200 km print(ma_voiture.arreter()) # La Renault Clio s'est arrêtée # Affichage de l'état complet print(ma_voiture) # Renault Clio (2020, rouge) - 200 km - arrêtée print(ta_voiture) # Peugeot 208 (2022, blanc) - 0 km - arrêtée # Calcul basé sur les attributs print(f"Âge de la voiture: {ma_voiture.age(2023)} ans") # Âge de la voiture: 3 ans # Attribut de classe (partagé) print(f"Toutes les voitures ont {Voiture.nombre_roues} roues") # Toutes les voitures ont 4 roues
Les méthodes d'instance sont des fonctions définies à l'intérieur d'une classe qui opèrent sur les objets créés à partir de cette classe. Elles ont accès aux attributs d'instance via le paramètre self et peuvent les modifier.
# Exemples détaillés des méthodes d'instance class CompteBancaire: # Attribut de classe taux_interet = 0.02 def __init__(self, titulaire, solde_initial=0): # Attributs d'instance self.titulaire = titulaire self.solde = solde_initial self.historique = [] self.compte_actif = True # Méthode d'instance pour déposer de l'argent def deposer(self, montant): if montant <= 0: return "Le montant doit être positif" if not self.compte_actif: return "Compte désactivé" self.solde += montant self.historique.append(f"Dépôt: +{montant}€") return f"Dépôt de {montant}€ effectué. Nouveau solde: {self.solde}€" # Méthode d'instance pour retirer de l'argent def retirer(self, montant): if montant <= 0: return "Le montant doit être positif" if not self.compte_actif: return "Compte désactivé" if montant > self.solde: return f"Solde insuffisant. Solde actuel: {self.solde}€" self.solde -= montant self.historique.append(f"Retrait: -{montant}€") return f"Retrait de {montant}€ effectué. Nouveau solde: {self.solde}€" # Méthode d'instance pour consulter le solde def consulter_solde(self): return f"Solde du compte de {self.titulaire}: {self.solde}€" # Méthode d'instance pour virer de l'argent def virer(self, montant, compte_destinataire): if montant <= 0: return "Le montant doit être positif" if not self.compte_actif or not compte_destinataire.compte_actif: return "Un des comptes est désactivé" if montant > self.solde: return f"Solde insuffisant pour le virement" self.solde -= montant compte_destinataire.solde += montant self.historique.append(f"Virement vers {compte_destinataire.titulaire}: -{montant}€") compte_destinataire.historique.append(f"Virement de {self.titulaire}: +{montant}€") return f"Virement de {montant}€ vers {compte_destinataire.titulaire} effectué" # Méthode d'instance pour calculer les intérêts def calculer_interets(self): if self.solde > 0: interets = self.solde * self.taux_interet self.solde += interets self.historique.append(f"Intérêts: +{interets:.2f}€") return f"Intérêts de {interets:.2f}€ ajoutés. Nouveau solde: {self.solde:.2f}€" return "Aucun intérêt calculé (solde négatif ou nul)" # Méthode d'instance pour afficher l'historique def afficher_historique(self): if not self.historique: return "Aucune transaction enregistrée" historique_str = f"Historique du compte de {self.titulaire}:\n" for i, transaction in enumerate(self.historique, 1): historique_str += f"{i}. {transaction}\n" return historique_str.strip() # Méthode d'instance pour désactiver le compte def desactiver_compte(self): self.compte_actif = False return f"Compte de {self.titulaire} désactivé" # Méthode d'instance pour réactiver le compte def reactiver_compte(self): self.compte_actif = True return f"Compte de {self.titulaire} réactivé" # Méthode spéciale pour la représentation string def __str__(self): statut = "actif" if self.compte_actif else "désactivé" return f"Compte de {self.titulaire}: {self.solde}€ ({statut})" # Utilisation des méthodes d'instance print("\n=== Méthodes d'instance ===") # Création de comptes bancaires compte_alice = CompteBancaire("Alice Dupont", 1000) compte_bob = CompteBancaire("Bob Martin", 500) # Utilisation des méthodes d'instance print(compte_alice.consulter_solde()) # Solde du compte de Alice Dupont: 1000€ print(compte_bob.consulter_solde()) # Solde du compte de Bob Martin: 500€ # Opérations bancaires print(compte_alice.deposer(200)) # Dépôt de 200€ effectué. Nouveau solde: 1200€ print(compte_bob.retirer(100)) # Retrait de 100€ effectué. Nouveau solde: 400€ # Virement entre comptes print(compte_alice.virer(300, compte_bob)) # Virement de 300€ vers Bob Martin effectué # Vérification des soldes après virement print(compte_alice.consulter_solde()) # Solde du compte de Alice Dupont: 900€ print(compte_bob.consulter_solde()) # Solde du compte de Bob Martin: 700€ # Calcul des intérêts print(compte_alice.calculer_interets()) # Intérêts de 18.00€ ajoutés. Nouveau solde: 918.00€ # Affichage de l'historique print(compte_alice.afficher_historique()) # Historique du compte de Alice Dupont: # 1. Dépôt: +200€ # 2. Virement vers Bob Martin: -300€ # 3. Intérêts: +18.00€ # Désactivation et réactivation print(compte_bob.desactiver_compte()) # Compte de Bob Martin désactivé print(compte_bob.retirer(50)) # Compte désactivé print(compte_bob.reactiver_compte()) # Compte de Bob Martin réactivé # Affichage final des comptes print(compte_alice) # Compte de Alice Dupont: 918.0€ (actif) print(compte_bob) # Compte de Bob Martin: 700€ (actif)
Une fois une classe définie, on peut créer des instances (objets), accéder à leurs attributs, appeler leurs méthodes et modifier leur état. C'est le cœur de l'interaction avec la programmation orientée objet.
L'instanciation est le processus de création d'un objet à partir d'une classe. On utilise le nom de la classe suivi de parenthèses contenant les arguments du constructeur.
# Définition d'une classe Personne class Personne: def __init__(self, nom, prenom, age=0): self.nom = nom self.prenom = prenom self.age = age self.amis = [] # Liste vide initialement def se_presenter(self): return f"Je m'appelle {self.prenom} {self.nom} et j'ai {self.age} ans." def ajouter_ami(self, ami): self.amis.append(ami) return f"{ami.prenom} a été ajouté(e) aux amis de {self.prenom}" def anniversaire(self): self.age += 1 return f"Joyeux anniversaire {self.prenom}! Vous avez maintenant {self.age} ans." # Définition d'une classe Livre class Livre: def __init__(self, titre, auteur, pages): self.titre = titre self.auteur = auteur self.pages = pages self.est_emprunte = False def emprunter(self): self.est_emprunte = True return f"Le livre '{self.titre}' a été emprunté." def retourner(self): self.est_emprunte = False return f"Le livre '{self.titre}' a été retourné." # Instanciation d'objets (création d'instances) print("=== Instanciation d'objets ===") # Création d'instances de Personne personne1 = Personne("Dupont", "Alice", 25) # Avec tous les paramètres personne2 = Personne("Martin", "Bob") # Âge par défaut (0) personne3 = Personne("Durand", "Charlie", 30) # Création d'instances de Livre livre1 = Livre("Python pour les débutants", "A. Programmeur", 350) livre2 = Livre("Apprendre la POO", "M. Expert", 200) # Vérification du type des instances print(type(personne1)) # <class '__main__.Personne'> print(isinstance(personne2, Personne)) # True print(isinstance(livre1, Livre)) # True print(isinstance(livre2, Personne)) # False # Création d'une liste d'objets personnes = [personne1, personne2, personne3] livres = [livre1, livre2] # Affichage du nombre d'instances créées print(f"Nombre de personnes: {len(personnes)}") print(f"Nombre de livres: {len(livres)}") # Instanciation avec des paramètres nommés personne4 = Personne(nom="Garcia", prenom="David", age=22) personne5 = Personne(age=28, prenom="Élodie", nom="Petit") # Instanciation dynamique dans une boucle noms = [("Leroy", "Sophie", 26), ("Moreau", "Thomas", 24)] nouvelles_personnes = [] for nom, prenom, age in noms: nouvelles_personnes.append(Personne(nom, prenom, age)) print(f"{len(nouvelles_personnes)} nouvelles personnes créées")
On accède aux attributs d'un objet en utilisant la notation pointée : objet.attribut. Python permet également d'accéder aux attributs dynamiquement.
# Accès aux attributs d'instance print("\n=== Accès aux attributs ===") # Accès direct aux attributs avec la notation pointée print(f"Nom: {personne1.nom}") print(f"Prénom: {personne1.prenom}") print(f"Âge: {personne1.age}") print(f"Amis: {personne1.amis}") # Liste vide initialement # Accès aux attributs d'un livre print(f"Titre: {livre1.titre}") print(f"Auteur: {livre1.auteur}") print(f"Pages: {livre1.pages}") print(f"Emprunté: {livre1.est_emprunte}") # Accès aux attributs avec getattr() (accès dynamique) attribut = "nom" valeur_nom = getattr(personne1, attribut) print(f"Valeur de l'attribut '{attribut}': {valeur_nom}") # Vérification de l'existence d'un attribut avec hasattr() print(hasattr(personne1, "prenom")) # True print(hasattr(personne1, "adresse")) # False # Accès sécurisé avec getattr() et valeur par défaut adresse = getattr(personne1, "adresse", "Non spécifiée") print(f"Adresse: {adresse}") # Non spécifiée # Parcours de tous les attributs d'un objet avec vars() print("\nTous les attributs de personne1:") for nom_attribut, valeur in vars(personne1).items(): print(f" {nom_attribut}: {valeur}") # Accès aux attributs avec la notation dictionary-style print(f"Nom (accès dictionary): {personne1.__dict__['nom']}") # Comparaison d'attributs entre différents objets print(f"\nComparaison d'âge:") print(f"{personne1.prenom} a {personne1.age} ans") print(f"{personne3.prenom} a {personne3.age} ans") if personne1.age > personne3.age: print(f"{personne1.prenom} est plus âgé que {personne3.prenom}") else: print(f"{personne3.prenom} est plus âgé que {personne1.prenom}") # Accès aux attributs dans une liste d'objets print("\nNoms de toutes les personnes:") for personne in personnes: print(f"- {personne.prenom} {personne.nom}") # Filtrage d'objets basé sur les attributs jeunes = [p for p in personnes if p.age < 30] print(f"\nPersonnes de moins de 30 ans: {len(jeunes)}") for jeune in jeunes: print(f"- {jeune.prenom} ({jeune.age} ans)")
Les méthodes d'instance sont appelées sur un objet en utilisant la notation pointée : objet.methode(). Le paramètre self est passé automatiquement.
# Appel des méthodes d'instance print("\n=== Appel des méthodes ===") # Appel de méthode simple presentation = personne1.se_presenter() print(presentation) # Je m'appelle Alice Dupont et j'ai 25 ans. # Appel de méthode avec modification de l'état message_anniversaire = personne2.anniversaire() print(message_anniversaire) # Joyeux anniversaire Bob! Vous avez maintenant 1 ans. print(personne2.se_presenter()) # Je m'appelle Bob Martin et j'ai 1 ans. # Appel de méthode avec paramètres ajout_ami = personne1.ajouter_ami(personne3) print(ajout_ami) # Charlie a été ajouté(e) aux amis de Alice # Vérification de l'état après l'appel de méthode print(f"Amis d'Alice: {[ami.prenom for ami in personne1.amis]}") # ['Charlie'] # Appel de méthodes sur les livres emprunt = livre1.emprunter() print(emprunt) # Le livre 'Python pour les débutants' a été emprunté. print(f"Livre emprunté: {livre1.est_emprunte}") # True retour = livre1.retourner() print(retour) # Le livre 'Python pour les débutants' a été retourné. print(f"Livre emprunté: {livre1.est_emprunte}") # False # Appel chaîné de méthodes personne1.ajouter_ami(personne2).# On peut chaîner si la méthode retourne self print(f"Amis d'Alice: {[ami.prenom for ami in personne1.amis]}") # ['Charlie', 'Bob'] # Appel de méthode avec getattr() (appel dynamique) methode_nom = "se_presenter" if hasattr(personne3, methode_nom): methode = getattr(personne3, methode_nom) resultat = methode() # Appel de la méthode print(resultat) # Je m'appelle Charlie Durand et j'ai 30 ans. # Utilisation de méthodes dans des expressions print(f"Alice a {len(personne1.amis)} ami(s)") # Appel de méthodes dans une boucle print("\nPrésentation de toutes les personnes:") for personne in personnes: print(f"- {personne.se_presenter()}") # Interaction entre objets via des méthodes personne3.ajouter_ami(personne1) personne3.ajouter_ami(personne4) print(f"\nAmis de Charlie: {[ami.prenom for ami in personne3.amis]}") # ['Alice', 'David'] # Méthodes qui retournent des valeurs est_majeur = personne1.age >= 18 print(f"{personne1.prenom} est majeur: {est_majeur}") # Alice est majeur: True
Les attributs d'instance peuvent être modifiés directement ou via des méthodes. Il est recommandé d'utiliser des méthodes pour encapsuler la logique de modification.
# Modification des attributs d'instance print("\n=== Modification des attributs ===") # Modification directe d'attributs print("Avant modification:") print(personne1.se_presenter()) # Je m'appelle Alice Dupont et j'ai 25 ans. personne1.age = 26 # Modification directe personne1.prenom = "Alicia" # Modification directe print("Après modification directe:") print(personne1.se_presenter()) # Je m'appelle Alicia Dupont et j'ai 26 ans. # Modification via une méthode print("Avant anniversaire:") print(personne2.se_presenter()) # Je m'appelle Bob Martin et j'ai 1 ans. personne2.anniversaire() # Modification via méthode # Modification d'attributs de liste personne1.amis.append(personne5) # Modification directe de la liste print(f"Amis d'Alicia: {[ami.prenom for ami in personne1.amis]}") # ['Charlie', 'Bob', 'Élodie'] # Modification avec setattr() (modification dynamique) setattr(personne1, "ville", "Paris") # Ajout d'un nouvel attribut print(f"Ville: {personne1.ville}") # Paris # Modification conditionnelle if hasattr(personne1, "age") and personne1.age > 18: personne1.est_majeur = True # Ajout conditionnel d'attribut print(f"{personne1.prenom} est majeur") # Suppression d'attribut avec delattr() if hasattr(personne1, "ville"): delattr(personne1, "ville") print("Attribut 'ville' supprimé") # Vérification que l'attribut a bien été supprimé print(hasattr(personne1, "ville")) # False # Modification en masse avec une boucle
Respecter les bonnes pratiques et conventions en Python est essentiel pour écrire du code maintenable, lisible et professionnel. Cela facilite la collaboration et réduit les erreurs.
Python suit des conventions de nommage spécifiques, souvent appelées "Pythonic" ways. Le PEP 8 est le guide de style officiel qui définit ces conventions.
# ============================================= # CONVENTIONS DE NOMMAGE EN PYTHON (PEP 8) # ============================================= # 1. Variables et fonctions : snake_case ma_variable = 10 nom_complet_utilisateur = "Alice Dupont" def calculer_moyenne(notes): return sum(notes) / len(notes) def est_valide_email(email): return "@" in email # 2. Classes : PascalCase class Utilisateur: pass class GestionnaireUtilisateurs: pass class APIHandler: pass # Les acronymes gardent leur casse (API, HTTP, etc.) # 3. Constantes : UPPER_CASE TAUX_TVA = 0.20 PI = 3.14159 NOMBRE_MAX_TENTATIVES = 3 # 4. Méthodes et attributs privés : _underscore_prefix class MaClasse: def __init__(self): self._attribut_protege = 42 # Convention pour protégé self.__attribut_prive = 100 # Name mangling pour privé def _methode_interne(self): # Méthode pour usage interne à la classe pass # 5. Méthodes spéciales : __double_underscore__ class MaClasseAvecMethodesSpeciales: def __str__(self): return "Représentation en string" def __len__(self): return 0 # 6. Modules : snake_case pour les noms de fichiers # mon_module.py, gestion_utilisateurs.py # 7. Packages : snake_case pour les noms de dossiers # mon_package/, outils_analyse/ # ============================================= # EXEMPLES DE BONNES ET MAUVAISES PRATIQUES # ============================================= # MAUVAIS - ne respecte pas les conventions class mauvaise_classe: # Doit être PascalCase def MauvaiseMethode(self): # Doit être snake_case variableMalNommee = 1 # Doit être snake_case CONSTANTE_MAL_NOMEE = 2 # Doit être UPPER_CASE # BON - respecte les conventions class BonneClasse: def bonne_methode(self): variable_bien_nommee = 1 CONSTANTE_BIEN_NOMEE = 2 # ============================================= # CONVENTIONS SPÉCIFIQUES À LA POO # ============================================= # 1. Nommage des classes : substantifs en PascalCase class Utilisateur: pass class GestionnaireBaseDeDonnees: pass class VehiculeElectrique: pass # 2. Nommage des méthodes : verbes en snake_case class CompteBancaire: def deposer(self, montant): pass def retirer(self, montant): pass def calculer_interets(self): pass # 3. Nommage des attributs : snake_case class Personne: def __init__(self): self.nom_complet = "" self.date_naissance = None self._adresse_email = "" # Protégé self.__mot_de_passe = "" # Privé # 4. Interfaces et classes abstraites from abc import ABC, abstractmethod class FormeGeometrique(ABC): @abstractmethod def calculer_aire(self): pass class Cercle(FormeGeometrique): def calculer_aire(self): return 3.14 * self.rayon * self.rayon
Les docstrings sont des chaînes de documentation qui aident à comprendre le code. Elles suivent le format PEP 257 et peuvent être de style Google, NumPy ou reStructuredText.
# ============================================= # DOCSTRINGS ET DOCUMENTATION (PEP 257) # ============================================= # Style Google (le plus courant) class Personne: """Représente une personne avec un nom, un prénom et un âge. Attributes: nom (str): Le nom de famille de la personne. prenom (str): Le prénom de la personne. age (int): L'âge de la personne. """ def __init__(self, nom, prenom, age=0): """Initialise une instance de Personne. Args: nom (str): Le nom de famille. prenom (str): Le prénom. age (int, optional): L'âge. Par défaut à 0. Raises: ValueError: Si l'âge est négatif. """ if age < 0: raise ValueError("L'âge ne peut pas être négatif") self.nom = nom self.prenom = prenom self.age = age def se_presenter(self): """Retourne une chaîne de présentation de la personne. Returns: str: Une phrase de présentation. Examples: >>> p = Personne("Dupont", "Alice", 25) >>> p.se_presenter() 'Je m'appelle Alice Dupont et j'ai 25 ans.' """ return f"Je m'appelle {self.prenom} {self.nom} et j'ai {self.age} ans." # Style NumPy (alternative) class Calculatrice: """ Une calculatrice simple avec des opérations basiques. Parameters ---------- valeur_initiale : float, optional La valeur initiale de la calculatrice, par défaut 0.0 Attributes ---------- valeur_actuelle : float La valeur courante affichée sur la calculatrice """ def __init__(self, valeur_initiale=0.0): self.valeur_actuelle = valeur_initiale def additionner(self, valeur): """ Ajoute une valeur à la valeur actuelle. Parameters ---------- valeur : float La valeur à ajouter Returns ------- float La nouvelle valeur actuelle """ self.valeur_actuelle += valeur return self.valeur_actuelle # Utilisation des docstrings print("=== Documentation des classes ===") # Accès à la documentation print(Personne.__doc__) # Affiche la docstring de la classe print(Personne.se_presenter.__doc__) # Affiche la docstring de la méthode # Utilisation de help() # help(Personne) # Affiche la documentation complète # Documentation pour les propriétés class Cercle: """Représente un cercle géométrique.""" def __init__(self, rayon): self.rayon = rayon @property def diametre(self): """float: Le diamètre du cercle (lecture seule).""" return 2 * self.rayon @property def aire(self): """float: L'aire du cercle (lecture seule).""" return 3.14159 * self.rayon * self.rayon # Documentation pour les classes abstraites from abc import ABC, abstractmethod class Animal(ABC): """Interface abstraite pour un animal.""" @abstractmethod def parler(self): """Fait parler l'animal. Returns: str: Le cri de l'animal """ pass class Chien(Animal): """Un chien qui hérite de Animal.""" def parler(self): return "Woof!"
Certaines erreurs sont fréquentes lors de l'utilisation de la POO en Python. Les connaître permet de les éviter et d'écrire un code plus robuste.
# ============================================= # ERREURS COURANTES EN POO PYTHON # ============================================= # 1. Oublier le paramètre self dans les méthodes d'instance class MauvaiseClasse: def mauvaise_methode(): # ERREUR: manque self return "Oops!" # 2. Utiliser des variables de classe mutable class ProblemeListe: elements = [] # Variable de classe mutable (DANGER!) def ajouter(self, element): self.elements.append(element) # Modifie la variable de classe! # Solution: initialiser dans __init__ class BonneClasse: def __init__(self): self.elements = [] # Variable d'instance # 3. Confondre héritage et composition # MAUVAIS: héritage inapproprié class Voiture(Moteur): # Une voiture N'EST PAS un moteur pass # BON: composition class Voiture: def __init__(self): self.moteur = Moteur() # Une voiture A UN moteur # 4. Surcharger accidentellement les méthodes built-in class MaClasse: def str(self): # ERREUR: devrait être __str__
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!