Introduction à la programmation orientée objet en Python

Programmation Orientée Objet en Python

La Programmation Orientée Objet (POO) est un paradigme de programmation qui organise le code autour d'objets regroupant des données (attributs) et des comportements (méthodes). Python est un langage entièrement orienté objet : tout en Python est un objet.

Concept	Description	Mot-clé Python
Classe	Modèle / plan de construction d'objets	`class`
Objet	Instance concrète d'une classe	`NomClasse()`
Attribut	Variable appartenant à une classe ou un objet	`self.attribut`
Méthode	Fonction appartenant à une classe	`def methode(self)`
Constructeur	Méthode d'initialisation automatique	`__init__`
Héritage	Une classe hérite d'une autre	`class Enfant(Parent)`

Classes et objets

Définition — Classe Une classe est un modèle (ou plan) qui définit la structure et le comportement communs à un ensemble d'objets. Elle regroupe des attributs (données) et des méthodes (fonctions). Un objet est une instance concrète de cette classe.

Syntaxe Python

class NomClasse:
    attribut = valeur       # attribut de classe

    def methode(self):      # méthode
        ...

objet = NomClasse()         # instanciation
objet.attribut              # accès à un attribut

Exemple — Classe simple

class Personne:
    nom    = "ESSADDOUKI"
    prenom = "Mostafa"
    annee  = 2019

p = Personne()
print(p.nom)          # ESSADDOUKI

p.prenom = 'Ismail'   # modification d'un attribut sur l'instance
print(p.prenom)       # Ismail
print(p.annee)        # 2019

Sortie

ESSADDOUKI
Ismail
2019

Remarque — Accès aux attributs Les attributs sont accessibles via l'opérateur point . : objet.attribut. En Python, les attributs de classe sont publics par défaut. La convention pour signaler un attribut "privé" est de le préfixer par _ (ex. _nom) ou __ pour le name mangling (ex. __nom).

Méthodes

Définition — Méthode Une méthode est une fonction définie à l'intérieur d'une classe avec le mot-clé def. Toutes les méthodes d'instance reçoivent self comme premier paramètre, qui représente l'objet courant (équivalent de this en Java ou C++).

Syntaxe Python

class NomClasse:
    def nom_methode(self, param1, param2):
        self.attribut = param1   # accès/modification via self
        ...

Exemple — Méthode de modification

class Personne:
    nom    = ''
    prenom = ''
    annee  = 0

    def modifier(self, nom, prenom, annee):
        self.nom    = nom
        self.prenom = prenom
        self.annee  = annee

    def afficher(self):
        print(f"Nom    : {self.nom}")
        print(f"Prénom : {self.prenom}")
        print(f"Année  : {self.annee}")

p = Personne()
p.modifier('ESSADDOUKI', 'Mostafa', 2019)
p.afficher()

Sortie

Nom    : ESSADDOUKI
Prénom : Mostafa
Année  : 2019

Constructeur — `init`

Définition — Constructeur La méthode __init__ est le constructeur de la classe. Elle est appelée automatiquement dès qu'un objet est instancié. Elle permet d'initialiser les attributs de l'objet dès sa création, jouant le même rôle que les constructeurs en C++ ou Java.

Syntaxe Python

class NomClasse:
    def __init__(self, param1, param2):
        self.attribut1 = param1   # initialisation des attributs d'instance
        self.attribut2 = param2

Exemple — Classe avec constructeur

class Personne:

    def __init__(self, nom, prenom):
        self.nom    = nom       # attribut d'instance
        self.prenom = prenom    # attribut d'instance

    def afficher(self):
        print(f"Nom    : {self.nom}")
        print(f"Prénom : {self.prenom}")

p1 = Personne('ESSADDOUKI', 'Mostafa')
p2 = Personne('Kayouh', 'Mohamed')

p1.afficher()
p2.afficher()

Sortie

Nom    : ESSADDOUKI
Prénom : Mostafa
Nom    : Kayouh
Prénom : Mohamed

Astuce — Valeurs par défaut Les paramètres de __init__peuvent avoir des valeurs par défaut, rendant certains arguments optionnels à l'instanciation :

class Personne:
    def __init__(self, nom, prenom, ville="Meknès"):
        self.nom    = nom
        self.prenom = prenom
        self.ville  = ville

p = Personne("ESSADDOUKI", "Mostafa")   # ville = "Meknès" par défaut

Attributs de classe vs attributs d'instance

Python distingue deux types d'attributs selon leur portée et leur mode de définition.

	Attribut de classe	Attribut d'instance
Déclaration	Dans le corps de la classe	Via `self.x = ...` dans une méthode
Partagé ?	✅ Par toutes les instances	❌ Propre à chaque objet
Accès	`NomClasse.attribut` ou `self.attribut`	`self.attribut` uniquement
Usage typique	Compteur d'instances, constante commune	Données propres à chaque objet

Exemple — Attribut d'instance conditionnel

class Personne:
    departement = 'Informatique'    # attribut de CLASSE (partagé)

    def __init__(self, nom, prenom):
        self.nom    = nom           # attribut d'INSTANCE
        self.prenom = prenom        # attribut d'INSTANCE

    def set_email(self, email):
        self.email = email          # attribut d'INSTANCE (optionnel)

    def afficher(self):
        print(f"Nom        : {self.nom}")
        print(f"Prénom     : {self.prenom}")
        print(f"Département: {self.departement}")
        # email peut ne pas exister — utiliser getattr pour éviter l'erreur
        print(f"E-mail     : {getattr(self, 'email', 'Non renseigné')}")

p1 = Personne('ESSADDOUKI', 'Mostafa')
p1.set_email('essaddouki@gmail.com')
p1.afficher()

print('─' * 30)

p2 = Personne('Kayouh', 'Mohamed')
p2.afficher()   # pas d'erreur grâce à getattr

Sortie

Nom        : ESSADDOUKI
Prénom     : Mostafa
Département: Informatique
E-mail     : essaddouki@gmail.com
──────────────────────────────
Nom        : Kayouh
Prénom     : Mohamed
Département: Informatique
E-mail     : Non renseigné

Erreur fréquente — AttributeError Si un attribut d'instance est défini dans une méthode optionnelle (comme set_email), il n'existe pas automatiquement sur tous les objets. Accéder à p2.email sans l'avoir défini lève une AttributeError. Utilisez getattr(self, 'email', valeur_defaut) ou initialisez tous les attributs dans __init__.

Héritage

Définition — Héritage L'héritage permet à une classe (sous-classe ou classe dérivée) de réutiliser les attributs et méthodes d'une autre classe (superclasse ou classe de base), et de les étendre ou surcharger selon ses besoins.

Syntaxe Python

class SousClasse(SuperClasse):

    def __init__(self, ...):
        super().__init__(...)   # appel du constructeur parent
        # initialisation supplémentaire

    def methode(self):
        super().methode()       # appel de la méthode parente
        # comportement supplémentaire

Exemple — Héritage simple Personne → Etudiant

class Personne:

    def __init__(self, nom, prenom):
        self.nom    = nom
        self.prenom = prenom

    def afficher(self):
        print(f"Nom    : {self.nom}")
        print(f"Prénom : {self.prenom}")


class Etudiant(Personne):

    def __init__(self, nom, prenom, annee):
        super().__init__(nom, prenom)       # constructeur parent
        self.annee_inscription = annee

    def afficher(self):
        super().afficher()                  # méthode parente
        print(f"Inscription : {self.annee_inscription}")


etd = Etudiant('ESSADDOUKI', 'Ismail', 2019)
etd.afficher()
print(isinstance(etd, Personne))    # True — etd EST une Personne

Sortie

Nom    : ESSADDOUKI
Prénom : Ismail
Inscription : 2019
True

Exemple — Hiérarchie étendue

class Enseignant(Personne):

    def __init__(self, nom, prenom, matiere):
        super().__init__(nom, prenom)
        self.matiere = matiere

    def afficher(self):
        super().afficher()
        print(f"Matière : {self.matiere}")


ens = Enseignant('ALAMI', 'Youssef', 'Mathématiques')
ens.afficher()

Sortie

Nom    : ALAMI
Prénom : Youssef
Matière : Mathématiques

Fonction / méthode	Rôle	Exemple
`super().__init__(...)`	Appelle le constructeur de la classe parente	Initialise les attributs hérités
`super().methode()`	Appelle une méthode de la classe parente	Réutilise le comportement existant
`isinstance(obj, Cls)`	Vérifie si un objet est une instance de la classe	`isinstance(etd, Personne)` → `True`
`issubclass(A, B)`	Vérifie si A hérite de B	`issubclass(Etudiant, Personne)` → `True`

Itérateurs

Définition — Itérateur Un itérateur est un objet qui implémente le protocole itérateur Python, c'est-à-dire les deux méthodes spéciales __iter__() et __next__(). Il permet de parcourir une séquence élément par élément, sans exposer la structure interne de la collection.

Méthode	Rôle	Appelée par
`__iter__(self)`	Retourne l'objet itérateur lui-même	`iter(objet)` ou boucle `for`
`__next__(self)`	Retourne l'élément suivant	`next(objet)` ou boucle `for`
`StopIteration`	Exception signalant la fin de la séquence	Levée dans `__next__` quand épuisé

Syntaxe Python

class MonIterateur:
    def __init__(self, données):
        self.données = données
        self.index   = 0

    def __iter__(self):
        return self             # retourne l'itérateur lui-même

    def __next__(self):
        if self.index >= len(self.données):
            raise StopIteration
        valeur = self.données[self.index]
        self.index += 1
        return valeur

Exemple — Itérateur sur un tableau

class Tableau:

    def __init__(self, tab):
        self.donnee = tab.copy()
        self.index  = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index >= len(self.donnee):
            raise StopIteration
        valeur = self.donnee[self.index]
        self.index += 1
        return valeur

T   = [1, 3, 5, 7, 8, 13, 20, 25]
tab = Tableau(T)

for elm in tab:
    print(elm, end=" ")

Sortie

1 3 5 7 8 13 20 25

Exemple — Itérateur de comptage à rebours

class Rebours:

    def __init__(self, debut):
        self.n = debut

    def __iter__(self):
        return self

    def __next__(self):
        if self.n < 0:
            raise StopIteration
        val    = self.n
        self.n -= 1
        return val

for val in Rebours(5):
    print(val, end=" ")   # 5 4 3 2 1 0

Sortie

5 4 3 2 1 0

Astuce — Itérateur vs Générateur Implémenter un itérateur manuellement avec __iter__ et __next__ est puissant mais verbeux. Pour des cas simples, un générateur avec yieldest souvent plus concis et lisible :

def rebours(n):
    while n >= 0:
        yield n
        n -= 1

for val in rebours(5):
    print(val, end=" ")   # 5 4 3 2 1 0

POO héritage

Suivant constructeur et destructeur en Python

Introduction à la programmation orientée objet en Python

Programmation Orientée Objet en Python

Classes et objets

Méthodes

Constructeur — `init`

Attributs de classe vs attributs d'instance

Héritage

Itérateurs

Discussion (0)

Laisser un commentaire

Structures de données

Algorithmes

Programmation

Bases de données

CPGE

Modules informatique

Introduction à la programmation orientée objet en Python

Programmation Orientée Objet en Python

Classes et objets

Méthodes

Constructeur — __init__

Attributs de classe vs attributs d'instance

Héritage

Itérateurs

Discussion (0)

Laisser un commentaire

Constructeur — `init`