LA-PROGRAMMATION-ORIENTEE-OBJET-EN-PYTHON

1
Support de cours
La programmation orientée objet en python
Réaliser par : Nene SYLLA

2
1. Le concept de POO en Python
La programmation orienté objet est un type de programmation basée sur la
création des classes et des objets via une méthode appelée instanciation. Une
classe est un prototype (modèle) codé en un langage de programmation dont le
but de créer des objets dotés d’un ensemble de méthodes et attributs qui
caractérisent n’importe quel objet de la classe.
Les attributs sont des types de données (variables de classe et variables
d’instance) et des méthodes, accessibles via la concaténation par points. En
programmation orientée objet, la déclaration d’une classe regroupe des
méthodes et propriétés (attributs) communs à un ensemble d’objets. Ainsi on
pourrait dire qu’une classe représente une catégorie d’objets. Elle apparaît aussi
comme une usine permettant de créer des objets ayant un ensemble d’attributs
et méthodes communes.
Depuis sa création, Python est un langage de programmation orienté objet. Pour
cette raison, la création et l’utilisation de classes et d’objets en Python est une
opération assez simple.
2. Les classes en Python
Pour créer une classe en Python, on utilise l’instruction :
class nom_de_la_classe :
On crée ensuite une méthode qui permet de construire les objets, appelé
constructeur via l’instruction :
def__init__ ( self ) :
Exemple 1:
Créons la class Personne qui prendra comme attributs : nom et age
class Personne :
def __init__ ( self ,nom, age) :
self.nom = nom
self.age = age
P = Personne( ” Albert ” ,27)
print ( ”Le nom de la personne est : ”, P.nom)
print ( ”L’age de la personne est : ”, P.age, ” ans” )
# affiche : Le nom de la personne est : Albert

3
# L’age de la personne est : 27 ans
Exemple 2 :
Créons la classe Rectangle qui prendra comme attributs : Longueur et Largeur
class Rectangle :
def __init__ ( self , L , l ) :
s e l f . Longueur=L
s e l f . Largeur=l
monRectangle=Rectangle(7 ,5)
print ( ”La longueur de mon rectangle est : ” ,monRectangle . Longueur)
print ( ”La largeur de mon rectangle est : ” ,monRectangle . Largeur )
Ce qui affiche à l’exécution :
La longueur de mon rectangle est : 7
La largeur de mon rectangle est : 5
3. Les méthodes de classes en Python
Une méthode de classe est une fonction ou procédure nommée au sein de la
classe, permettant de définir des propriétés ou comportements des objets
d’instances.
Exemple :
Reprenons l’exemple de la class Rectangle et ajoutons une méthode qui calcule la
surface de ce rectangle.
class Rectangle :
def __init__ ( self , L , l ) :
self.Longueur = L
self.Largeur = l
# méthode qui calcule la surface
def surface ( self) :
return self.Longueur*self.Largeur
# création d’un rectangle de longueur 7 et de largeur 5
monRectangle = Rectangle(7 ,5)
print ( ”La surface de mon rectangle est : ”, monRectangle.surface ())
Ce qui affiche après exécution : La surface de mon rectangle est : 35

4
4. L’encapsulation en python
L'encapsulation est un principe qui consiste à cacher ou protéger certaines
données de notre objet. Dans la plupart des langages orientés objet, tels que le
C++, le Java ou le PHP, on va considérer que nos attributs d'objets ne doivent pas
être accessibles depuis l'extérieur de la classe. Autrement dit, vous n'avez pas le
droit de faire, depuis l'extérieur de la classe, mon_objet.mon_attribut.
On va définir des méthodes un peu particulières, appelées des accesseurs et
mutateurs. Les accesseurs donnent accès à l'attribut. Les mutateurs permettent
de le modifier. Concrètement, au lieu d'écrire mon_objet.mon_attribut, vous
allez écrire mon_objet.get_mon_attribut(). De la même manière, pour modifier
l'attribut écrivez mon_objet.set_mon_attribut(valeur) et non pas
mon_objet.mon_attribut = valeur.
 get signifie « récupérer », c'est le préfixe généralement utilisé pour un
accesseur.
 set signifie, dans ce contexte, « modifier » ; c'est le préfixe usuel pour un
mutateur.
Il peut être très pratique de sécuriser certaines données de notre objet, par
exemple faire en sorte qu'un attribut de notre objet ne soit pas modifiable, ou
alors mettre à jour un attribut dès qu'un autre attribut est modifié. Les cas sont
multiples et c'est très utile de pouvoir contrôler l'accès en lecture ou en écriture
sur certains attributs de notre objet.
L'inconvénient de devoir écrire des accesseurs et mutateurs, comme vous
l'aurez sans doute compris, c'est qu'il faut créer deux méthodes pour chaque
attribut de notre classe. D'abord, c'est assez lourd. Ensuite, nos méthodes se
ressemblent plutôt. Certains environnements de développement proposent, il est
vrai, de créer ces accesseurs et mutateurs pour nous, automatiquement.
Mais cela ne résout pas vraiment le problème, vous en conviendrez.
En Python, il n'y a pas d'attribut privé. Tout est public. Cela signifie que si
vous voulez modifier un attribut depuis l'extérieur de la classe, vous le pouvez.
Pour faire respecter l'encapsulation propre au langage, on la fonde sur des
conventions que nous allons découvrir un peu plus bas mais surtout sur le bon
sens de l'utilisateur de notre classe (à savoir, si j'ai écrit que cet attribut est
inaccessible depuis l'extérieur de la classe, je ne vais pas chercher à y accéder
depuis l'extérieur de la classe).
Les propriétés sont un moyen transparent de manipuler des attributs
d'objet. Elles permettent de dire à Python : « Quand un utilisateur souhaite
modifier cet attribut, fais cela ». De cette façon, on peut rendre certains attributs

5
tout à fait inaccessibles depuis l'extérieur de la classe, ou dire qu'un attribut ne
sera visible qu'en lecture et non modifiable. Ou encore, on peut faire en sorte
que, si on modifie un attribut, Python recalcule la valeur d'un autre attribut de
l'objet.
Les propriétés sont des objets un peu particuliers de Python. Elles prennent
la place d'un attribut et agissent différemment en fonction du contexte dans
lequel elles sont appelées. Si on les appelle pour modifier l'attribut, par exemple,
elles vont rediriger vers une méthode que nous avons créée, qui gère le cas où «
on souhaite modifier l'attribut ».
Création de propriété
Une propriété ne se crée pas dans le constructeur mais dans le corps de la classe.
Il s'agit d'une classe, son nom est property. Elle attend quatre paramètres, tous
optionnels :
o la méthode donnant accès à l'attribut ;
o la méthode modifiant l'attribut ;
o la méthode appelée quand on souhaite supprimer l'attribut ;
o la méthode appelée quand on demande de l'aide sur l'attribut.
En pratique, on utilise surtout les deux premiers paramètres : ceux définissant les
méthodes d'accès et de modification, autrement dit nos accesseur et mutateur
d'objet.
Exemple :
#−*− coding : utf−8 −*−
class Personne :
def __init__ ( self ,nom, age) :
self.nom = nom
self.age = age
self._lieu_residence = ‘’Mali’’ # Notez le souligne _ devant le nom
def _get._lieu_residence (self):
print (“On accede a l’attribut lieu_residence’’)
return self._lieu_residence
def _set._lieu_residence (self, nouvelle_residence):
print ("Attention, il semble que {} déménage à {}.".format( \
self.prenom, nouvelle_residence))
self._lieu_residence = nouvelle_residence
# On va dire à Python que notre attribut lieu_residence pointe vers une
#propriété