ROYAUME DU MAROC

‫مكتب التكوين المهني وإنعاش الشغل‬

office de la formation professionnelle et de la promotion du travail

ISMONTIC TETOUAN

Filière : Développement digital

Module: M103-Programmation Orienté Objet

PROGRAMMATION ORIENTÉE OBJET EN

PYTHON: GÉNÉRALITÉS

LAFHAL JOAIRIA

2023/2024
Introduction
La programmation orientée objet, souvent abrégée POO, permet de
concevoir une application sous la forme d'un ensemble de briques logicielles
appelées des objets.

Chaque objet joue un rôle précis et peut communiquer avec les autres objets.
Les interactions entre les différents objets vont permettre à l'application de
réaliser les fonctionnalités attendues.

La POO facilite la conception de programmes par réutilisation de

composants existants, avec tous les avantages évoqués plus haut. Elle
constitue le standard actuel (on parle de paradigme) en matière de
développement de logiciels.
Introduction

la programmation orientée objet consiste à concevoir une application sous la

forme de « briques » logicielles appelées des objets. Chaque objet joue un
rôle précis et peut communiquer avec les autres objets. Les interactions entre
les différents objets vont permettre à l'application de réaliser les
fonctionnalités attendues.

La notion de classe est à la base de la programmation orientée objet. Elle

définit un type d'objet.
Notion de classe
Le concept de classe est la base de tout langage de programmation orienté objet et a
le pouvoir de définir les caractéristiques d’un ensemble d’objets qui ont des
propriétés et effectuent les mêmes actions. En fait, elle représente tous les objets
appartenant à une certaine classe.

Par exemple (voitures) : chaque voiture est différente d’une autre mais elles ont
toutes quatre roues exécutent l’action de diriger ou freiner. Ces éléments communs
en font un concept unique. Une classe.

Plus concrètement, on peut dire qu’une classe est une collection de variables,
méthodes et propriété.
Une classe qui définit un type d’objet a la structure suivante :
✓ Son nom est celui du type que l’on veut créer.
✓ Elle contient les noms et le type des caractéristiques (les variables d’instances)
définissant les objets de ce type.
✓ Elle contient les méthodes applicables sur les objets de la classe.
la différence entre la classe et l'objet
Les classes et les objets sont les composants fondamentaux de la POO.
Le concept d’utilisation de classes et d’objets consiste à encapsuler l’état et le
comportement dans une seule unité de programmation.
Les objets python sont similaires aux objets du monde réel. Par exemple, nous
pouvons créer un objet voiture en python, qui aura des propriétés telles que la vitesse
et la couleur; et un comportement comme: accélérer et freiner.
Exemple :
Déclarer une classe
1. Syntaxe:

La déclaration d'une classe utilise le mot clé class :

class Nom_de_la_classe:
#corps de classe
Par convention en Python, le nom identifiant une classe (qu’on appelle aussi son
identifiant) débute par une majuscule.
Les membres (Les champs et/ou les méthodes) sont définis à l'intérieur du bloc.
Déclarer une classe
2. Instanciation des objets
Instanciation = création d’un objet à partir d’une classe
Objet = instance de classe.
Autrement dit, un objet est une variable conforme à un type, qui est une classe. Les
opérations de l’objet utilisent les valeurs des attributs de l’objet. En outre, un objet
possède une identité qui permet de le distinguer des autres objets.
Par exemple pour créer un objet de type MaClasse, on écrit :
Mon_objet= MaClasse();
#La variable mon_objet référence l’objet crée. On dit que l’objet est une instance de
MaClasse. Une classe définit un nouveau type dans le langage. La POO est d’abord
un modèle de programmation qui permet d’ajouter dans le langage des nouveaux
types d’objet.
Déclarer une classe
3. Tester le type d’un objet
En Python, il existe deux fonctions standards intéressantes pour connaître et tester le
type d’un objet :
type(o): Retourne le type de l’objet passé en paramètre.
Exemple: type(mon_objet) ➔ <class '__main__.MaClasse'>
isinstance(o, cls): Retourne True si l’objet passé en premier paramètre est une
instance de la classe passée en deuxième paramètre.
Exemple: isinstance(mon_objet, MaClasse) ➔True
Déclarer une classe
4. Les champs (les attributs):
Les attributs sont des variables qui sont associées de manière explicite à une classe.
Les attributs de la classe se comportent comme des variables globales pour toutes les
méthodes de cette classe.
Les attributs représentent l’état interne d’un objet.
Pour définir un attribut au sein d'une classe, il suffit :
d'assigner une valeur à cet attribut dans le corps de la classe :
class Cercle:
# Déclaration d'un attribut de classe 'rayon'
# auquel on assigne la valeur 2.
rayon=2
d'assigner une valeur à cet attribut en dehors de la classe. On parle alors d'attribut
dynamique :
class Cercle:
# Le corps de la classe est laissé vide.
pass
# Déclaration dynamique d'un attribut de classe 'rayon'
# auquel on assigne la valeur 2.
Cercle.rayon = 2
print(Cercle.rayon) #>>2
Déclarer une classe
4. Les champs (les attributs):
Les attributs définis ainsi sont appelés « attributs de classe » car ils sont liés à la
classe, par opposition aux « attributs d'instance » dont la vie est liée à l'instance à
laquelle ils sont rattachés. Les attributs de classe sont automatiquement reportés
dans les instances de cette classe et deviennent des attributs d'instance:
class Cercle:
pass

c1=Cercle()
c1.rayon=2
print(c1.rayon) #2
c2=Cercle()
print(c2.rayon) #AttributeError: 'Cercle' object has no attribute 'rayon'
Déclarer une classe
5. Les méthodes:
Les méthodes sont des fonctions qui sont associées de manière explicite à une classe.
Elles ont comme particularité un accès privilégié aux attributs de la classe elle-
même.
Les méthodes sont en fait des fonctions pour lesquelles la liste des paramètres
contient obligatoirement un paramètre explicite qui est l’instance de la classe à
laquelle cette méthode est associée. Ce paramètre est le moyen d’accéder aux
données de la classe.
Syntaxe:
class nom_classe :
def nom_methode(self, param_1, ..., param_n):
# corps de la méthode...
Déclarer une classe
5. Les méthodes:
A part le premier paramètre qui doit de préférence s’appeler self, la syntaxe de
définition d’une méthode ressemble en tout point à celle d’une fonction. Le corps de
la méthode est indenté par rapport à la déclaration de la méthode, elle-même
indentée par rapport à la déclaration de la classe.
Comme une fonction, une méthode suppose que les arguments qu’elle reçoit existe, y
compris self. On écrit la méthode en supposant qu’un objet existe qu’on nomme self.
L’appel à cette méthode obéit à la syntaxe qui suit :
cl = nom_classe() # variable de type nom_classe
cl.nom_methode (valeur_1, ..., valeur_n)
L’appel d’une méthode nécessite tout d’abord la création d’une variable. Une fois
cette variable créée, il suffit d’ajouter le symbole « . » pour exécuter la méthode. Le
paramètre self est ici implicitement remplacé par cl lors de l’appel.
 Déclarer une classe
6. Exemple: #création des objets
#déclaration de la classe p1=Personne()
class Personne: print(p1.nom)
#déclaration des attributs p1.nom="Kadiri"
nom="Allali" p1.bienVenue()
prenom="Ahmed" nomC=p1.nomComplet()
age=20 print(nomC)
estMarie=False anneN=p1.anneeNaissan
#déclaration des méthodes ce(2022)
def bienVenue(self): print(anneN)
print("Bonjour")
def nomComplet(self):
return "Nom Complet:"+self.nom +" "+self.prenom
def anneeNaissance(self,anneeActuelle):
return anneeActuelle-self.age
Déclarer une classe
7. Constructeur:
Les constructeurs sont généralement utilisés pour instancier un objet. La tâche des
constructeurs consiste à initialiser (attribuer des valeurs) aux attributs de la classe
lorsqu'un objet de la classe est créé.
En Python, la méthode __init __ () est appelée le constructeur et est toujours
appelée. quand un objet est créé.
Syntaxe:
def __init__(self, liste_parameters):
# Initialisiation
Types de constructeurs:
constructeur par défaut: le constructeur par défaut est un constructeur simple qui
n’accepte aucun argument. Sa définition n’a qu’un seul argument qui soit une
référence à l’instance en cours de construction.
constructeur paramétré: Le constructeur paramétré prend son premier argument
en tant que référence à l'instance en cours de construction, appelée self, et le reste
des arguments est fourni par le programmeur.
Déclarer une classe
7. Constructeur:
Exemple:
class Personne:
def __init__(self,nomIn,ageIn):
self.nom=nomIn
self.age=ageIn

p1=Personne("Allali",20)
p2=Personne("Kadiri",22)
print(p1.nom,"a ",p1.age,"ans") #Allali a 20 ans
print(p2.nom,"a ",p2.age,"ans") #Kadiri a 22 ans
Déclarer une classe
8. Destructeur:
Les destructeurs sont appelés lorsqu'un objet est détruit. En Python, les destructeurs ne
sont pas aussi nécessaires que en C++, car Python dispose d'un ramasse-miettes qui
gère automatiquement la gestion de la mémoire.
La méthode __del __ () est une méthode appelée destructeur en Python. Il est appelé
lorsque toutes les références à l’objet ont été supprimées, c’est-à-dire lorsqu’un objet
est nettoyé.
Syntaxe:
def __del__(self):
# actions
Exemple:
class Personne:
def __init__(self,nomIn,ageIn):
self.nom=nomIn
self.age=ageIn
def __del__(self):
print("je suis le destructeur")
p1=Personne("Allali",20)
print(p1.nom) #Allali
del p1 #je suis le destructeur
print(p1.nom) #NameError: name 'p1' is not defined
Déclarer une classe
9. Exercice d’application:
Réaliser une classe Point permettant de manipuler un point d'un plan. On prévoira :

1. un point est défini par ses coordonnées x et y

2. un constructeur d’initialisation qui permet d’initialiser x et y.

3. une fonction membre déplace effectuant une translation définie par ses deux

arguments dx et dy.

4. une procédure membre affiche se contentant d'afficher les coordonnées cartésiennes

du point.
Déclarer une classe
10. Principe d’encapsulation:
L'encapsulation consiste à masquer des données de l'état interne pour protéger
l'intégrité de l'objet.
Un membre d'une classe désigne un attribut ou une méthode définie dans cette classe.
La visibilité des membres d'une classe définit les endroits d'où ils peuvent être utilisés.
Dans cette partie du cours, nous allons voir deux sortes de visibilité: la
visibilité publique et la visibilité privée.
Les membres privés d'une classe ne sont accessibles que par les méthodes de la classe:
Les attributs privés d'une classe ne peuvent être utilisés que par les méthodes de
cette classe.
Les méthodes privées d'une classe ne peuvent être appelées que par les méthodes
de cette classe.
Les membres publics d'une classe sont accessibles de l'intérieur et de l'extérieur de la
classe, par conséquent:
Les attributs publiques d'une classe sont donc accessibles (en lecture ou en
écriture) depuis n'importe quelle méthode.
Les méthodes publiques d'une classe peuvent être appelées par n'importe quelle
méthode.
Déclarer une classe
10. Principe d’encapsulation:
En Python, il n’existe pas de mécanisme dans le langage qui nous permettrait de gérer
la visibilité. Par contre, il existe une convention dans le nommage.
Une méthode ou un attribut dont le nom commence par __ (underscore) est considéré
comme privé. Il est donc déconseillé d’accéder à un tel attribut ou d’appeler une telle
méthode depuis l’extérieur de l’objet.
Les attributs privés d'une classe ne peuvent être utilisés que par les méthodes de cette
classe. Les méthodes privées d'une classe ne peuvent être appelées que par les
méthodes de cette classe.
Exemple:
class Personne:
def __init__(self,nom):
self.nom=nom
self.__age=20

p1=Personne("Allali")
print(p1.__age) #AttributeError: 'Personne' object has no attribute '__age'
Déclarer une classe
10. les accesseurs et mutateurs:
L'encapsulation d'une classe interdit d'accéder à ses attributs depuis l'extérieur, mais
elle autorise d'y accéder indirectement via des méthodes. Les méthodes jouant ce rôle
sont appelées des accesseurs et les mutateurs.
les accesseurs (en anglais accessor) qui fournissent des informations relatives à
l’état d’un objet, c’est-à-dire aux valeurs de certains de ses attributs (généralement
privés) sans les modifier ;
les mutateurs (en anglais mutator) qui modifient l’état d’un objet, donc les valeurs
de certains de ses attributs.
On rencontre souvent l’utilisation de noms de la forme get_XXXX() pour les
accesseurs et set_XXXX() pour les mutateurs, y compris dans des programmes dans
lesquels les noms de variable sont francisés.
Déclarer une classe
10. les accesseurs et mutateurs:
Exemple:
class Personne:
def __init__(self,nomA,prenomA):
self.__nom=nomA
self.__prenom=prenomA
def getNom(self):
return self.__nom
def setNom(self,nom):
self.__nom=nom
def getPrenom(self):
return self.__prenom
def setPrenom(self,prenom):
self.__prenom=prenom

p=Personne("allali","ahmed")
print(p.__nom) #AttributeError: 'Personne' object has no attribute '__nom'
print(p.getNom()) #allali
p.setNom("kadiri")
print(p.getNom())#Kadiri
Attributs et méthodes statiques

Python fournit une fonctionnalité permettant de maintenir les membres au

niveau de la classe plutôt qu'au niveau de l'objet.
Il existe certains scénarios dans lesquels vous souhaitez stocker des données
ou définir des fonctions qui ont un sens au niveau de la classe plutôt que par
objet.
Les membres sont appelés membres statiques. Il existe deux types de
membres statiques.
Variables statiques
Méthodes statiques
Attributs et méthodes statiques
1. Attributs statiques
les données attributs, sont des variables appartenant à une instance
particulière d'une classe. Python permet aussi les attributs de classe, qui sont
des variables appartenant à la classe elle-même.

Les variables statiques sont les variables dont la valeur est définie au niveau
de la classe. Il n’est pas nécessaire d’avoir une instance de classe pour
accéder aux variables statiques.
Ces attributs sont partagés par toutes les instances.
Attributs et méthodes statiques
1. Attributs statiques
Syntaxe:
class Nom_class :
attribut_statique = valeur
def nom_methode (self,params, ...):
Nom_class.attribut_statique2 = valeur2

Les deux paramètres attribut_statique, attribut_statique2 sont statiques, soit parce

qu’ils sont déclarés en dehors d’une méthode, soit parce que leur déclaration fait
intervenir le nom de la classe

Appel d’un attribut statique: Nom_Class. attribut_statique

Attributs et méthodes statiques
1. Attributs statiques
Exemple:
class Personne:
nombreObjets=0
def __init__(self,nom,age):
self.nom=nom
self.age=age
Personne.nombreObjets+=1

Utilisation
p1=Personne("allali",20)
p2=Personne("kadiri",19)
p3=Personne("Mrabti",20)
print(Personne.nombreObjets) #3
Attributs et méthodes statiques
2. Méthodes statiques
Une méthode de classe ou une méthode statique est une méthode qui n'agit pas sur
des variables d'instance mais uniquement sur des variables de classe.
On déclare une méthode statique d’une classe :
en préfixant la déclaration du décorateur @staticmethod.
elle peut être appelée même sans avoir instancié la classe
elle peut accéder uniquement à des variables et méthodes statiques
elle peut être appelée avec la notation classe.methode() au lieu de
objet.methode()
Les méthodes statiques sont utiles lors de la création de méthodes utilitaires qui
effectuent une tâche de manière isolée car elles n’ont pas besoin d’accéder ou de
modifier les propriétés d’une classe ; cela ne fonctionne qu’avec les données
passées dans les arguments.
Attributs et méthodes statiques
2. Méthodes statiques
Une méthode de classe ou une méthode statique est une méthode qui n'agit pas sur
des variables d'instance mais uniquement sur des variables de classe.
On déclare une méthode statique d’une classe :
en préfixant la déclaration du décorateur @staticmethod.
elle peut être appelée même sans avoir instancié la classe
elle peut accéder uniquement à des variables et méthodes statiques
elle peut être appelée avec la notation classe.methode() au lieu de
objet.methode()
Les méthodes statiques sont utiles lors de la création de méthodes utilitaires qui
effectuent une tâche de manière isolée car elles n’ont pas besoin d’accéder ou de
modifier les propriétés d’une classe ; cela ne fonctionne qu’avec les données
passées dans les arguments.
Attributs et méthodes statiques
2. Méthodes statiques
Syntaxe:
class Nom_Class:
@staticmethod
def methodeStatique():
#traitement

Utilisation: Nom_Class.methodeStatique()
Attributs et méthodes statiques
2. Méthodes statiques
Exemple:
class Personne:
nombreObjets=0
def __init__(self,nom,age):
self.nom=nom
self.age=age
Personne.nombreObjets+=1
@staticmethod
def affichage():
print(Personne.nombreObjets)
@staticmethod
def affichageInfo(p):
print(p.nom,p.age)
Utilisation:
p1=Personne("allali",20)
p2=Personne("Mrabti",19)
Personne.affichage() #2
Personne.affichageInfo(p1) #allali 20
Attributs et méthodes statiques
3. Exercice d’application
Réaliser une classe Vecteur3d permettant de manipuler des vecteurs à trois
composantes et disposant :
1. Un attribut partagé qui permet de compter le nombre d’instances
2. d’un constructeur à trois arguments,
3. d’une méthode d’affichage des coordonnées du vecteur, sous la forme : <
composante_1, composante_2, composante_3 >
4. d’une méthode fournissant la norme d’un vecteur,
5. d’une méthode (statique) fournissant la somme de deux vecteurs,
6. d’une méthode (non statique) fournissant le produit scalaire de deux
vecteurs.
7. Écrire un petit programme utilisant cette classe.