m103 Poo Complet

DÉVELOPPEMENT DIGITAL
PROGRAMMER EN
ORIENTÉ OBJET
Durée : 110 heures

OBJECTIF A l’issue de ce module de
compétence, vous serez capable de
programmer en Orientée Objet
(POO)
2
SOMMAIRE
PARTIE 1 PARTIE 2 PARTIE 3
Appréhender le paradigme de la POO Connaître les principaux piliers de la POO Appliquer la POO dans le langage de
programmation Python
Chapitre 1 : Définir l’héritage et le

Chapitre 1 : Introduire la POO polymorphisme Chapitre 1 : Présenter l’environnement de
Chapitre 2 : Définir un objet Chapitre 2 : Connaître l’encapsulation programmation Python 3
Chapitre 2 : Implémenter une classe
Chapitre 3 : Caractériser l’abstraction
Chapitre 3 : Administrer les exceptions
Chapitre 4 : Gérer le interfaces graphiques
CHAPITRE 1 1- Programmation procédurale
2- De la programmation procédurale à la POO
INTRODUIRE LA POO
3 - Avantages de la POO
4 - Historique de la POO
Programmation procédurale
Dans la programmation procédurale, le programme est divisé en petites parties appelées procédures ou
fonctions.
• Ensuite, pour résoudre chaque partie, une ou plusieurs procédures/fonctions sont utilisées
• Dans la programmation procédurale, les notions de données et de traitement de ces données sont
séparées
Programmes = Procédures/Fonctions + Données
5
Dans la programmation procédurale:
• Les données constituent la partie passive du programme.
• Les procédures et les fonctions constituent la partie active.
Programmer dans ce cas revenait à:
• définir un certain nombre de variables (entier, chaine de caractères, structures,

tableaux, etc.)
• écrire des procédures pour les manipuler.

6
Inconvénients:
 Difficulté de réutilisation du code
 Difficulté de la maintenance de grandes applications
 Pas de cadre bien défini pour organiser les fonctions
 La modification d’une fonction entraine la modification d’une
autre
 La portée d’une modification est trop difficile à gérer
 Redondance du code
 Propagation des erreurs et débogage difficile
7
Paradigmes de programmation
Programmation structurée (procédurale )
Programmation structurée (traditionnelle ou classique)
 Séparation des données et des opérations

 Initialisation des structures de données
 Traitement des données par les procédures et les fonctions
Programmation orientée objet (POO)
 Une même structure contient les données et les opérations associées
Historique de la POO
 Origine : langage Simula 67 en 1967

 Intérêt grandissant à partir du milieu des années 80 : C++, Java,
Python, …
 Programmes: éléments actifs et importants comportant les
opérations séquentielles nécessaires pour résoudre un problème
 Données: éléments passifs qui traversent l’arborescence de la programmation
procédurale en tant que flot d’informations
Programmation orientée objet

 Fondée sur une seule catégorie d’´éléments: “les objets” qui communiquent
entre eux grâce `a l’envoi de messages (des operateurs appelés méthodes)
 Par rapport à un langage impératif typé, un objet est l’´équivalent d’une variable
(simple ou structurée) et la classe dont il est l’instance correspond au type de la
variable
programmation procédurale :
P.P. (Pascal, C, etc.)
programmation orientée objet :

P.O.O. (C++, Java, Delphi, C#,Python)
etc.
Exemple de code en C
Programmation procédurale vs Programmation orientée objet
Programmation procédurale vs Programmation orientée objet
Les concepts de base de la POO
Schéma comparatif – programmation procédurale versus objet
programmation procédurale programmation orientée objet

INTRODUIRE LA POO
3- Avantages de la POO
4- Historique de la POO
• Séparation (données, procédures) est-elle utile ?
• Pourquoi privilégier les procédures sur les données ?
• Pourquoi ne pas considérer que les programmes sont avant tout des ensembles
objets informatiques caractérisé par les opérations qu’ils connaissent?
Les langages orientés objets sont nés pour répondre à ces questions.
Ils sont fondés sur la connaissance d’une seule catégorie d’entités informatiques :
LES OBJETS
1
7
 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.
La Programmation Orientée Objet (ou POO) est un paradigme de programmation dans
lequel les programmes sont écrits et structurés autour des objets plutôt que des fonctions
ou de logique. Ici, les objets sont définis comme des champs de données qui ont des
attributs et un comportement uniques.
Pour bien comprendre, regardons un exemple dans la vrai vie, une voiture est un objet,
avec ses attributs (type, modèle, prix, couleurs, etc…) et ses méthodes (accélérer, ralentir,
tourner, freiner, etc.).
• Un objet incorpore des aspects statiques et dynamiques au sein
d’une même notion
• Un programme est constitué d’un ensemble d’objets chacun

disposant d’une partie procédure (traitement) et d’une partie
données.
2
0
Que doit faire le

système ?
Sur quoi doit-il le

faire?
De quoi doit être

composé mon
programme?
Programmation Orientée Objet
2
1
Créditer un
compte?
Débiter un
compte?
Programmation procédurale Programme de Gestion des

comptes bancaires
Comment se
présente (structure)
d’un compte
bancaire ?
2
2
Concepts de POO
INTRODUIRE LA POO 3- Avantages de la POO
4- Historique de la POO
Motivation et avantage de la POO
Motivation : concevoir, maintenir et exploiter facilement de gros logiciels
Avantages:
• Modularité : les objets forment des modules compacts regroupant des données et un ensemble
d'opérations ce qui réduit la complexité de l’application (classe = module)
• Abstraction :
• Les entités objets de la POO sont proches de celles du monde réel (objet est un compte, stagiaire,
formateur, etc.).
• La POO se base sur un processus qui consiste à masquer des détails non pertinents à l’utilisateur.
Exemple:
Pour envoyez un SMS, vous tapez simplement le message, sélectionnez le contact et cliquez sur Envoyer ce
qui se passe réellement en arrière-plan est masqué car il n’est pas pertinent à vous.2
5
Avantages de la POO
Réutilisabilité:
• La POO favoriser la réutilisation de composants logiciels et même

d'architectures complexes
• La définition d’une relation d’héritage entre les entités logicielle évite la

duplication de code
• Facilité de la maintenance logicielle et amélioration de la productivité
2
6
Avantages de la POO
Avantages
 Développement plus facile (et souvent plus rapide)
 Fonctionnement plus stable
 améliorer la réutilisation des outils existants
 s’éloigner de la machine et se rapprocher du problème à résoudre.
 développer une approche mieux adaptée à la résolution de problèmes.
 Nouvelle façon de penser la décomposition de problèmes et l’élaboration
de solutions.
 Maintenance plus simple
 Augmentation de la qualité des logiciels (moins de bugs)
 Une approche différente pour rapprocher le développement et notre
manière de concevoir le monde
2- De la programmation procédurale à la POO 3
INTRODUIRE LA POO
- Avantages de la POO
4 - Historique de la POO
Historique évolution de la POO
• Les concepts de la POO naissent au cours des années 1970 dans des
laboratoires de recherche en informatique.
• Les premiers langages de programmation véritablement orientés objet ont

été Simula, puis Smalltalk.
• Simula (1966) regroupe données et procédures.
• Simula I (1972) formalise les concepts d'objet et de classe. Un programme
est constitué d’ une collection d'objets actifs et autonomes.
• Smalltalk (1972) : généralisation de la notion d'objet.
2
9
Historique évolution de la POO
• A partir des années 80, les principes de la POO sont appliqués dans de nombreux langages
• Eiffel créé par le Français Bertrand Meyer
• C++ est une extension objet du langage C créé par le Danois Bjarne Stroustrup
• Objective C une autre extension objet du C utilisé, entre autres, par l'iOS d'Apple
• Les années 1990 ont vu l'avènement des PPOs dans de nombreux secteurs du développement
logiciel, et la
création du langage Java par la société Sun Microsystems
• De nos jours, de très nombreux langages permettent d'utiliser les principes de la POO dans des
domaines variés tels que PHP (à partir de la version 5), VB.NET, PowerShell, Python, etc.
3
0
• Comment peut on y arriver?
Introduction des nouvelles (?) notions
objet
classe
instanciation
hiérarchie des classes
héritage
événement
• On va utiliser ces notions pour introduire le paradigme de
programmation orientée objet.
CHAPITRE 2 1- Notion d’objet
DÉFINIR UN OBJET
2- Notion de classe
3– Constructeur/Destructeur
4– Objets en interaction
Notion d’objet
Définition d’un objet
Un objet représente une entité du monde réel, ou de monde virtuel dans le cas
d’objets immatériels, qui se caractérisent par une identité (id), des états (attribut)
significatifs et par un comportement (méthode).
 Un objet est capable de sauvegarder un état c'est-à-dire un ensemble d’information

dans des variables internes (attributs)
Son état correspond aux valeurs de tous les attributs à un instant donné.
 L’identité d’un objet permet de distinguer les objets les uns par rapport aux autres.
 Le comportement d’un objet se défini par l’ensemble des opérations qu’il peut
exécuter en réaction aux messages envoyés (un message = demande d’exécution
d’une opération) par les autres objets.
Notion d’objet
OBJET= Référent + Etat + Comportement
• Chaque objet doit avoir un nom (référence) « qui lui est propre » pour l’identifier
• La référence permet d’accéder à l’objet, mais n’est pas l’objet lui-même. Elle contient
l’adresse de l’emplacement mémoire dans lequel est stocké l’objet.
• Mémoire
• @0x304009
0x304009 Objet
Référence P1
Notion d’objet
• Plusieurs référents peuvent référer un même objet→ adressage indirect
Mémoire P1=P2
0x304009 Objet 1 Mémoire
P1
0x504010 Objet 1
0x504010 Objet 2 P1
P2
Mémoire des objets 0x504010 Objet 2
P2
Recopie l’adresse de P2
dans le réfèrent de P1 Mémoire des objets
Notion d’objet
Exemple d’objets où chaque attribut est d’un type dit «primitif » ou « prédéfini », comme entier, réel, caractère…
Attribut Valeur
Première_Voiture
Couleur=rouge
0x304009
Marque=Peugeot
Deuxième_Voiture
Couleur=Noir
0x304021
Marque=Citroën
Premier-Arbre-Dans-Larue
Type: Citronnier
0x304100
Hauteur: 2
Mémoire des objets

Notion d’objet
Un objet stocké en mémoire peut être placé à l’intérieur de l’espace mémoire réservé à
un autre. Il s’agit d’un Objet Composite
Première_Voiture:
Première_Voiture Objet composite
0x304009 Couleur=rouge
Marque=Peugeot
Moteur1 Moteur1:
Moteur=Moteur1
0x304021 Objet composant
Puissance=100
Marque=XX
Mémoire des objets

Notion d’objet
• Les objets changent d’état
• Le cycle de vie d’un objet se limite à une succession de changements d’états
• Soit l’objet Feu_de_signalisation_EnQuestion avec sa couleur et ses trois valeurs
Feu_de_signalisation_EnQuestion
Couleur=1
0x304021
Couleur=2
Couleur=3
Mémoire des objets

Notion d’objet
OBJET= Référent + Etat +Comportement
Mais qui est la cause des changements d’états ?
– LES METHODES
Feu_de_signalisation
_EnQuestion Change()
0x304021 Couleur=1
Couleur=Couleur+1
If(Couleur==4)
Couleur=1
Mémoire des objets Mémoire des méthodes

Définition d’une application orientée objet

Une application orientée objet
Définition d’un ensemble d’objets coopérants -

communicants - et concurrents - vivants indépendamment les
uns des autres.
Introduction
 la programmation orientée objet consiste à 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 à l'application
de réaliser les fonctionnalités attendues.
 La notion de classe est à la base de la programmation orientée objet. Elle

définit un type d'objet.
DÉFINIR UN OBJET
2- Notion de classe
3– Constructeur/Destructeur
4– Objets en interaction
Notion de classe
Le concept de classe est la base de tout langage de programmation orienté 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 à 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.
Notion de classe
Notion de classe
Une classe est la description d'une famille d'objets qui ont la même
structure et les mêmes comportements.
Nom
Attributs
méthodes
Notion de classe
Une classe unit les méthodes aux attributs
CLASSE= Attributs + Méthodes
Une classe est un modèle de définition pour les objets

ayant:
• même structure (même ensemble d’attributs)
• même comportement (mêmes méthodes)

Notion de classe
Python est un langage de programmation orienté objet. Presque

tout en Python est un objet, avec ses propriétés et ses
méthodes.
Une classe est comme un usine d’objet pour créer des objets.
Notion de classe
• Les objets sont des représentations dynamiques (instanciation), « vivantes » du
modèle défini pour eux au travers de la classe.
• Une classe permet d’instancier (créer) plusieurs objets
• Chaque objet est une instance (un exemplaire)

d’une (seule) classe
4
7
 Une classe est la généralisation de la notion de type défini par l’utilisateur
 Classe : association à la fois les données et les fonctions
 Les objets sont des instances de classes. Ils possèdent les mêmes
caractéristiques que les variables ordinaires
 Pour créer un objet, il faut d'abord créer une classe
Vocabulaire : on dit qu'un objet est une instance d'une classe.

C'est un mot très courant que l'on rencontre souvent en POO. Cela signifie
qu'un objet est la matérialisation concrète d'une classe (tout comme une
maison est la matérialisation concrète du plan de la maison)
Notion de classe
Classe Feu_de_Signalisation
objet1 Feu_de_Signalisation1
Couleur =1
Feu_de_Signalisation instanciation Change()
Attributs
Couleur instanciation Feu_de_Signalisation2
Méthodes Change() Couleur =2
objet2
Change()
Avion_airbus a380
Classe Avion
objet1 Etat= En VOl
Avion Contenu réservoir= 40l
instanciation Atterrir()
Attributs EtatContenuRéservoir
instanciation Avion_airbus a320
Méthodes Etat= Au Sol
Atterrir() objet2
ContenuRéservoir= 25l
Atterrir()
4
9
Objet: instance d’une classe
• Chaque objet correspond à une instance de la classe à laquelle il fait
référence
• La création d’un objet est constituée de deux phases:
• Une phase de ressort de la classe: allouer de la mémoire et un
contexte d’exécution minimaliste.
• Une phase du ressort de l’objet: initialiser ses attributs d’instances
• Dans les langages, ces deux phases ne sont pas différenciées.
→ Appel à une méthode spéciale : le constructeur
5
0
Objet: instance d’une classe
Appel d’une méthode d’une classe instanceDeClasse.méthode()
Exemple: Soit la classe Feu_De_Signalisation

Classe Feu_de_Signalisation
Feu_de_signalisation_EnQuestion
Feu_de_Signalisation
0x304021 Couleur=1 Couleur
Change()
Mémoire des objets
Feu_de_signalisation_EnQuestion.change()
Feu_de_signalisation_EnQuestion Application de la méthode change() définie
dans la classe Feu_de_Signalisation
0x304021 Couleur=2
Mémoire des objets

5
1
Notion de classe
La création d’une classe en python commence toujours par le
mot class.
Ensuite toutes les instructions de la classe seront indentées :
La classe est une espèce de moule , à partir de ce moule nous

allons créer des objets
). (plus exactement nous parlerons
d'instances
Notion de classe
L’instruction pass
la définition d’une classe ne peut pas être vide, mais si pour une raison
quelconque vous avez une définition de classe sans contenu, insérez
l’instruction pass pour éviter d’obtenir une erreur.
Conventions
Prenez l'habitude de nommer votre classe uniquement avec des caractères
alphanumériques et commençant par une majuscule. Et à l'inverse l'instance
peut être nommée sans majuscule.
Notion de classe
Puis créer différentes instances de cette classe (Peugeot407, Renault Espace,…).

Pour créer une de ces instances, la procédure est relativement simple :
Cette ligne veut tout simplement dire : “crée un objet (une instance) de la
classe Voiture que l’on nommera peugeot407.”
Ensuite, rien ne nous empêche de créer une deuxième instance de la classe Voiture :
Notion de classe
Les attributs
 Un attribut est une variable associée à une classe.
 Pour définir un attribut au sein d’une classe , il suffit :
-d’assigner une valeur à cet attribut dans le corps de la classe :
-d’assigner une valeur à cet attribut en dehors de la classe

On parle alors d’attribut dynamique
Notion de classe
Comme tout autre langage de programmation orientée objet, Python prend en charge les classes.
 Les classes sont créées par mot-clé class.
 Les attributs sont les variables qui appartiennent à la classe.
 Les attributs sont toujours publiques et sont accessibles à l’aide de l’opérateur point (.).
Ex .: NomClass.NomAttribut
En Exécution
Un autre exemple de classe
Notion de classe
Les méthodes
Dans notre classe on pourra aussi ajouter des fonctions.
Définition :
Une fonction définie au sein d’une classe est appelée méthode.
Pour exécuter une méthode à l’extérieur de la classe,
la syntaxe générale est instance.méthode().
Voici un exemple d’ajout d’une fonction, ou plus exactement d’une méthode, au sein d’une
classe (attention à l’indentation !) :
À l'intérieur d'une classe, on ne

parle plus de fonctions mais
de méthodes.
Notion de classe
On définit une méthode nommée .salam() qui va afficher un petit message.
Attention, cette méthode prend obligatoirement un argument que nous avons
nommé ici self.
On crée l’instance e de la classe Etudiant , puis on exécute la méthode

.salam() avec une syntaxe instance.méthode().
Il s'agit en fait d'une référence vers l'instance en cours

Notion de classe
self est utilisé pour représenter l'instance de la classe ! C'est grâce à lui que je peux
donc accéder aux attributs et aux méthodes de ma classe.
La méthode rouler dans la classe Velo a comme premier paramètre self :
def rouler (self):

print('ça roule mieux avec un vélo de bonne marque')
De ce fait, on peux appeler cette méthode rouler sur toutes les instances que on a
créées.
self permet à l’utilisateur de spécifier et d’accéder aux attributs et aux méthodes
d’une instance de la classe
Notion de classe
self n'a pas besoin d'être utilisé lors de l'appel d'une

méthode alors que vous avez déjà une instance disponible.
Note:
Sache que tu n'es pas obligé d'utiliser explicitement le mot self car
en réalité ce n'est pas un mot réservé en Python.
Si tu viens d'un autre langage de programmation comme
JavaScript, tu as peut-être l'habitude d'utiliser this.
En Python, on utilise le mot self par convention
Notion de classe
Les attributs de classe
Si on ajoute une variable dans une classe comme on créait une variable
locale dans une fonction, on crée ce qu’on appelle un attribut de classe :
Définition :
Une variable de classe ou attribut de classe est un attribut qui sera identique
pour chaque instance. On verra que de tels attributs suivent des règles différentes par
rapport aux attributs d’instance.
À l’extérieur ou à l’intérieur d’une classe, un attribut de classe peut se retrouver

avec une syntaxe NomClasse.attribut :
Notion de classe
Définition :
Une variable de classe est une variable qui est partagée par toutes les instances de ta classe
Une variable de classe est une variable qui est partagée par toutes les instances de ta
classe.
Dans notre classe Velo, la variable roues est une variable de classe. Ce qui est plutôt
logique car tous les vélos ou presque roulent sur deux roues et pas plus
De l'autre côté, on a les variables d'instances dont les valeurs diffèrent d'une
instance à une autre.
Membre de classe vs membre d’instance
Un membre est un attribut ou une méthode. Il existe 2 types de membres (de classe/d’instance)
• Membre de classe • Membre d'instance

• Un Attribut de classe est associé à sa classe et non à Un attribut d'instance est associée à une instance
une instance de cette classe. de la classe.
Chaque objet possède donc sa propre copie de la
• Méthode de classe est associée à une classe et
propriété
non à un objet.
Remarque: Une méthode d'instance est associée à une
• Une méthode de classe ne peut exploiter que des instance d'une classe.
membres de classe Chaque objet possède donc sa propre copie de la
• Une méthode d'instance peut utiliser n'importe méthode.
quel type de membre (classe ou instance)
6
4
Membre de classe vs membre d’instance
Exemple: Classe Avion
la classe Avion suivante
Avion
Attribut d’instance EtatContenuRéservoir
Attribut de classe NombreAvions
Méthode d’instance Atterrir()
Méthode de classe CompterNombreAvions()
6
5
Exercice 1
1. Créer la classe Stagiaire avec les attributs suivants : numins, nom, prenom, dateNaissance
et le nombre de stagiaire.
2. Instancier 2 objets de type Stagiaire .
3. Demander à l’utilisateur de saisir les informations du deuxième objet.
4. Afficher les informations des ces deux Stagiaire
5. Créer la classe Saluer avec la méthode dire qui affiche un texte pour le paramètre nom
6. Instancier 1 objet de type Saluer
7. afficher le texte « bonjour » à le nom « Ali »
8. Créer un docstring pour la classe Saluer (texte expliquant la classe)
9. Afficher le docstring de la classe Saluer.
10.Afficher le texte « bonjour » à un objet de la classe personne
Exercice 1
1. Créer la classe Stagiaire avec les attributs suivants : numins, nom, prenom, dateNaissance et le nombre de stagiaire.
Un autre exemple de classe
Créer la classe saluer avec la méthode dire

Pour afficher une docstring d’une classe, exécutez le code suivant.
Les docstrings sont des chaines de doc qui doivent être placées juste en dessous des définitions de
fonction ou de classe, ou bien tout en haut d'un module.
L'intérêt, c'est que les docstrings sont récupérables dynamiquement via l'attribut __doc__, ou grâce à la
fonction primitive help( ). Ça permet notamment de faire de la documentation autogénérée :
2- Notion de classe
DÉFINIR UN OBJET
3- Constructeur/Destructeur
4- Objets en interaction
 Lors de l'instanciation d'un objet à partir d'une classe, il peut être intéressant
de lancer des instructions comme par exemple initialiser certaines variables.
 Pour cela, on ajoute une méthode spéciale nommée .__init__() : cette
méthode s'appelle le « constructeur » de la classe : en effet, elle sert au
fonctionnement interne de notre classe
 le constructeur est appelé lors de la création d'un nouvel objet. Il s'agit en
fait d'une méthode particulière dont le code est exécuté lorsqu'une classe
est instanciée.
 Ce constructeur est exécuté à chaque instanciation de notre classe, et ne
renvoie pas de valeur, il ne possède donc pas de return.
Constructeur
 Le constructeur d'une classe est une méthode appelée une seule fois par objet et au
moment de sa création
 Le constructeur se définit dans une classe comme une fonction avec deux particularités :
 le nom de la fonction doit être __init__ ;
 la fonction doit accepter au moins un paramètre, dont le nom doit être self, et qui
doit être le premier paramètre.
Le paramètre self représente en fait l'objet cible, c'est-à-dire que c'est une variable qui
contient une référence vers l'objet qui est en cours de création. Grâce à ce dernier, on
va pouvoir accéder aux attributs et fonctionnalités de l'objet cible.
 Le rôle du constructeur est d'initialiser les attributs de l'objet Donc init() représente le
code d’initialisation.
 Syntaxe
def __init__(self, liste_parameters):
# Initialisiation 7
2
Constructeur
Modifions la classe Personne en lui ajoutant un constructeur qui permet de
créer une nouvelle Personne en renseignant son cin ,son prénom, son nom
et année de naissance
 La classe Personne, telle qu'elle est pour le moment, n'est pas encore des plus utiles car
les variables contiennent tout simplement une référence vers l'objet qui a été créé,
c'est-à-dire une indication sur son emplacement en mémoire.
 En effet, il serait souhaitable de pouvoir stocker les informations de la classe Personne
dans l'objet qui a été créé. c'est-à-dire avoir des attributs stockant les informations du
contact cd sont Variable d'instance accessible à l'aide du paramètre self
Constructeur
L'idée est que le constructeur initialise ces variables d'instances, qui seront alors stockées
dans l'objet et en mémoire pour toute la durée de vie de l'objet. On modifie donc le
constructeur de la classe Personne en :
Constructeur
Il est important de faire la différence entre les deux types de variables qui
se trouvent dans le code de ce constructeur :
la variable self.nom représente la variable d'instance, c'est-à-dire celle
associée à l'objet, qui existe à partir de la création de l'objet jusque sa
destruction ;
la variable nom représente le paramètre reçu par le constructeur et
n'existe que dans le corps de ce dernier.
Le paramètre self permet donc d'accéder aux variables d'instance, c'est-
à-dire aux attributs de l'objet cible, depuis le constructeur.
75
Constructeur
Imaginons que tu sois fan de cyclisme et que tu veuilles créer un programme pour
gérer ta dépendance dévorante au short moulant :
La différence entre une variable
d'instance et une variable de classe
histoire
 Dans notre classe Velo, la

variable roues est une variable de classe.
Ce qui est plutôt logique car tous les
vélos ou presque roulent sur deux roues
et pas plus
 De l'autre côté, on a les variables d'instances dont les valeurs diffèrent d'une instance à
une autre.
Dans notre exemple, les variables self.marque, self.prix et self.poids sont des variables
d'instance. elles sont définies à l'intérieur de la méthode __init__.
Constructeur
si je crée deux instances de ma classe Velo et que j'essaie d'accéder à ces
variables :
Attribut de classe
Attribut d ‘ instance
Constructeur
Résume
La méthode constructeur (Constructor):
 Le constructeur (constructor) est une méthode spéciale de classe, elle
est toujours nommé init
 Le premier paramètre du constructeur est toujours self (un mot-clé se réfère à la classe
elle-même).
 Le constructeur est utilisé pour créer un objet.
 Le constructeur attribue des valeurs du paramètre aux propriétés de l'objet qui sera créé.
 Vous ne pouvez définir qu'un plus constructeur en classe.
 Si la classe n'est pas définie par le constructeur, par défaut Python considère qu'il a un
constructeur par défaut init (self), avec le corps vide, il hérite le constructeur de la
classe parente.
78
Constructeur
Affichage d’objet
79
Constructeur
Représentation de l’objet : deux méthodes spéciales permettent de contrôler
comment l’objet est représenté et affiché.
La méthode repr affecte la façon dont est affiché l’objet quand on tape
directement son nom. On la redéfinit quand on souhaite faciliter le debug sur
certains objets.
La méthode str est appelée pour afficher l’objet avec print (sinon repr )
ou pour convertir l’objet en chaîne de caractères.
Destructeur
• Le destructeur est une méthode qui permet la destruction d'un objet non référencé.
• Un destructeurs permet:
• Gérer les erreurs
• .Libérer les ressources utilisées de manière certaine
• Assurer la fermeture de certaines parties du code.
• Les langages qui utilisent des ramasse-miettes (exemple Python) n'offrent pas le mécanisme
des destructeurs puisque le programmeur ne gère pas la mémoire lui-même
• Un ramasse-miettes est programme de gestion automatique de la mémoire. Il est
responsable du recyclage de la mémoire préalablement allouée puis inutilisée.
8
1
Destructeur
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é.
Résumé :
 On définit une classe en suivant la syntaxe
class NomClasse:
 Les méthodes se définissent comme des fonctions, avec le mot clé def, sauf
qu'elles se trouvent dans le corps de la classe.
 On construit une instance de classe grâce à son constructeur, une méthode
appelée __init__.
 Les méthodes prennent en premier paramètre self, l'instance de l'objet
manipulé.
 On définit les attributs d'une instance dans le constructeur de sa classe, en
suivant cette syntaxe : self.nom_attribut = valeur.
 On peut accéder aux attribut d'un objet avec l'opérateur . en suivant cette
syntaxe: valeur = nom_objet.nom_attribut
2- Notion de classe
DÉFINIR UN OBJET 3- Constructeur/Destructeur
4- Objets en interaction
Objets en interaction
• La communication entre les objets est la base de la POO
• Les objets communiquent par envois de messages ceci:

• Quand un objet demande à un autre d’exécuter une méthode
qui est propre à cet autre.
8
5
Objets en interaction
• Supposons que le feu « Feu_de_signalisation_EnQuestion1 » fasse ralentir ou accélérer la voiture « Voiture-Devant »
• Objet Feu_de_signalisation_EnQuestion est l’expéditeur de message
• Objet Voiture-Devant est le destinataire de message
Feu_de_signalisation_EnQuestion1 Change()
0x304021 Couleur=3 Couleur=Couleur+1
If(Couleur==4) Couleur=1
If (couleur==1)……….
Voiture-Devant.ChangeVitesse(50)
Voiture-Devant
ChangeVitesse(int nV)
0x30502 Vitesse=0
Vitesse=nV
Mémoire des méthodes

Mémoire des objets
8
6
Exercice
1. Créer une classe Python nommée CompteBancaire qui représente un
compte bancaire, ayant pour attributs : numeroCompte (type numérique )
, nom (nom du propriétaire du compte du type chaîne), & solde.
2. Créer un constructeur ayant comme paramètres : numeroCompte, nom,
solde.
3. Créer une méthode Versement() qui gère les versements.
4. Créer une méthode Retrait() qui gère les retraits.
5. Créer une méthode Agios() permettant d’appliquer les agios à un
pourcentage de 5 % du solde
6. Créer une méthode afficher() permettant d’afficher les détails sur le
compte
7. Afficher les détails d un compte en utilisant La méthode str
8. Donner le code complet de la classe CompteBancaire.
CHAPITRE 3
1- Principe de l’encapsulation
CONNAITRE 2- Niveaux de visibilité
L’ENCAPSULATION
Encapsulation
Dans un programme contenant la définition d'une classe, on peut distinguer le code se
trouvant à l'intérieur de la classe (donc dans le corps de ses méthodes) et celui qui
se trouve à l'extérieur (instructions ne figurant dans aucune méthode de la classe).
L'encapsulation est une manière de définir une classe de telle sorte que ses attributs
ne puisse pas être directement manipulés depuis l'extérieur, mais seulement
indirectement par l'intermédiaire de ses méthodes.
Un des avantages de cette approche est la possibilité de redéfinir la représentation
interne des attributs, sans que cela affecte la manipulation externe d'un objet de cette
classe.
L'encapsulation facilite donc la mise à jour des applications. On peut en voir l'intéret
dans un projet de développement réalisé par plusieurs développeurs (ce qui est
généralement le cas en entreprise). Chaque développeur est responsable d'une partie
du projet. Si les classes dont il est le responsable sont proprement encapsulées, il
pourra modifier par la suite leurs représentations internes, sans que cela perturbe le
travail des autres développeurs du projet susceptibles d'utiliser ces classes.
90
Principe de l’encapsulation
• L’encapsulation est le fait de réunir à l'intérieur d'une même entité (objet)
le code (méthodes) + données (attributs).
• L’encapsulation consiste à protéger l’information contenue dans un objet.
• Il est donc possible de masquer les informations d'un objet aux autres
objets
Encapsulation
Le concept d'encapsulation est un concept très utile de la POO. Il permet en

particulier d’éviter une modification par erreur des données d’un objet. En effet, il
n’est alors pas possible d’agir directement sur les données d’un objet ; il est
nécessaire de passer par ses méthodes qui jouent le rôle d’interface obligatoire.
92
Principe de l’encapsulation
• L’encapsulation consiste donc à masquer les détails d’implémentation d’un objet, en
définissant une interface.
• L’interface est la vue externe d’un objet, elle définit les services accessibles (Attributs
et méthodes) aux utilisateurs de l’objet. Public
Interface
interface = liste des signatures des méthodes accessibles
Attributs
Privé
Interface = Carte de visite de l’objet
Méthodes
Objet
9
3
Intérêt de l’encapsulation
• Les objets restreignent leur accès qu’aux méthodes de leur classe
Compte Attributs
privés
Numéro de compte;
• Cela permet d’avoir un contrôle sur tous les accès.
solde
Exemple:
Les attributs de la classe compte sont privés retirer() déposer()
Ainsi le solde d’un compte n’est pas accessible Méthodes publique
par un client qu’à travers les méthodes retirer() et déposer() qui sont publiques
→ Un client ne peut modifier son solde qu’ on effectuant une Client

Opération de dépôt ou de retrait
CHAPITRE 3
1- Principe de l’encapsulation
CONNAITRE 2- Niveaux de visibilité
L’ENCAPSULATION
Niveaux de visibilité des membres
• Il existe 2 niveaux de visibilité des membres d’une classe:
• Publique: les fonctions de toutes les classes peuvent accéder aux données ou aux méthodes d'une classe
définie avec le niveau de visibilité publique
 Il s'agit du plus bas niveau de protection des données
• Privé: l'accès aux données est limité aux méthodes de la classe elle-même
 Il s'agit du niveau de protection des données le plus élevé

Niveaux de visibilité des membres
Visibilité des membres d'une classe
 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: la visibilité publique ,privée et protégée.
 membres privés :
• Les attributs privés accessible uniquement depuis intérieur de la classe
(ses méthodes, constructeur, destructeur)
• Les méthodes privées d'une classe ne peuvent être appelées que par les
méthodes de cette classe.
 membres publics :
•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.
Une classe est encapsulée, si tous ses attributs sont privés.
Encapsulation
En Python, un membre est privé si son nom débute et ne se termine pas par deux caractères
soulignés. Dans le cas contraire il est publique.
Exemple:
__solde est un attribut privé, alors que solde est publique.
Le constructeur de toute classe __init__ est publique car il se termine par deux caractères
soulignés.
98
Encapsulation
Exemple de classe encapsulé en python
class CompteBancaire:
def __init__(self, idNumber, nomPrenom,solde):
self.__numcompte = idNumber
self.__nomPrenom = nomPrenom
self.__solde = solde
Il n’est alors plus possible de faire appel aux attributs __numcompte , __nomPrenom
et __solde depuis l’extérieur de la classe CompteBancaire.
l faut donc disposer de méthodes qui vont permettre par exemple de modifier ou d’afficher les
informations associées à ces variables appelées des accesseurs (Getter ) et mutateurs (Setter)
Getter : Une méthode qui permet d' accéder à un attribut dans une classe donnée
Setter : une méthode qui vous permet de définir ou de modifier la valeur d'un attribut dans une
classe
Encapsulation
Principe des 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 accesseurs.
 Les accesseurs sont des méthodes qui permettent de retourner la valeur d’un attribut.
Une convention souvent utilisée en programmation objet est de nommer ces méthodes
par get suivi du nom de l'attribut (getter).
Exemple, la méthode get_nom joue ce rôle. Elle nous permet d'obtenir la valeur de
l'attribut nom. Comme les accesseurs en lecture doivent retourner une valeur (celle de
l'attribut associé) ce sont donc nécessairement des méthodes de type fonction
 Les mutateurs permettent de modifier la valeur d’un attribut. Ce sont des méthodes de
type procédure, prenant en paramètre la nouvelle valeur de l'attribut. On trouve ici
également une convention fréquemment utilisée pour nommer ces méthodes: elles
commencent par set et sont suivies du nom de l'attribut associé (setter).
Exemple, la méthode setnom joue le rôle d'un accesseur en écriture. C'est l'accesseur
en écriture de l'attribut nom
1.Rajoutez des accesseurs permettant
de récupérer la masse d'un objet.
2.Rajoutez des mutateurs permettant de
modifier la masse d'un objet.
Encapsulation
Effectuer un contrôle sur

les valeurs de les attributs
code et note
Par exemple, il serait
possible de n’autoriser
que des valeurs positives
pour les attributs privés
__code
Exercice
• Définir une classe Rectangle ayant les attributs suivants : Longueur et Largeur.
• Définir à l’aide des propriétés les méthodes d’accès aux attributs de la classe.
• Ajouter un constructeur d’initialisation.
• Ajouter les méthodes suivantes :
• Périmètre ( ) : retourne le périmètre du rectangle.
• Aire( ) : retourne l'aire du rectangle.
• EstCarre( ) : vérifie si le rectangle est un carré.
• AfficherRectangle( ) : expose les caractéristiques d’un rectangle comme suit :
Longueur : […] - Largeur : […] - Périmètre : […] - Aire : […] - Il s’agit d’un carré / Il ne s’agit pas
d’un carré]
Exemple d’exécution :
Exercice 3 :
•Définir une classe Livre avec les attributs suivants : Titre, NomAuteur , Prix.
•Définir un constructeur permettant d’initialiser les attributs de la méthode par des valeurs
saisies par l’utilisateur.
•Définir à l’aide des propriétés les méthodes d’accès aux différents attributs de la classe.
•Définir la méthode Afficher ( ) permettant d’afficher les informations du livre en cours.
•Écrire un programme testant la classe Livre.
Exemple d’exécution :
Exercice
Soit la classe Date définie par
le diagramme de classe UML
suivant :
1) Implémenter cette classe en Python.

2) Dans la méthode de construction de la classe, prévoir un dispositif pour éviter les dates
impossibles (du genre 32/14/2020).Dans ce cas, la création doit provoquer une erreur,
3) Les noms des mois seront définis en tant qu’attribut de classe à l’aide d’une liste.
4) Ajouter une méthode _str_ permettant d’afficher la date sous la forme "25 janvier
2022".
5) Ajouter une méthode __comparer__ qui permet de comparer deux dates.
6) L’expression d1 < d2 (d1et d2étant deux objets de type Date) doit grâce à cette
méthode renvoyer True ou False
Encapsulation
@property – un décorateur à utiliser dans vos classes Python
 @property est un décorateur intégré en langage python qui est utilisé pour faire en sorte que des
fonctions telles que les getters et les setters dans une classe se comportent comme des propriétés de
classe.
 Le décorateur python @property permet d’accéder à une méthode en tant qu’attribut plutôt qu’en tant
que méthode ou fonction.
Soit la classe Etudiant, dans laquelle on

a 2 propriétés, à savoir nom, prenom et
nom
Et nous avons aussi une fonction,

email() qui génère une adresse e-mail
en utilisant le prénom et le nom.
Connaître les principaux

109
piliers de la POO
Encapsulation
Définir des méthodes setter et deleter avec @property
La méthode setter définira la valeur de l’attribut et la méthode deleter supprimera l’attribut de la
mémoire.
Dans notre exemple, nous avons créé

un getter, un setter à l’aide du
décorateur @property.
On a utilisé les décorateurs

@nom.setter (nom est le nom de
notre fonction à décorer).
Appréhender le paradigme de Connaître les principaux

La POO en Python 110
la POO piliers de la POO
Encapsulation
La fonction property()
Au lieu d’utiliser un @property, nous pouvons utiliser la fonction property() en python pour créer des
getters, des setters et des deleters.
Elle renvoie l’attribut de propriété à partir du getter, du setter et du deleter donnés.
La syntaxe est : property(fget, fset, fdel, doc)
fget() : obtenir la valeur de l’attribut.

fset() : définir la valeur d’un attribut.
fdel() : supprimer la valeur d’attribut.
doc() : une chaîne contenant la documentation (docstring) de l’attribut.
Il est recommandé d’utiliser le décorateur @property qui facilite la déclaration d’une propriété au lieu
d’appeler la fonction property().
@Property est un décorateur intégré pour la fonction property() en Python. Il est utilisé pour ajouter des
fonctionnalités « spéciales » à certaines méthodes pour les faire agir comme des getters, des setters ou des
deleters lorsque nous définissons des propriétés dans une classe. 111
Les méthodes de classes et statiques en python
 la méthode d’instance
 prend en paramètre self , qui pointe vers l’instance de l’objet qui a appelé la
méthode.
 la méthode d’instance a accès aux états de la classe et de l’instance et elle prend
comme paramètre self ou l’instance
 Les méthodes de classes sont différentes des méthodes d’instances en ce qu’elles

prennent comme premier argument la classe elle-même. De plus, une méthode
de classe est liée à la classe, mais pas à l’objet de cette classe.
 une méthode de classe est une méthode qui a accès uniquement à l’état de la
classe.
 Pour la créer, on utilise le décorateur @classmethod et elle prend comme
paramètre cls
 la méthode statique n’a accès à aucun des deux états, c’est à dire elle ne prend comme
paramètre ni l’instance (self) ni la classe (cls). Elle peut être appelée sans créer d’objet ou
d’instance.
Utilisation des méthodes de classe
 Les méthodes de classe sont souvent utilisées comme constructeurs

alternatifs ou comme méthodes de construction, c’est-à-dire pour créer des
instances basées sur différents cas d’utilisation.
 Pour créer une méthode de classe, il faut la faire précéder d’un «décorateur»
: @classmethod
 Le premier argument de la méthode de classe doit être cls.
 La méthode de classe est appelé sur l'objet Classe lui-même (et donc,
effectivement, n'utilise pas d'objet instancié).
 L'exemple le plus canonique d'une méthode de classe intégrée est dict.fromkeys.
Il est utilisé comme un constructeur alternatif de dict, (bien adapté lorsque vous
savez quelles sont vos clés et que vous voulez une valeur par défaut pour elles.)
dict.fromkeys(['a', 'b', 'c'])

{'c': None, 'b': None, 'a': None}
 Un autre exemple
Soit une classe Etudiant ayant des attributs nom, note et date d‘admission.
Le constructeur prend la date d’admission sous la forme d’une année, d’un mois et
d’un jour. Certains utilisateurs fournissent les informations dans ce format, mais
d’autres donnent la date d’admission sous forme de chaîne de caractère «JJ-MM-
AAAA».
Pour la forme chaîne, nous utiliserons une méthode de classe comme
constructeur alternatif, ce qui permettra à nos utilisateurs d’entrer des informations
comme ils le souhaitent.
Exemple3
Si on veut avoir le nombre d'instances, tout ce qu'on doit faire est comme suivant
Utilisation des méthodes Statiques
 Les méthodes statiques sont utilisées pour créer des fonctions utiles. Ces méthodes ont
une connexion logique avec la classe, mais n’utilisent pas l’état de la classe ou de
l’objet.
 méthodes utiles car elles ne sont généralement pas liées au cycle de vie d’un objet.
 Une méthode statique est une méthode qui ne sait rien de la classe ou de l'instance à
laquelle elle a été appelée. Il obtient juste les arguments qui ont été passés, pas de
premier argument implicite.
 Avec les méthodes statiques , ni self(l'instance d'objet) ni cls(la classe) n'est

implicitement passé comme premier argument. Ils se comportent comme des fonctions
simples, sauf que vous pouvez les appeler à partir d'une instance ou de la classe
Utilisation des méthodes Statiques
 Utilisez une méthode statique lorsque vous souhaitez pouvoir accéder à la méthode sans
instance de la classe.
 Les méthodes statiques n'ont pas besoin d'être invoquées sur l'objet et c'est à ce moment-là
que vous l'utilisez.
Exemple: votre Main () est statique et vous ne créez pas d'objet pour l'appeler.
 Une "méthode statique" sera une fonction rangée dans une boîte "class" (plutôt que dans
une boîte "module"). Comme pour les méthodes de "class" pas besoin d'instancier un objet de
la classe pour pouvoir l'appeler: la différence sera qu'elle ne recevra pas la classe en premier
argument.
L'autre différence est qu'on pourra surcharger une méthode de classe (dans une s/classe)
alors que ce sera plus difficile pour une fonction statique puisqu'il faudra désigner
explicitement sa classe.
 Exemple
On va ajouter une méthode statique qui prend la moyenne d’un étudiant et affiche une
observation. Cette méthode a une connexion logique avec la classe Etudiant, mais n’utilise
pas ses propriétés ou ses méthodes.
Exercice 4 :
Un Article caractérisé par les champs (privée) suivants:
 Numéro
 Description
 prixUnitaire
 AnneeExpiration
1) Créer la classe Article

2) Ajouter les propriétés (Les accesseurs/mutateurs) sachant que :
 Le numéro doit être entre 101 et 999.
 La description doit avoir une taille entre 3 et 25 et ne doit pas commencer par un chiffre.
 Le prix unitaire ne doit pas être négatif.
 L’année d’expiration ne doit pas être inférieure à 2019.
4) Utiliser Le décorateur python @property pour pouvoir accéder aux méthodes en tant qu’attribut
5) Ajouter un constructeur sachant qu’à la création d'un article, on doit renseigner le numéro, la description, le prix Unitaire
ainsi que la date d’expiration.
6) Ajouter la méthode AfficherDetails() : qui affiche les détails de l'article
7) Ajouter la méthode EffectuerReduction(taux): qui permet de baisser le prix de l'article selon le taux donné en paramètres.
8) Ajouter la méthode EstPerime() : qui retourne true si l'article est périmé, false sinon.
9) Tester la classe Article :
 Créer deux articles et tester les méthodes déclarées.
 Créer une liste qui contient 10 articles dont ses attributs sont saisis par l’utilisateur.
PARTIE 2
CONNAÎTRE LES
PRINCIPAUX PILIERS DE
LA POO
CHAPITRE 4
1- Principe et intérêt de l’héritage
DÉFINIR L’HÉRITAGE ET 2- Types de l’héritage
LE POLYMORPHISME
3- Redéfinition des méthodes
4- Principe du polymorphisme
Définition
 L'héritage est un principe propre à la programmation orientée objet.
 Permet de créer une nouvelle classe à partir d'une classe existante.
 Le nom d’héritage provient du fait que la classe dérivée (la classe nouvellement créée) contient les
attributs et les méthodes de sa superclasse (la classe dont elle dérive).
 L'intérêt majeur de l'héritage est de pouvoir définir de nouveaux attributs et de nouvelles méthodes
pour la classe dérivée, qui viennent s'ajouter à ceux et celles héritées.
Exemple :
Supposons que nous avons une classe Personne contenant les informations et fonctionnalités reliées à un individu.
Un étudiant est une personne, mais il possède des informations que certains n’ont pas, comme le domaine d’études ou université
d’attaché
Principe de l’héritage
Exemple:
Considérons la définition des 3 classes Personne, Etudiant et Employé suivantes:
Personne Etudiant Employe

Nom
Nom
CIN Nom
CIN
anneeNaiss CIN
anneeNaiss
age() anneeNaiss
prixHeure
note1, note2
nbreHeure
age()
age()
moyenne()
Salaire()
Problème:
• Duplication du code
• Une modification faite sur un attribut ou méthode doit être refaite sur les autres
classes
1
2
5
Personne
Solution Nom
CIN Super-classe
• Placer dans la classe mère toutes les informations anneeNaiss
age()
communes à toutes les classes.
Héritent de
• Les classes filles ne comportent que les attributs ou
méthodes plus spécifiques. Employe
Etudiant
• Les classes filles héritent automatiquement les
prixHeure
attributs (et les méthodes) qui n'ont pas besoin note1, note2 nbreHeure
moyenne()
d'être ré-écrits.
Salaire()
Sous-classes
L'héritage permet de :
• récupérer le comportement standard d'une classe d'objet (classe parente) à partir de

propriétés et des méthodes définies dans celles-ci,
• ajouter des fonctionnalités supplémentaires en créant de nouvelles propriétés et

méthodes dans la classe dérivée,
• modifier le comportement standard d'une classe d'objet (classe parente) en

surchargeant certaines méthodes de la classe parente dans la classe dérivée.
Intérêt de l’héritage
 L'héritage minimise l'écriture du code en regroupant les caractéristiques communes
entre classes au sein d’une seule (la classe de base) sans duplication.
 Localisation facile, en un point unique, des sections de code.
 La rectification du code se fait dans des endroits uniques grâce à la non redondance de
description
 L’extension ou l’ajout de nouvelles classes est favorisée surtout en cas d’une hiérarchie de
classes bien conçue
 Définition des informations et des comportements aux niveaux opportuns.
 Rapprochement de la modélisation des systèmes d’informations aux cas réels
 Le concept de l'héritage spécifie une relation de spécialisation/généralisation entre les classes
(Document : livre, revu, …/Personne : étudiant, employé…)
 Lorsqu'une classe D hérite d'une classe B :
• D possède toutes les caractéristiques de B et aussi, d'autres caractéristiques qui sont spécifiques à D
• D est une spécialisation de B (un cas particulier)
• B est une généralisation de D (cas général)
• D est appelée classe dérivée (fille)
• B est appelée classe de base (mère ou super-classe)
 Tout objet instancié de D est considéré, aussi, comme un objet de type B
 Un objet instancié de B n'est pas forcément un objet de type D
 Exemple:
Généralisation Spécialisation
Personne
-CIN
- Nom
- Prenom
- Age
Formateur Administrateur Stagiaire

-Matricule - service - CNE
-Echelle - Filiere
-Specialite - Niveau
Python vous permet de créer une classe étendue d'une simple classe ou de
multiple classes. Cette classe est appelée une classe dérivée (Derived class), ou
simplement une sous classe. La sous classe hérite des attributs (attribute), des
méthodes et des autres membres de la classe mère.
CHAPITRE 4
DÉFINIR L’HÉRITAGE ET
LE POLYMORPHISME 2- Types de l’héritage
Héritage simple
• Si aucun attribut n'est trouvé
dans la classe, la recherche
continue vers la classe de mère.
Cela se répète de manière
récursive, si la classe mère est
elle-même dérivée d'autres
classes.
• En Python, nous utilisons la

fonction super() pour appeler
les méthodes de la classe
parent.
Héritage multiple
• L’héritage multiple se produit lorsque la classe enfant
hérite des méthodes et des fonctionnalités de deux ou
plusieurs classes parentes. Il est avantageux de dériver
toutes les données à la fois
• Une classe peut hériter de plusieurs classes
Exemple:
Un Etudiant est à la fois une Personne et un EtreHumain
•La classe Etudiant hérite les attributs et les méthodes des
deux classes→ Il deviennent ses propres attributs et
méthodes
1
3
4
Héritage en cascade Personne
Nom
•Une classe sous-classe peut être elle-même CIN
dateNaiss
une super-classe age()
Etudiant
•Exemple:
note1
Etudiant hérite de Personne note2
Moyenne()
EtudiantDeuxièmeCycle hérite de Etudiant
EtudiantDeuxièmeCycle hérite de Personne Etudiant

DeuxiemeCycle
option
Fonction isinstance()
La fonction isinstance() vérifie si l’objet (premier argument) est une instance ou une sous-
classe de la classe (deuxième argument).
Paramètres:
Syntaxe: La fonction isinstance() prend deux paramètres:
Isinstance (object, type) object – objet à vérifier
type – classe, type ou tuple de classes et de types
Valeur de retour:
La fonction isinstance() renvoie True si l’objet est une instance ou une sous-classe d’une
classe, ou tout élément du tuple, sinon renvoie False.
Exemple
if isinstance (e,EtudiantDeuxiemeCycle):
print("e est un objet de la classe EtudiantDeuxiemeCycle")
Fonction issubclass()
La fonction issubclass() renvoie True si l’objet spécifié est une sous-classe de l’objet spécifié,
sinon renvoie False.
Paramètres:
Syntaxe: La fonction issubclass() prend deux paramètres:
Issubclass (object, type) object – objet à vérifier
type – classe, type ou tuple de classes et de types
Valeur de retour
La fonction issubclass() renvoie True si l’objet est une instance ou une sous-classe d’une
classe, ou tout élément du tuple, sinon renvoie False.
Exemple
if issubclass (EtudiantDeuxiemeCycle,Etudiant):
print("EtudiantDeuxiemeCycle est une sous classe de la classe Etudiant")
CHAPITRE 4
DÉFINIR L’HÉRITAGE 2- Types de l’héritage
ET 3- Redéfinition des méthodes
LE POLYMORPHISME
Redéfinition des méthodes héritées
• Une méthode héritée peut être redéfinie si sa version initiale n'est pas satisfaisante
pour la classe dérivée
• La redéfinition consiste à conserver l'entête de la méthode et à proposer un code

différent
• Si une méthode héritée est redéfinie, c'est uniquement la nouvelle version qui fait
parti de la description de la classe dérivée
• Si la méthode définie au niveau de la classe dérivée est de type différent, ou de

paramètres différents, alors
il s’agit d’une nouvelle méthode qui s’ajoute à celle héritée de la classe de base
Redéfinition des méthodes héritées
Exemple:
Personne
Nom
• Soit la classe Etudiant qui hérite de la classe Personne CIN
age()
• La méthode afficher() de la classe Personne affiche les afficher()
attribut Nom, CIN d’une personne
• La classe Etudiant hérite la méthode afficher() de la

Etudiant
classe Personne et la redéfinit , elle propose un nouveau
note1
code (la classe Etudiant ajoute l’affichage des attributs note2
notes1 et note2 de l’étudiant) Moyenne()
afficher()
Redéfinition des méthodeshéritées : Surcharge
Surcharger un attribut
Surcharger un attribut est très simple, puisqu'il suffit de redéfinir sa valeur

au sein de la classe fille.
class MaClasseFille(MaClasseMere):
def __init__(self):
MaClasseMere.__init__(self)
self.attribut_classe_mere = 'nouvelle valeur'
Redéfinition des méthodeshéritées: Surcharge
Surcharger une méthode
 Tout comme pour les attributs, pour surcharger une fonction, il suffit de la redéfinir.
 On peut toutefois vouloir qu’une méthode d’une classe fille n’ait pas le même
comportement que son équivalent dans la classe mère. On redéfinit alors simplement
la méthode dans la classe fille. On parle de polymorphisme et cette technique relève
de la surcharge de méthode, ou en anglais overriding.
Exemple:
def infos_mag (self):
return super(Vetement, self).infos_mag(), "La specialite {}".format(self.specialite)
Mécanisme de la liaison retardée
• Soit C la classe réelle d'un objet o à qui on envoie un message « o.m() »
• o.m() peut appeler la méthode m() de C ou de n’importe quelle sous-classe de C
• Si le code de la classe C contient la définition (ou la redéfinition) d’une méthode m(),
c’est cette méthode qui sera exécutée
• Sinon, la recherche de la méthode m() se poursuit dans la classe mère de C, puis dans la
classe mère de cette classe mère, et ainsi de suite, jusqu’à trouver la définition d’une
méthode m() qui est alors exécutée
Mécanisme de la liaison retardée
Exemple:
Soit etc1 un objet de type EtudiantTroisièmeCycle
1er cas 2ème cas

Personne Personne
afficher() etc1.afficher() afficher()
Etudiant Etudiant
Afficher() de la
afficher()
classe Personne
est exécutée
Afficher() de la classe
EtudiantTroisièmeCycle est
EtudiantTroisième EtudiantTroisième
exécutée Cycle
Cycle
etc1.afficher() afficher()
CHAPITRE 4
DÉFINIR L’HÉRITAGE ET 1- Principe et intérêt de
LE POLYMORPHISME l’héritage
2- Types de l’héritage
Principe de polymorphisme
“Polymorphisme” signifie littéralement “plusieurs formes”.
Dans le contexte de la programmation orientée objet, le polymorphisme est un
concept qui fait référence à la capacité d’une variable, d’une fonction ou d’un objet
à prendre plusieurs formes, c’est-à-dire à sa capacité de posséder plusieurs
définitions différentes.
Attention
le polymorphisme peut désigner deux choses différentes: le fait de définir des
méthodes différentes pour des classes qui héritent l’une de l’autre (overriding) mais
aussi le fait de définir plusieurs fois la même méthode (ou fonction) avec des
arguments différents (overloading).
Le second cas est plus naturel dans des langages de programmation typé
statiquement (Java, C++, …) et est assez éloigné de la philosophie de Python. Nous
n’en parlerons donc pas ici.
• Le polymorphisme désigne un concept de la théorie des types, selon lequel un nom d'objet peut désigner
des instances de classes différentes issues d'une même arborescence
Exemple: Une instance de Etudiant peut « être vue comme » une instance de Personne (Pas l’inverse!!)
Variables Références Objets
Type Personne p 0x304021

Objet de Type Personne
Type Etudiant e 0x304055
• p = e autorisé car le type de p est plus générique que le type de e Objet de Type Etudiant
• e = p non autorisé car le type de e est plus spécifique que celui de p

• le type de la variable est utilisé par le compilateur pour déterminer si on accède à un membre (attribut ou
méthode) valide
Variables Références Objets
Type A a1 0x304021 A
MethodeA()
Type B b1 0x304055
Type A a2 0x304555 B
b1.MethodeA() OK car b1 est de type déclaré B qui hérite de A MethodeB()
b1.MethodeB() OK car b1 est de type déclaré B a2.MethodeA()

OK car a2 est de type déclaré A
a2.MethodeB()→ ERREUR car a2 est de type A (même si le type l’objet référencé est B)
Exercice 3 :
Partie A
Soit la classe Personne qui a comme attributs : cin, nom , dateNaissance
Travail à réaliser
1) Définir la classe Personne.
2) Ajouter un constructeur paramétré qui initialise tous les attributs de la classe Personne.
3) Ajouter les accesseurs et les mutateurs de chaque attribut.
4) Ajouter une méthode __str()__ qui retourne l’état (valeurs des attributs) d’une instance de la classe
Personne
•Pour tester : Créer deux p1 p2

CIN :BH14501 CIN :FG254170
personnes et afficher leurs Nom :benani.Ahmad Nom :Alaoui Ikram
informations. dateNaissance : 2000 dateNaissance : 1998
5) Soit la classe Stagiaire qui hérite de la classe Personne et qui a comme attribut :
 numéroInscription st1
 Moyenne générale CIN :BH14501
Nom :benani.Ahmad
1) Définir la classe Stagiaire. dateNaissance : 2000
numéroInscription : NTIC85
2) Ajouter un constructeur qui initialise tous les attributs de la classe Stagiaire. Moyenne générale : 15,86
3) Redéfinir la méthode __str()__ pour retourner l’état d’un stagiaire.
Exercice 3 (suite)
Partie B
On dérive la classe Personne déjà développée par une classe formateur.
En plus des données membres individu, la classe Formateur a comme données membres privés :
•Masse horaire effective (MH) .
•Heure supplémentaire (HS) .
•Taux horaire effectif (THE) .
•Taux horaire supplémentaire (THS)
1. Ecrire un constructeur paramétré et redéfinir la méthode affichage.
2. La méthode calculSalaire() intègre un mode de calcul comme suit :
calculSalaire = (Masse horaire effective* Taux horaire effectif)+( Heure supplémentaire* Taux horaire supplémentaire)
3. Dans le test :
•Prévoir deux formateurs et les instancier avec les constructeurs adéquats
•Les afficher et calculer leurs salaires.
Exercice 3 (suite)
Partie C
On souhaite enregistrer des objets personnes dans une liste de type personne:
1. Créer une classe Etablissement avec une liste de type personne qui contient des objets personne
2. Ecrire des procédures de mise à jour de cette liste :
Ajout
Modification
Suppression
Recherche
Affichage de tous les stagiaires et tous les formateurs
3. Dans le test, créer le menu suivant :
------------Menu---------
1. Ajouter
2. Modifier
3. Supprimer
4. Rechercher
5. Afficher
6. Quitter
------------------------
Exercice 4 :Héritage multiple
a) Créer la classe objet comprenant :
– les données membres : montant (float), type (chaîne de caractères)
– un constructeur initialisant les données membres
– une fonction affiche qui affiche les informations sur l’objet assure
b) Créer une classe ordinateur dérivant de la classe objet comprenant :
– les données membres : ram (int), hd(int)
– une fonction affiche qui affiche les informations sur l’ordinateur et qui appelle la fonction affiche de la
classe objet assure
c) Créer une classe bagage dérivant de la classe objet comprenant :
– les données membres : type (chaîne de caractères), poids (float)
– une fonction affiche affichant les informations sur le bagage et appelant la fonction affiche de la classe
objet assure.
d) Créer une classe ordinateur portable dérivant des classes ordinateur et bagage et comprenant :
– les données membres poids (float) et epaisseur (float)
– une fonction affiche qui affiche les informations sur l’ordinateur portable et qui appelle les fonctions
affiche des classes bagage et ordinateur
e) Créer un programme qui crée un objet ordinateur portable et qui affiche les informations sur cet objet
CHAPITRE 5
1- Les exceptions
Les exceptions
 Les exceptions sont les opérations qu’effectue un interpréteur ou un
compilateur lorsqu’une erreur est détectée au cours de l’exécution d’un
programme. En règle générale, l’exécution du programme est
interrompue, et un message d’erreur plus ou moins explicite est affiche.
 Une exception est un objet qui contient des informations sur le contexte
de l’erreur. Lorsqu’une exception survient et qu’elle n’est pas traitée alors
elle produit une interruption du programme et elle affiche sur la sortie
standard un message .
 Il existe un très grand nombre d’exceptions organisées de façon
structurée et hiérarchique
Les exceptions
 Python n’étant pas un langage compilé, les erreurs dans la rédaction du
code ne sont détectées que pendant la phase d’exécution et
déclenchent des exceptions
 La plupart des exceptions toutefois ne sont pas prises en charge par les
programmes, ce qui génère des messages d’erreurs comme celui-ci :
 Le message d’erreur proprement dit

comporte deux parties séparées par un
double point :
 le type d’erreur
 une information spécifique de
cette erreur
La gestion des exceptions
 Dans les langages de niveau élevé comme Python, il est également

possible d’associer un mécanisme de surveillance à tout un ensemble
d’instructions, et donc de simplifier le traitement des erreurs qui
peuvent se produire dans n’importe laquelle de ces instructions.
 Un mécanisme de ce type s’appelle en général mécanisme de traitement

des exceptions. Celui de Python utilise l’ensemble d’instructions :
try - except – else-- finally, qui permettent d’intercepter une erreur
et d’exécuter une portion de script spécifique de cette erreur.
Exemple
lorsqu’une exception survient
dans un bloc try, elle interrompt
immédiatement l’exécution du
bloc et l’interpréteur recherche
un bloc except pouvant traiter
l’exception.
Try signifie "essayer" en anglais,
ce mot clé permet d'essayer une action et si
l'action échoue on peut lui donner d'autres
instructions dans un bloc except
La clause else après les blocs try except:
Le bloc else est exécuté uniquement si le
bloc try se termine normalement, c’est-à-dire
sans qu’une exception ne survienne
Finally
On utilise le mot clé finally pour exécuter des
instructions quelque soit les erreurs générées
ou non (et même si il y a présence d'un return ).
Dans tous les cas les instructions placées dans
finally seront exécutées.
Exemple
Post-traitement
Dans certain cas, on souhaite réaliser un traitement après le bloc try que ce dernier se
termine correctement ou bien qu’une exception soit survenue.
Dans ce cas, on place le code dans un bloc finally.
try:
numerateur = int(input("Entrez un numérateur : "))
denominateur = int(input("Entrez un dénominateur : "))
resultat = numerateur / denominateur
print("Le resultat de la division est", resultat)
except (ValueError, ZeroDivisionError):
print("Désolé, quelque chose ne s'est pas bien passé.") Un bloc finally est systématique
finally: appelé même si le bloc try est
interrompu par une instruction
print("afficher ceci quel que soit le résultat") return
 Parmi les exceptions standard les plus fréquentes:
IndexError, ImportError, IOError, ZeroDivisionError, TypeError.
 Il y a deux sortes d'erreurs:

•Erreur de syntaxe : Également appelée erreur d’analyse, la plus élémentaire.
Apparaît lorsque l'analyseur Python est incapable de comprendre une ligne de
code.
•Exception: erreurs détectées lors de l'exécution. par exemple - ZeroDivisionError.
Liste des erreurs d'exceptions:

IOError: si le fichier ne peut pas être ouvert
KeyboardInterrupt: lorsqu'une touche non requise est enfoncée par l'utilisateur
ValueError: lorsque la fonction intégrée reçoit un argument incorrect
EOFError: si End-Of-File est touché sans lire aucune donnée
ImportError: s'il est impossible de trouver le module
MemoryError : Cette erreur est générée lorsqu'une opération manque de mémoire.
Il est possible d’ajouter plusieurs blocs except à la suite d’un bloc try.
Chacun d’entre-eux permet de coder un traitement particulier pour chaque
type d’erreur :
Récupérer le message d’une exception
Les exceptions possèdent une

représentation sous forme de
chaîne de caractères pour
fournir un message.
Pour avoir accès à l’exception,
on utilise la syntaxe suivante :
Lever une exception

 Il est possible de signaler une exception grâce au mot-clé raise.
 L'instruction raise permet au programmeur de forcer une exception spécifique à se
produire. Le seul argument soulevé indique l'exception à déclencher. Il doit s'agir d'une
instance d'exception ou d'une classe d'exception (une classe dérivée de Exception).
 Pour la plupart des exceptions, il est possible de passer en paramètre un message pour
décrire le cas exceptionnel :
x = int(input("enter la valeur de x"))

if x < 0:
raise ValueError("La valeur ne doit pas être négative")
else:
print(82/x)
Création d'exceptions personnalisées
Il arrive d’avoir besoin de générer un type d’erreur personnalisé qui ne figure pas parmi
les différentes classes d’exception du langage Python.
Par exemple, le fait de saisir une note d’examen non valide ∈/[0 ;20] par exemple
Exceptions définies par l’utilisateur

 Les programmes peuvent nommer leurs propres exceptions en créant une nouvelle
classe d’exception
 Les exceptions sont typiquement dérivées de la classe Exception, directement ou non.
 Les classes d’exceptions peuvent être définies pour faire tout ce qu’une autre classe
peut faire. Elles sont le plus souvent gardées assez simples, n’offrant que les attributs
permettant aux gestionnaires de ces exceptions d’extraire les informations relatives à
l’erreur qui s’est produite.
Création d’une exception
TP: Exceptions
Le parking de voitures :
Nous disposons d’un parking permettant de garer des voitures.
Les voitures seront stationnées sur des places numérotées en partant de 0.
Le nombre de places est fixé une fois pour toutes à la construction du parking.
La classe Voiture
1) Créez une classe Voiture caractérisée par les attributs : nom du propriétaire, immatriculation, marque, et le type.
2) Créer les méthodes d’accès à ces attributs et redéfinir la méthode __str()__.
La classe parking
1) Ecrire la classe Parking qui va contenir une de voitures et le constructeur qui prend en paramètre le nombre de
places limite.
2) Ecrire une méthode garer qui prend en paramètres immatriculation d’une voiture et un numéro de place, et qui
gare la voiture à la place donnée si elle est libre, et lève une exception avec le message « Place Non Libre » si la
place est occupée.
3) Ecrire une méthode sortir qui prend en paramètre un numéro de place et qui retire du garage la voiture à cette
place. La méthode retourne l’objet voiture récupéré. Elle lève une exception avec le message « Place Libre » si la
place est vide.
4) Ecrire une méthode __str()__ affichant l’état du parking : pour chaque place, le numéro, ainsi que les
caractéristiques de la voiture qui l’occupe si elle existe.
5) Tester la classe parking
CHAPITRE 6
1- Classes et méthodes abstraites
CARACTÉRISER
L’ABSTRACTION 2- Interface
Classes et méthodes abstraites
 En programmation orientée objet (POO), une classe abstraite est une classe si et
seulement si elle n'est pas instanciable. Elle sert de base à d'autres classes dérivées
(héritées).
 Les classes abstraites sont comme des classes standard, avec la particularité qu’on ne
pourra pas créer d’instance de ces classes.
 Une classe abstraite est une classe qui contient une ou plusieurs méthodes abstraites. Elle
peut malgré tout contenir d'autres méthodes habituelles (appelées parfois méthodes
concrètes).
 Une méthode abstraite est une méthode qui ne contient pas de corps. Elle possède
simplement une signature de définition (pas de bloc d'instructions)
 Toutefois, une classe abstraite nécessite des sous-classes qui fournissent des
implémentations pour les méthodes abstraites.
1
7
2
 Une classe possédant une ou plusieurs méthodes abstraites devient obligatoirement
une classe abstraite.
 Une classe abstraite peut ne pas comporter de méthodes abstraites
 Les classes abstraites doivent être spécifiées.
 Les classes qui spécifient les classes abstraites pourront elles être instanciées.
 Lors de la spécialisation, la classe dérivée aura toutes les méthodes de la classe
mère (la classe abstraite). Ce mécanisme est utile pour généraliser un objet.
 L’abstraction est très utile lors de la conception de systèmes complexes pour
limiter la répétition et assurer la cohérence. C’est similaire à une interface
dans d’autres langages.
1
7
4
le module abc
Le module abc de Python fournit les fonctionnalités pour définir et utiliser des
classes abstraites.
le module abc donne accès à la classe ABC (Abstract Base Class: classes de bases
abstraites qui permet par héritage de construire une classe abstraite, et au décorateur
@abstractmethod pour définir des méthodes abstraites.
par exemple :
from abc import ABC
class maclasseABC(ABC):
pass
1
7
5
Exemple:
Forme Classe abstraite
• Sachant que toutes les formes possèdent les
X, Y
propriétés périmètre et surface, il est judicieux Déplacer()
de placer les méthodes définissant ces propriétés Surface()
Méthodes abstraite
Périmètre()
(périmètre()et surface()) dans la classe qui est à
la racine de l'arborescence (Forme)
• La classe Forme ne peut cependant pas Cercle Rectangle

implémenter ces deux méthodes car on ne peut Surface() Surface()
Périmètre() Périmètre()
pas calculer le périmètre et la surface sans
Classes concrètes
connaître le détail de la forme
• On pourrait naturellement implémenter ces
Forme
méthodes dans chacune des sous-classes de Forme Classe abstraite
X, Y
mais il n'y a aucune garantie que toutes les sous- Déplacer()
classes les possèdent Surface()
Méthodes abstraites
• Solution: Déclaration dans la classe Forme deux Périmètre()
méthodes abstraites périmètre()et surface()ce qui
rend la classe
Cercle Rectangle
Forme elle-même abstraite et impose aux
Surface() Surface()
créateurs de sous-classes de les implémenter Périmètre() Périmètre()
Classes concrètes
Exemples
Les règles suivantes s'appliquent aux classes abstraites:
• Une classe abstraite ne peut pas être instanciée
• Une sous-classe d'une classe abstraite ne peut être instanciée que si elle redéfinit
chaque méthode abstraite de sa classe parente et qu'elle fournit une
implémentation(un corps) pour chacune des méthodes abstraites.
• Si une sous-classe d'une classe abstraite n'implémente pas toutes les méthodes
abstraites dont elle hérite, cette sous-classe est elle-même abstraite (et ne peut donc
pas être instanciée)
TP1 : Classe abstraite
Une société vend des Articles de papeterie. Un Article a une marque et un prix unitaire.
Cette société vend :
1. des Stylos (qui sont des Articles) décrits par une couleur.
2. des Ramettes (qui sont aussi des Articles) décrits un grammage et une couleur (e.g. 80/m2).
Un Article a une méthode permettant de calculer une référence. Cette référence, de type String,
dépend du type de l'article : par exemple, pour un Stylo, la référence sera : "marque:stylo:couleur".
Identiquement, pour une Ramette, ce sera : "marque:ramette:grammage:couleur".
Écrire les classes Article, Stylo et Ramette suivant ces spécifications :
Article est une classe abstraite.
La (seule) méthode abstraite de cette classe est celle du calcul de référence :
 Un Article se construit avec une marque et un prix unitaire.
 Un Stylo se construit avec une marque, une couleur et un prix unitaire.
 Une Ramette se construit avec une marque, un grammage, une couleur et un prix unitaire.
 Pensez aux accesseurs.
 Pensez au __str__().
TP2 : Classe abstraite
Soit la classe abstraite Employé caractérisée par attributs suivants : Matricule, Nom, Prénom, Date de naissance
La classe Employé doit disposer des méthodes suivantes :
 un constructeur d’initialisation des propriétés pour les différents attributs
 la méthode __str()__
 une méthode abstraite GetSalaire.
Un ouvrier est un employé qui se caractérise par sa date d’entrée à la société.
Tous les ouvriers ont une valeur commune appelée SMIG=2500 DH
L’ouvrier a un salaire mensuel qui est : Salaire = SMIG + (Ancienneté en année)*100.
De plus, le salaire ne doit pas dépasser SMIG*2.
Un cadre est un employé qui se caractérise par un indice.
Le cadre a un salaire qui dépend de son indice :
1 : salaire mensuel 13000 DH
Un patron est un employé qui se caractérise par un chiffre d’affaire et un pourcentage.
Le chiffre d’affaire est commun entre les patrons.
Le patron a un salaire annuel qui est égal à x% du chiffre d'affaire : Salaire = CA*pourcentage/100
1) Créer la classe abstraite Employé.
2) Créer la classe Ouvrier, la classe Cadre et la classe Patron qui héritent de la classe Employé, et prévoir les Constructeurs
et la méthode str() de chacune des 3 classes.
3) Implémenter la méthode GetSalaire() qui permet de calculer le salaire pour chacune des classes.
CHAPITRE 3
CARACTÉRISER
L’ABSTRACTION 1- Classes et méthodes abstraites
2- Interface
Utilité des classes abstraites
• les classes abstraites permettent de définir des fonctionnalités(des comportements)
que les sous-classes devront impérativement implémenter
• Les utilisateurs des sous-classes d'une classe abstraite sont donc assurés de trouver
toutes les méthodes définies dans la classe abstraite dans chacune des sous-classes
concrètes
• Les classes abstraites constituent donc une sorte de contrat (spécification

contraignante) qui garantit que certaines méthodes seront disponibles dans les sous-
classes et qui oblige les programmeurs à les implémenter dans toutes les sous-classes
concrètes.
Principe d’interface
• Comme une classe et une classe abstraite, une interface permet de définir un nouveau
type (référence).
• Une interface est une forme particulière de classe où toutes les méthodes sont
abstraites
• Lorsqu'une classe implémente une interface, elle indique ainsi qu'elle s'engage à
fournir une implémentation (c'est-à-dire un corps) pour chacune des méthodes
abstraites de cette interface.
• Si une classe implémente plus d'une interface, elle doit implémenter toutes les
méthodes abstraites de chacune des interfaces.
Exemple1: Si l'on souhaite caractériser la fonctionnalité de comparaison qui est commune à
tous les objets qui ont une relation d'ordre (plus petit, égal, plus grand), on peut définir
l'interface Comparable.
• Les classes Personne et Outils qui implémentent l'interface Comparable doivent

présenter une implémentation de la méthode CompareTo() sinon elles seront abstraites
Interface
Comparable
CompareTo()
Comparaison implémente implémente
des personnes Comparaison des
selon l'âge Outils selon la
Personne Outils longueur
CompareTo() CompareTo()
1
8
5
interface
imprimable
Exemple2: Imprimer()
Supposons que nous voulions que les classes dérivées de la classe

Forme disposent toutes d'une méthode imprimer() permettant implémente
d'imprimer les formes géométriques.
Forme
Classe abstraite
Solution 1: Ajouter une méthode abstraite Imprimer()à la classe X, Y
Forme et ainsi chacune des sous-classes concrètes devrait Déplacer()
implémenter cette méthode Surface()
Méthodes abstraites
Si d'autres classes (qui n'héritent pas de Forme souhaitaient Périmètre()
également disposer des fonctions d'impression, elles devraient à

nouveau déclarer des méthodes abstraites d'impression dans leur
arborescence.
Cercle Rectangle
Solution 2: la classe forme implémente l’interface Surface() Surface()
Périmètre() Périmètre()
imprimable ayant la méthode Imprimer() Imprimer() Imprimer()
Classes concrètes
Solution 2
from abc import abstractmethod
class Comparable:
@abstractmethod
def CompareTo():
pass
# les classes qui implémentent l'interface :

class Personne(Comparable):
def __init__(self,nom,age):
self.__nom=nom
self.__age=age
def CompareTo(self,p):
if self.__age==p.__age:
return True
else:
return False
class Outils(Comparable):
def __init__(self, long, prix):
self.__longueur=long
self.__prix=prix
def CompareTo(self,o):
if self.__longueur==o.__longueur:
return True
else:
return False
#objets
p1=Personne("Ali",5)
p2=Personne("fati",20)
o1=Outils(60,450)
o2=Outils(60,450)
if (p1.CompareTo(p2)):
print("ont le meme age")
else:
print("ces personnes ont des ages différents")
if (o1.CompareTo(o2)):
print("ces objets sont egaux, ils ont meme longueur")
else:
print("longueurs différents")
TP: Les interfaces
On considère les informations suivantes : Un véhicule est identifié par :
• Numéro d’immatriculation
• date de mise en marche
• marque
• modèle
Un élève est identifié par ce qui suit :
• Numéro
• Son Nom
• Sa date de naissance
• Son niveau
• Sa branche
• véhicule
Un enseignant du centre est identifié par ce qui suit :
• Un matricule
• Son Nom
• Date de naissance
• Date d’embauche
• Salaire
• véhicule
Un parrain est enseignant qui encadre un ensemble des élèves avec une prime d’encadrement 70DH par élève
1. Créer les classes véhicule, élève, enseignant et Parrain (attributs, accesseurs, constructeurs, str())
2. Réaliser l’interface IAnnée qui comporte la méthode :
 Int CalculerAnnee(DateTime dateEntre) : cette méthode prend en paramètre la date de début à partir de laquelle le nombre d’année sera calculé
3. Réaliser l’interface ICalcul qui comporte la méthode :
 Double CalculSalaireTotal() : cette méthode donnera en retour le salaire total
4. Implémenter ces méthodes dans les classes correspondantes.
5. Définir pour les classes la méthode CompareTo de l'interface IComparable
6. Tester tous les classes

Langue

m103 Poo Complet

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

m103 Poo Complet

Transféré par

Droits d'auteur :

Formats disponibles

DÉVELOPPEMENT DIGITAL

Durée : 110 heures

PARTIE 1 PARTIE 2 PARTIE 3

Chapitre 1 : Définir l’héritage et le

Programmes = Procédures/Fonctions + Données

• Les données constituent la partie passive du programme.

• Les procédures et les fonctions constituent la partie active.

Programmer dans ce cas revenait à:

• définir un certain nombre de variables (entier, chaine de caractères, structures,

• écrire des procédures pour les manipuler.

 Séparation des données et des opérations

Programmation orientée objet (POO)

 Une même structure contient les données et les opérations associées

 Origine : langage Simula 67 en 1967

Programmation orientée objet

programmation orientée objet :

programmation procédurale programmation orientée objet

• Pourquoi privilégier les procédures sur les données ?

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

• Un programme est constitué d’un ensemble d’objets chacun

Que doit faire le

Sur quoi doit-il le

De quoi doit être

Programmation procédurale Programme de Gestion des

Programmation Orientée Objet

• La POO favoriser la réutilisation de composants logiciels et même

• La définition d’une relation d’héritage entre les entités logicielle évite la

• Facilité de la maintenance logicielle et amélioration de la productivité

• Les premiers langages de programmation véritablement orientés objet ont

 Un objet est capable de sauvegarder un état c'est-à-dire un ensemble d’information

0x304009 Objet 1 Mémoire

Mémoire des objets

Mémoire des objets

• Le cycle de vie d’un objet se limite à une succession de changements d’états

• Soit l’objet Feu_de_signalisation_EnQuestion avec sa couleur et ses trois valeurs

Mémoire des objets

Mais qui est la cause des changements d’états ?

Mémoire des objets Mémoire des méthodes

Définition d’une application orientée objet

Définition d’un ensemble d’objets coopérants -

 La notion de classe est à la base de la programmation orientée objet. Elle

Une classe unit les méthodes aux attributs

CLASSE= Attributs + Méthodes

Une classe est un modèle de définition pour les objets

• même structure (même ensemble d’attributs)

• même comportement (mêmes méthodes)

Python est un langage de programmation orienté objet. Presque

• Une classe permet d’instancier (créer) plusieurs objets

• Chaque objet est une instance (un exemplaire)

Vocabulaire : on dit qu'un objet est une instance d'une classe.

Exemple: Soit la classe Feu_De_Signalisation

Mémoire des objets

La classe est une espèce de moule , à partir de ce moule nous

Puis créer différentes instances de cette classe (Peugeot407, Renault Espace,…).

-d’assigner une valeur à cet attribut en dehors de la classe

À l'intérieur d'une classe, on ne

On crée l’instance e de la classe Etudiant , puis on exécute la méthode

Il s'agit en fait d'une référence vers l'instance en cours

La méthode rouler dans la classe Velo a comme premier paramètre self :

def rouler (self):

self n'a pas besoin d'être utilisé lors de l'appel d'une

À l’extérieur ou à l’intérieur d’une classe, un attribut de classe peut se retrouver

• Membre de classe • Membre d'instance

La méthode del () est une méthode appelée destructeur en Python. Il est