Signature

numérique de
KAMAL IDRISSI
Hamza
Date :
2022.03.15
14:42:20
+01'00'

Classes et objets.
OOP Object Oriented Programming
 Classes et objets.

Objectifs de ce module

• Apprendre à déclarer une classe.

• Savoir construire un objet en initialisant ses

attributs.

• Être capable de manipuler les membres d’une

classe selon leur visibilité.
 Classes et objets.

Plan de ce module

1. Déclarer une classe.

2. Constructeurs et destructeurs.
3. Encapsulation.
Classes et objets.

1. Déclarer une classe.

 1. Déclarer une classe.

Plan de ce chapitre

a. Rappel des concepts.

b. Syntaxe générale.
c. Attributs.
d. Méthodes.
e. Attributs et méthodes de classe.
 1. Déclarer une classe.

a. Rappels des concepts.

Objet :

•Il s’agit d’une entité possédant

1. Une identité.
2. Des variables définissant son état (attributs).
3. Des sous programmes gérant son comportement
(méthodes).
 1. Déclarer une classe.

a. Rappels des concepts.

Classe :

•Il s’agit d’une abstraction regroupant des objets ayant les

mêmes attributs et les mêmes méthodes.
 1. Déclarer une classe.

a. Rappels des concepts.

En programmation :

•On commence par déclarer une classe qui est le moule

commun à nos futurs objets.

•Selon nos besoins on instancie des objets de cette classe,

chaque objet ayant une identité et des valeurs d’attributs qui
lui sont propres.
 1. Déclarer une classe.

b. Syntaxe générale.
Syntaxe de la déclaration d’une classe :

class nomDeLaClasse:
“““documentation de la classe“““
...
 1. Déclarer une classe.

b. Syntaxe générale.
Remarques sur la documentation :

•Écrire une documentation pertinente fait partie des bonnes

pratiques.

•On peut accéder à la documentation d’une classe par la

commande y compris les commentaires

nomDeLaClasse.__doc__
 1. Déclarer une classe.

b. Syntaxe générale.
Une première instanciation :

•Pour créer un objet d’une classe existante, on utilise la

syntaxe

monObjet = nomDeLaClasse()
 1. Déclarer une classe.

b. Syntaxe générale.
Exemple :

class compte:
"""gestion d'un compte bancaire"""

monCompte = compte()
print(monCompte)
print(monCompte.__doc__)
 1. Déclarer une classe.

b. Syntaxe générale.
Syntaxe de l’accès aux membres d’une classe :

•On va voir dans la suite comment définir les attributs et les

méthodes d’une classe, mais retenons déjà comment on
pourra les appeler :

monObjet.monAttribut

monObjet.maMéthode(para1,...)
 1. Déclarer une classe.

c. Attributs.
Ajout dynamique d’attributs :

•Après avoir instancié un objet on peut lui ajouter des

attributs en suivant une syntaxe de la forme

monObjet.monAttribut = valeur
 1. Déclarer une classe.

c. Attributs.
Exemple :

class compte:
"""gestion d'un compte bancaire"""

monCompte = compte()
monCompte.nom = "comptePerso"
monCompte.numero = 666
monCompte.solde = -1000
 1. Déclarer une classe.

c. Attributs.
Remarque :

•Cette façon de déclarer des attributs n’est pas satisfaisante.

•On préfèrera en effet déclarer les attributs lors de la

création de l’objet.

•Ce sera le rôle du constructeur de la classe.

 1. Déclarer une classe.

c. Attributs.
Autre remarque :

•Avec ce type de gestion des attributs on ne peut de plus

espérer respecter le principe d’encapsulation.
 1. Déclarer une classe.

d. Méthodes.
Déclaration de méthodes au sein d’une classe :

•Lors de la déclaration d’une classe, on doit déclarer les

méthodes

class nomDeLaClasse:
“““documentation de la classe“““
def méthode1(self,para1,para2,...):
...
def méthode2(self,para1,para2,...):
...
 1. Déclarer une classe.

d. Méthodes.
Explications :

•Ces déclarations de méthodes se font dans la classe.

•La syntaxe d’une méthode est la même que celles des

fonctions en Python.
 1. Déclarer une classe.

d. Méthodes.
Explications (suite) :

•Le premier paramètre d’une méthode est toujours une

référence vers l’objet courant. Elle est usuellement appelée
“self”. Lors de l’appel, elle n’est pas utilisée.

•Les autres paramètres sont les données transmises à la

méthode pour son bon fonctionnement.
 1. Déclarer une classe.

d. Méthodes.
Exemple :

class compte:
"""gestion d'un compte bancaire"""
def crediter(self,x):
self.solde += x
def afficherSolde(self):
print("Le solde vaut :",self.solde)
 1. Déclarer une classe.

d. Méthodes.
Exemple (suite) :

monCompte = compte()
monCompte.nom = "comptePerso"
monCompte.numero = 6666
monCompte.solde = -1000
monCompte.crediter(5000)
monCompte.afficherSolde()
 1. Déclarer une classe.

e. Attributs et méthodes de classe.

• Les attributs précédents sont des attributs d’instances.

• Cela signifie que leur valeur est différente pour chaque

objet.

• On peut également définir des attributs de classes.

• Ceux-ci auront la même valeur pour tous les objets de la

classe.
 1. Déclarer une classe.

e. Attributs et méthodes de classe.

Déclaration d’un attribut de classe :

•Celle-ci doit s’effectuer au sein de la classe

class nomDeLaClasse:
“““documentation de la classe“““

monAttributDeClasse = valeur

def méthode1(self,para1,para2,...):
...
 1. Déclarer une classe.

e. Attributs et méthodes de classe.

Exemple :

class compte:
"""gestion d'un compte bancaire"""
nbreCompte = 0
def crediter(self,x):
self.solde += x
def afficherSolde(self):
print("Le solde vaut :",self.solde)
 1. Déclarer une classe.

e. Attributs et méthodes de classe.

Accès à un attribut de classe :

•Celui-ci s’effectue en utilisant la syntaxe

maClasse.monAttributDeClasse
 1. Déclarer une classe.

e. Attributs et méthodes de classe.

Exemple :

print(compte.nbreCompte)
monCompte = compte()
monCompte.nom = "comptePerso"
monCompte.numero = 666
monCompte.solde = -1000
compte.nbreCompte += 1
print(compte.nbreCompte)
 1. Déclarer une classe.

e. Attributs et méthodes de classe.

Remarque :

•Cet exemple du décompte du nombre d’objet instanciés est

l’exemple typique d’attribut de classe ou statique.

•Un autre rôle usuel est de stocker la valeur de certaines

constantes propres à la classe (valeur de taux,etc.).
 1. Déclarer une classe.

e. Attributs et méthodes de classe.

• Les attributs de classes n’étant pas rattachés à des objets,
on peut imaginer sur le même principe des méthodes
rattachées à la classe.

• Celles-ci auront un effet indépendant des objets.

• Leur rôle sera en particulier de manipuler les attributs de

classes.
 1. Déclarer une classe.

e. Attributs et méthodes de classe.

Déclaration d’une méthode de classe :

•Celle-ci doit s’effectuer au sein de la classe et requiert

l’utilisation du mot clé “@classmethod” et de la classe en
parameter. Ce dernier n’est pas utilisé lors de l’appel

class nomDeLaClasse:
“““documentation de la classe“““

@classmethod
def maMéthodeDeClasse(cls,para1,...):
...
 1. Déclarer une classe.

e. Attributs et méthodes de classe.

Exemple :

class compte:
"""gestion d'un compte bancaire"""
nbreCompte = 0
@classmethod
def afficherNbreComptes(cls):
print("Nombre de comptes : ",cls.nbreCompte)
 1. Déclarer une classe.

e. Attributs et méthodes de classe.

Accès à une méthode de classe :

•Celui-ci s’effectue en utilisant une des deux syntaxes

suivantes :

maClasse.maMéthodeDeClasse(...)

unObjet.maMéthodeDeClasse(...)
 1. Déclarer une classe.

e. Attributs et méthodes de classe.

Exemple :

monCompte = compte()
compte.nbreCompte += 1
compte.afficherNbreComptes()
monAutreCompte = compte()
compte.nbreCompte += 1
monAutreCompte.afficherNbreComptes()
Classes et objets.

2. CONSTRUCTEURS ET
DESTRUCTEURS.
 2. Constructeurs et destructeurs.

Plan de ce chapitre

a. La méthode « __init__ ».
b. La méthode « __del__ ».
 2. Constructeurs et destructeurs.

a. La méthode “__init__”.
• Pour initialiser les attributs d’un objet que l’on crée, on va
rajouter à nos classes une méthode particulière : un
constructeur.

• En Python, son nom est imposé : __init__

• On prendra donc l’habitude de n’utiliser que cette

méthode pour déterminer les attributs d’un objet et leur
valeur initiale.
 2. Constructeurs et destructeurs.

a. La méthode “__init__”.
Syntaxe de la déclaration de la méthode __init__ :

•C’est la même que pour une autre méthode

class nomDeLaClasse:
“““documentation de la classe“““
def __init__(self,para1,para2,...):
...
def méthode1(self,para1,para2,...):
...
 2. Constructeurs et destructeurs.

a. La méthode “__init__”.
Exemple :

class compte:
"""gestion d'un compte bancaire"""
def __init__(self,nom,numero,valeur):
self.nom = nom
self.numero = numero
self.solde = valeur
def afficherSolde(self):
print("Le solde vaut :",self.solde)
 2. Constructeurs et destructeurs.

a. La méthode “__init__”.
Exemple (suite) :

monCompte = compte("pro",777,10000)
monCompte.afficherSolde()
 2. Constructeurs et destructeurs.

a. La méthode “__init__”.
Remarque :

•La méthode “__init__” est appelée automatiquement lors

de l’instanciation d’un objet.

•L’utilisateur de la classe n’a donc pas à l’invoquer.

 2. Constructeurs et destructeurs.

a. La méthode “__init__”.
Valeurs par défaut des attributs :

•On peut donner des valeurs par défaut aux attributs dans la
méthode “__init__“.

•Cela permettra de continuer à utiliser ce genre de syntaxe

monObjet = nomDeLaClasse()

mais cette fois ci en étant sûr de son sens.

 2. Constructeurs et destructeurs.

a. La méthode “__init__”.
Exemple :

class compte:
"""gestion d'un compte bancaire"""
def __init__(self,nom="perso"
,numero=666,valeur=1000):
self.nom = nom
self.numero = numero
self.solde = valeur
def afficherSolde(self):
print("Le solde vaut :",self.solde)
 2. Constructeurs et destructeurs.

a. La méthode “__init__”.
Exemple (suite) :

monCompte = compte("pro",777,10000)
monCompte.afficherSolde()
monAutreCompte = compte()
monAutreCompte.afficherSolde()
 2. Constructeurs et destructeurs.

a. La méthode “__init__”.
Remarque : si l’on dispose d’un attribut de classe
dénombrant le nombre d’objets instanciés il est pertinent de
le mettre à jour dans la méthode __init__

class compte:
nbreCompte = 0
def __init__(self,nom="perso"
,numero=666,valeur=1000):
self.nom = nom
self.numero = numero
self.solde = valeur
compte.nbreCompte += 1
 2. Constructeurs et destructeurs.

a. La méthode “__init__”.
Remarque (suite) :

monCompte = compte("pro",777,10000)
print(compte.nbreCompte)
monAutreCompte = compte()
print(compte.nbreCompte)
 2. Constructeurs et destructeurs.

b. La méthode “__del__”.
• Pour libérer la mémoire d’un objet que l’on n’utilise plus,
on va rajouter à nos classes une méthode particulière : un
destructeur.

• En Python, son nom est imposé : __del__

• Il pourra également servir à mettre à jour certains

attributs de classes, comme par exemple un compteur
d’objets instanciés.
 2. Constructeurs et destructeurs.

b. La méthode “__del__”.
Syntaxe de la déclaration de la méthode __del__ :

•C’est la même que pour une autre méthode

class nomDeLaClasse:
“““documentation de la classe“““
def __init__(self,para1,para2,...):
...
def __del__(self):
...
def méthode1(self,para1,para2,...):
...
 2. Constructeurs et destructeurs.

b. La méthode “__del__”.
Remarque :

•On ne fait quasiment jamais d’appel explicite à la méthode

__del__

•Elle est appelée automatiquement quand un objet cesse

d’être référencé (comme par exemple si l’on crée une
instance dans une fonction ou procédure).
 2. Constructeurs et destructeurs.

b. La méthode “__del__”.
Exemple :

class compte:
nbreCompte = 0
def __init__(self,nom="perso"
,numero=666,valeur=1000):
self.nom = nom
self.numero = numero
self.solde = valeur
compte.nbreCompte += 1
def __del__(self):
compte.nbreCompte -= 1
 2. Constructeurs et destructeurs.

b. La méthode “__del__”.
Exemple (suite) :

def unePetiteProcedure():
unAutreCompte = compte()
compte.afficherNbreComptes()

monCompte = compte()
monAutreCompte = compte()
compte.afficherNbreComptes()
unePetiteProcedure()
compte.afficherNbreComptes()
Classes et objets.

3. ENCAPSULATION.
 3. Encapsulation.

Plan de ce chapitre

a. Rappel du principe.
b. Comment rendre un attribut “privé“.
c. Le rôle des accesseurs.
d. Le rôle des mutateurs.
 3. Encapsulation.

a. Rappel du principe.
Encapsulation : principe interdisant l’accès direct aux
attributs. On ne dialoguera avec l’objet qu’à travers une
interface définissant les services accessibles aux l’utilisateurs
de l’objet. Ce sera le rôle des méthodes.
 3. Encapsulation.

a. Rappel du principe.
• Le principe d’encapsulation est donc de déclarer :

– Les attributs de façon privée.

– Les méthodes de façon publique.

 3. Encapsulation.

b. Comment rendre un attribut “privé“

Méthode pour déclarer un attribut “privé“ :

•Lors de l’implémentation de la méthode “__init__” on

précèdera le nom de l’attribut en question d’un double
underscore :

def __init__(self,para1,para2,...):
attributPublic = valeur
__attributPrivé = valeur
...
 3. Encapsulation.

b. Comment rendre un attribut “privé“

Exemple :

class compte:
"""gestion d'un compte bancaire"""
def __init__(self,nom,numero,valeur):
self.nom = nom
self.numero = numero
self.__solde = valeur
def afficherSolde(self):
print("Le solde :",self.__solde)
 3. Encapsulation.

b. Comment rendre un attribut “privé“

Exemple (suite) : “nom“ est un attribut public, on peut le
manipuler en dehors de la classe.

monCompte = compte("pro",777,10000)
monCompte.nom = "perso"
print(monCompte.nom)
 3. Encapsulation.

b. Comment rendre un attribut “privé“

Exemple (suite) : “__solde“ est un attribut privé, on ne peut
pas le manipuler en dehors de la classe.

monCompte = compte("pro",777,10000)
print(monCompte.__solde)
 3. Encapsulation.

b. Comment rendre un attribut “privé“

Exemple (fin) : on prendra donc l’habitude de déclarer tous
nos attributs de façon privée, notre classe deviendra donc

class compte:
"""gestion d'un compte bancaire"""
def __init__(self,nom,numero,valeur):
self.__nom = nom
self.__numero = numero
self.__solde = valeur
def afficherSolde(self):
print("Le solde :",self.__solde)
 3. Encapsulation.

b. Comment rendre un attribut “privé“

Remarque :

•On procéderait de la même façon pour rendre une méthode

privée, faire précéder son nom d’un double underscore.

•Cela peut être utile lors de l’implémentation de certaines

méthodes publiques complexes, que l’on va “découper“ en
plusieurs sous-méthodes qui seront déclarées privées car
étant internes à l’objet.
 3. Encapsulation.

b. Comment rendre un attribut “privé“

Remarque (suite) :

•On procéderait de la même façon pour rendre un attribut de

classe privé, faire précéder son nom d’un double underscore.
 3. Encapsulation.

c. Le rôle des accesseurs.

Principe :

•Un accesseur (ou “getter“) est une méthode retournant la

valeur d’un attribut.

•On sera donc souvent amené à créer autant d’accesseurs

que d’attributs.
 3. Encapsulation.

c. Le rôle des accesseurs.

Exemple :

class compte:
"""gestion d'un compte bancaire"""
def __init__(self,nom,numero,valeur):
self.__nom = nom
self.__numero = numero
self.__solde = valeur
def getSolde(self):
return self.__solde
 3. Encapsulation.

c. Le rôle des accesseurs.

Exemple (suite) :

monCompte = compte("pro",777,10000)
print(monCompte.getSolde())
 3. Encapsulation.

d. Le rôle des mutateurs.

Principe :

•Un mutateur (ou “setter“) est une méthode fixant la valeur

d’un attribut.

•On sera donc souvent amené à créer autant de mutateurs

que d’attributs.
 3. Encapsulation.

d. Le rôle des mutateurs.

Exemple :

class compte:
"""gestion d'un compte bancaire"""
def __init__(self,nom,numero,valeur):
self.__nom = nom
self.__numero = numero
self.__solde = valeur
def getSolde(self):
return self.__solde
def crediter(self,x):
self.__solde += x
 3. Encapsulation.

d. Le rôle des mutateurs.

Exemple (suite) :

monCompte = compte("pro",777,10000)
monCompte.crediter(500000)
print(monCompte.getSolde())
 3. Encapsulation.

e. Exercice.
Exercice : compléter la classe “compte” avec des accesseurs
et des mutateurs pour chacun de ses attributs.
 3. Encapsulation.

e. Exercice.
Solution :

class compte:
def debiter(self,x):
if x < self.__solde:
self.__solde -= x
def getNumero(self):
return self.__numero
def getNom(self):
return self.__nom
def setNom(self,nom):
self.__nom = nom
def setNumero(self,num):
self.__numero = num