Dernière mise à jour Informatique Denis DEFAUCHY

24/12/2021 Programmation objet Cours

Informatique

Cours

Page 1 sur 12
 Dernière mise à jour Informatique Denis DEFAUCHY
24/12/2021 Programmation objet Cours

0.I. Initiation à la programmation orientée objet ....................................................................... 3

0.I.1 Introduction ............................................................................................................................................ 3
0.I.2 Définitions .............................................................................................................................................. 3
0.I.2.a Objet................................................................................................................................................ 3
0.I.2.b Attribut............................................................................................................................................ 4
0.I.2.c Méthode .......................................................................................................................................... 5
0.I.3 Exemples ................................................................................................................................................ 7
0.I.3.a Comptes en banque ........................................................................................................................ 7
0.I.3.b Une petite blague ........................................................................................................................... 8
0.I.3.c Jeu de cartes .................................................................................................................................... 9
0.I.3.d Particules....................................................................................................................................... 11
0.I.4 Conclusions ........................................................................................................................................... 12

Page 2 sur 12
 Dernière mise à jour Informatique Denis DEFAUCHY
24/12/2021 Programmation objet Cours

1.I. Initiation à la programmation orientée objet

1.I.1 Introduction

La programmation orientée objet (POO) est une méthode de programmation très puissante et je tiens
à préciser que je n’entrerai pas dans des détails complexes et dans toutes les possibilités qui nous sont
offertes, et que je ne connais pas. C’est pourquoi je tiens à préciser que c’est une « initiation » à a
programmation objet. Nous allons plus nous focaliser sur la forme que sur le fond dans sa mise en
œuvre.

1.I.2 Définitions

1.I.2.a Objet

Un objet, c’est un truc ! Un code informatique, qui réalise quelque chose ! N’importe quoi.

Pour créer des objets, on utilise les classes. La classe est un outil qui permet de créer des objets.

class Compte():
a = 0

Il est alors possible de créer une infinité d’objets de type Compte :

Page 3 sur 12
 Dernière mise à jour Informatique Denis DEFAUCHY
24/12/2021 Programmation objet Cours

1.I.2.b Attribut

Un objet peut posséder des attributs. On pourrait dire que chaque objet pourra posséder des variables
qui lui sont associées. Nous allons voir dans le prochain paragraphe ce qu’est une méthode, en
particulier la méthode appelée __init__. On peut juste dire ici que lorsque l’on va créer une instance
de Compte (un objet, ou un compte), la fonction __init_ sera toujours exécutée immédiatement. C’est
donc dans cette fonction de l’on va créer les attributs de chaque objet.

class Compte():

def __init__(self,Nom="Absent",Solde=0.0):
self.nom = Nom
self.solde = Solde

On peut voir que chaque instance de Compte aura deux attributs :

- Un nom : self.nom, qui s’il n’est pas précisé sera « Absent »

- Un solde : self.solde, qui de même sera nul si non précisé

Sans rentrer dans les détails pour le moment, le self permet d’attribuer les valeurs des attributs à
l’objet en question. Nous en parlerons au prochain paragraphe.

On peut alors créer le compte de Denis avec un solde à 100€ et un compte à solde nul au nom de
Nicolas ainsi :

Vous remarquerez que l’on ne tient pas compte de l’argument « self » lors de l’appelle de la classe
Compte, qui appelle elle-même la méthode __init__.

Il est nécessaire de créer/modifier les attributs dans les méthodes, et pas uniquement dans la méthode
__init__.

Page 4 sur 12
 Dernière mise à jour Informatique Denis DEFAUCHY
24/12/2021 Programmation objet Cours

1.I.2.c Méthode

Un objet possède des méthodes. Ce sont des fonctions comme vous savez les créer, qui vont pourvoir
réaliser tout ce que vous souhaitez.

Soit le code suivant :

class Compte():

def __init__(self,Nom="Absent",Solde=0):
self.nom = Nom
self.solde = Solde

def depot(self,Montant):
self.solde += Montant
print("Nouveau solde: ",self.solde)

Il existe dans cette classe qui crée les objets Compte, deux méthodes : __init__ et depot

La première est entourée de « dunder », pour « double underscore ». Les méthodes dunder (magic
methods) sont des méthodes prédéfinies (leurs noms sont imposés) et ont des fonctions particulières
dans les classes. Ainsi, __init_ est une méthode qui est exécutée immédiatement à chaque appel de la
classe Compte.

On voit ensuite 3 méthodes qui sont des fonctions classiques que vous savez réaliser.

Il reste à parler du « self » vu partout… Pour cela, prenons un exemple.

Je crée le compte de Denis avec un solde initial de 100€. J’effectue un versement de 100€.

Il y a deux appels de méthodes :

- A l’appel de Compte, la fonction __init__ est appelée. Pour qu’init puisse affecter des valeurs
à l’objet créé c1, il faudrait normalement comme vous en avez l’habitude écrire
__init__(c1, « Denis »,100).
- A l’appel de depot, il faudrait de même écrire depot(c1,100)

Le « self » sert à ça ! self sera en réalité l’objet concerné, d’où le nom self en anglais…

Et c’est pour cela que lors de l’appel de méthodes (volontairement ou non (__init__)), il n’y a pas
d’argument à préciser pour self puisque la classe le place d’elle-même. Et il faudra bien évidemment
penser à mettre self en argument de toutes les classes qui agissent sur l’objet concerné.

Page 5 sur 12
 Dernière mise à jour Informatique Denis DEFAUCHY
24/12/2021 Programmation objet Cours

Pour obtenir toutes les méthodes prédéfinies dans python, on peut utiliser « dir ». Par exemple :

- « dir(list) » donnera toutes les méthodes utilisables sur les objets de type list
- « dir(math) » permettra d'obtenir la liste de toutes méthodes présentes dans le module math
(après l'avoir importé)

On peut observer :

- Les « magic methods ». Par exemple, pour les listes

o La méthode « __repr__ » est là pour afficher la liste dans la console quand on tape
« L » (une liste) puis « enter » dans la console
o La méthode « __add__ » définie ce que fait la somme de deux listes « L1+L2 »
- Les méthodes classiques que vous utilisez, comme « append »…

Page 6 sur 12
 Dernière mise à jour Informatique Denis DEFAUCHY
24/12/2021 Programmation objet Cours

1.I.3 Exemples

1.I.3.a Comptes en banque

class Compte():

def __init__(self,Nom="Absent",Solde=0):
self.nom = Nom
self.solde = Solde

def depot(self,Montant):
self.solde += Montant
print("Nouveau solde: ",self.solde)

def retrait(self,Montant):
self.solde -= Montant
print("Nouveau solde: ",self.solde)

def affiche(self):
print(self.nom,": ",self.solde)

Page 7 sur 12
 Dernière mise à jour Informatique Denis DEFAUCHY
24/12/2021 Programmation objet Cours

1.I.3.b Une petite blague

class int():

def __init__(self,Val):
self.val = Val

def __repr__(self):
return str(self.val)

def __add__(self,other):
return self.val + other.val + 1

On écrase la classe « int » de python ☺ et on la remplace par une autre ! Remarquez que j’ai utilisé des
méthodes magiques :

- On crée d’abord deux variables :

- __init__ permet de définir la valeur Val à l’objet

- __repr__ permet d’afficher la valeur de l’objet quand on l’entre et qu’on tape « Enter ».

En effet, sinon cela affiche :

Remarque : Vous avez probablement vu en première année cette possibilité offerte par
"{}".format de préciser dans une chaine de caractères aux bons endroits :

- __add__ permet de définir ce que doit faire l’opérateur « + » entre les objets « self » et
« other », add pour adition ! Vous verrez alors la supercherie ☺

Page 8 sur 12
 Dernière mise à jour Informatique Denis DEFAUCHY
24/12/2021 Programmation objet Cours

1.I.3.c Jeu de cartes

Soit le code suivant en POO :

# Import des librairies

from random import shuffle,randint

# Définition des classes

class Carte():
def __init__(self, f, c):
self.figure = f
self.couleur = c
def affiche (self):
s = self.figure + " de " + self.couleur
print(s)
def __repr__(self):
return str(self.figure) + " de " + str(self.couleur)

class JeuDeCartes ():

def __init__(self): # Création du jeu
couleur = ["Pique","Coeur","Carreau","Trèfle"]
valeur =
["1","2","3","4","5","6","7","8","9","10","Valet","Dame","Roi"]
self.cartes=[]
for coul in couleur:
for val in valeur:
self.cartes.append(Carte(val,coul))

def taille(self):
return len(self.cartes)

def battre(self): #~ Mélange des cartes

shuffle(self.cartes)

def tirer(self): # Tirage de la première carte de la pile

if len(self.cartes) == 0 :
print("Plus aucune carte")
return Carte("Fini","chez fini")
else:
t = randint (0, len(self.cartes)-1)
carte = self.cartes.pop(t)
return carte

# Manipulation des classes

jeu = JeuDeCartes()
jeu.battre()
c = jeu.tirer()
c.affiche()

Essayez de comprendre ce qu’il réalise.

Page 9 sur 12
 Dernière mise à jour Informatique Denis DEFAUCHY
24/12/2021 Programmation objet Cours

Voici une version non orientée objet qui réalise la même chose :

# Import des librairies

from random import shuffle,randint

# Définition des fonctions

def JeuDeCartes():
Liste_cartes = []
couleur = ["Pique","Coeur","Carreau","Trèfle"]
valeur =
["1","2","3","4","5","6","7","8","9","10","Valet","Dame","Roi"]
for coul in couleur:
for val in valeur:
Liste_cartes.append([val,coul])
return Liste_cartes

def Taille(Jeu):
return len(Jeu)

def Battre(Jeu):
shuffle(Jeu)

def Tirer(Jeu):
if len(Jeu) == 0 :
print("Plus aucune carte")
return ["Fini","chez fini"]
else:
t = randint (0, len(Jeu)-1)
carte = Jeu.pop(t)
return carte

# Manipulation des classes

Jeu = JeuDeCartes()
Battre(Jeu)
c = Tirer(Jeu)
print(c)

Page 10 sur 12
 Dernière mise à jour Informatique Denis DEFAUCHY
24/12/2021 Programmation objet Cours

1.I.3.d Particules

Voici deux codes qui réalisent la même chose :

## Code normal ## Code POO

from random import randint as rand from random import randint as rand

def Particule(): class Particule():

C = 'b' def __init__(self):
X = rand(0,10) self.C = 'b'
Y = rand(0,10) self.X = rand(0,10)
V = rand(0,5) self.Y = rand(0,10)
m = 0.2 self.V = rand(0,5)
R = rand(0,5) self.m = 0.2
Part = [X,Y,V,m,R,C] self.R = rand(0,5)
return Part def __repr__(self):
L = [self.X,self.Y,self.V,self.m,self.R,self.C]
def Particules(n): return str(L)
L_Part = []
for i in range(n): class Particules():
Part = Particule() def __init__(self,n):
L_Part.append(Part) self.n = n
return L_Part self.Particules = []
for i in range(n):
def Affiche(Liste_Part): Part = Particule()
for Part in Liste_Part: self.Particules.append(Part)
Part = Particule() def Affiche(self):
print(Part) for i in range(self.n):
Part = self.Particules[i]
Liste_Particules = Particules(10) print(Part)
Affiche(Liste_Particules)
Liste_Particules = Particules(10)
Liste_Particules.Affiche()

Page 11 sur 12
 Dernière mise à jour Informatique Denis DEFAUCHY
24/12/2021 Programmation objet Cours

1.I.4 Conclusions

Il existe bien des avantages à la POO qui ne sont pas mis en évidence dans cette initiation.

A notre niveau, on notera les petits plus apportés par la POO :

- La gestion des paramètres associées à chaque objet est aisée. Là où par exemple, une particule
serait associée à une liste [X,Y,V,m,R,C] et où le rayon serait Part[4], l’ajout d’un
paramètre avant R nécessiterait la modification de tout le code. En POO, il est aisé d’ajouter
un nouveau paramètre dans init et de l’appeler par son nom Part.Var
- Les paramètres et fonctions méthodes sont regroupées au même endroit pour un type d’objet,
alors qu’habituellement, les fonctions des codes classiques sont éparpillées dans tout le code
et les paramètres sont dans des tableaux, plus ou moins bien organisées… Il est aisé d’ajouter
des paramètres/méthodes à chaque type d’objet au bon endroit, c’est très clair
- Les méthodes sont adaptées au type d’objet. Ainsi, on pourrait créer des classes triangle, carré,
cercle, mettre des objets de ces 3 types dans une liste puis créer une boucle for appelant pour
chaque objet sa méthode objet.affiche() qui serait adaptée à chacun…

Page 12 sur 12