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

Python - Programmation orientée objet
Chapitre 1 : Introduction à la Programmation Orientée Objet

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

Qu'est-ce que la Programmation Orientée Objet ?

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.

Définition et concepts fondamentaux

La POO organise le code autour d'objets plutôt que d'actions et de logique. Les quatre piliers fondamentaux sont :

  • Encapsulation : regroupe données et méthodes dans une classe
  • Abstraction : masque les détails complexes et expose uniquement l'essentiel
  • Héritage : permet à une classe d'hériter des propriétés d'une autre
  • Polymorphisme : permet à une méthode de s'adapter selon le contexte
concepts_poo.py
# 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.

Avantages de la POO

La programmation orientée objet offre plusieurs avantages significatifs :

  • Réutilisabilité : Les classes peuvent être réutilisées dans différents projets
  • Maintenabilité : Le code est mieux organisé et plus facile à maintenir
  • Modularité : Les objets sont des entités indépendantes qui peuvent être développées séparément
  • Évolutivité : Il est plus facile d'ajouter de nouvelles fonctionnalités
  • Sécurité : L'encapsulation protège les données internes
avantages_poo.py
# 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€.

Comparaison avec la programmation procédurale

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

Les concepts clés de la POO

La Programmation Orientée Objet repose sur quatre concepts fondamentaux qui permettent de structurer le code de manière modulaire, réutilisable et maintenable.

Les objets et les classes

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.

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

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.

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

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.

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

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

La POO en Python

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.

Particularités de Python pour la POO

Python présente plusieurs caractéristiques distinctives dans son implémentation de la POO :

  • Duck typing : L'accent est mis sur le comportement des objets plutôt que sur leur type
  • Tout est objet : Même les types primitifs sont des objets en Python
  • Méthodes spéciales : Utilisation de méthodes comme __init__, __str__ pour personnaliser le comportement
  • Modification à l'exécution : Possibilité de modifier les classes et objets dynamiquement
  • Properties : Mécanisme pour contrôler l'accès aux attributs
  • Multiple inheritance : Support de l'héritage multiple
  • MRO (Method Resolution Order) : Algorithme qui détermine l'ordre de recherche des méthodes
particularites_poo.py
# 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

Syntaxe de base : définir une classe

La définition d'une classe en Python suit une syntaxe simple mais puissante :

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

Créer des instances d'objets

La création d'instances (objets) en Python est simple et intuitive :

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

Première classe en Python

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.

Structure d'une classe simple

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

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.

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

Les attributs d'instance sont des variables spécifiques à chaque objet créé à partir d'une classe. Ils définissent l'état de l'objet.

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

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.

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

Utilisation des objets

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.

Instanciation d'objets

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.

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

Accès aux attributs

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.

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

Appel des méthodes

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

Modification des attributs

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

		

Bonnes pratiques et conventions

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.

Conventions de nommage en Python

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_nommage.py
# =============================================
# 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

Documentation des classes (docstrings)

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.

documentation_classes.py
# =============================================
# 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!"

Erreurs courantes à éviter

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.py
# =============================================
# 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__

			
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