Vous êtes sur la page 1sur 6

Université Centrale PolyTech A.

U : 2020/2021

La Programmation Orientée Objet en Python


1. Introduction
La programmation orientée objet (POO) permet de créer des entités (objets) que l'on
peut manipuler. La programmation orientée objet impose des structures solides et
claires. Les objets peuvent interagir entre eux, cela facilite grandement la
compréhension du code et sa maintenance. On oppose souvent la programmation objet
à la programmation procédurale, la première étant plus "professionnelle" que l'autre
car plus fiable et plus propre.
La programmation orientée objet est le paradigme qui nous permet de définir nos
propres types d’objets (classes), avec leurs propriétés (attributs) et opérations
(méthodes et méthodes spéciales). Ce paradigme vient avec de nombreux concepts qui
seront explicités le long de ce cours.
La POO permet de mieux modéliser la réalité en concevant des modèles d'objets-
classes. Ces classes permettent de construire des objets interactifs entre eux et avec le
monde extérieur. Les objets sont créés indépendamment les uns des autres, grâce à
l'encapsulation, mécanisme qui permet d'embarquer leurs propriétés. Les classes
permettent d'éviter au maximum l'emploi des variables globales. Enfin les classes
offrent un moyen économique et puissant de construire de nouveaux objets à partir
d'objets préexistants.
2. Classes
Une classe est équivalente à un nouveau type de données. Une classe regroupe des
fonctions et des attributs qui définissent un objet. On appelle par ailleurs les fonctions
d'une classe des " méthodes ". On connaît déjà par exemple les classes list ou str
et les nombreuses méthodes permettant de les manipuler sort ou upper.

L'instruction class permet d'introduire la définition d'une nouvelle classe (c'est-à-


dire d'un nouveau type de données). class est une instruction composée. Elle
comprend un en-tête (avec docstring) + corps indenté.
Syntaxe :

class Nom_Classe :

" " " Documentation de la classe " " "


Corps de la classe
Exemple :
>>> class Etudiant:

" " " une classe permettant de manipuler des objets représentants les étudiants
d'un institut préparatoire " " "

2ème Année MP/PC Page 1


Université Centrale PolyTech A.U : 2020/2021

3. Objets et attributs
Un objet est une instance d'une classe. Un objet ou une instance est un exemplaire
particulier d'une classe. On peut instancier autant d'objets que l'on désire avec une
classe.
Exemple :
>>> L1=list()
>>> L2=list((3,4,5))
>>> Casse=str('programmation')
>>> L1
[]
>>> L2
[3, 4, 5]
>>> Casse
'programmation'

Instancions maintenant un étudiant :


>>> Etu=Etudiant()
>>> Etu
<__main__.Etudiant instance at 0x022B34B8>

Concrètement, un objet est constitué de 3 caractéristiques :


 Un type, qui identifie le rôle de l’objet (int, str et list sont des exemples
de types d’objets) ;
 Des attributs, qui sont les propriétés de l’objet ;
 Des méthodes, les opérations qui s’appliquent sur l’objet.
Par exemple un objet de la classe complex possède deux attributs : imag et real ;
plusieurs méthodes, comme conjugate(), abs()…
Pour notre classe Etudiant on peut distinguer les propriétés suivantes : numéro
d’inscription, nom, prénom et moyenne d’où les attributs Num, Nom, Prenom et Moy.
4. La notion de constructeur ou l’initialisateur
Si lors de l’instanciation d’un objet nous voulons qu’un certain nombre d’actions soit
réalisées (par exemple une initialisation), nous pouvons utiliser un constructeur. Un
constructeur n’est rien d’autre qu’une méthode, sans valeur de retour, qui porte un
nom imposé par le langage Python : __init__(). Ce nom est constitué de init
entouré avant et après par __ (deux fois le symbole underscore _, qui est le tiret sur la
touche 8). Cette méthode est appelée automatiquement lors de la création de l’objet.

2ème Année MP/PC Page 2


Université Centrale PolyTech A.U : 2020/2021

Le constructeur peut disposer d’un nombre quelconque de paramètres, éventuellement


aucun.
Exemple sans paramètres :
>>> class Etudiant:
def __init__(self):
self.Num=0
self.Nom=""
self.Prenom=""
self.Moy=0.0

Exemple avec paramètres et valeurs par défaut (optionnelles) :


>>> class Etudiant:
def __init__(self,a=0,b="",c="",d=0.0):
self.Num=a
self.Nom=b
self.Prenom=c
self.Moy=d

5. Méthodes de classes
Les méthodes sont des fonctions définies dans une classe. Une méthode s'écrit comme
une fonction du corps de la classe avec un premier paramètre self obligatoire, où
self représente l'objet sur lequel la méthode sera appliquée. Autrement dit self est
la référence d'instance.
Exemple :
Ajouter dans la classe les méthodes :
- Affiche : permettant d’afficher les informations relatives d’un étudiant donné ;
- Resultat : à résultat booléen qui retourne True si la moyenne de l’étudiant est
supérieur ou égale à 10 et False sinon ;
- Mention : permettant d’afficher la mention d’un étudiant donné sachant que la
mention est "Passable" si la moyenne est entre 10 et 12, "Assez bien" si la
moyenne entre 12 et 14, "Bien" si la moyenne entre 14 et 16 et "Très bien" si la
moyenne supérieure à 16.
6. Les méthodes spéciales
Beaucoup de classes offrent des caractéristiques supplémentaires comme la
concaténation des chaînes, listes, tuples en utilisant simplement l'opérateur +. Ceci est
obtenu grâce aux méthodes spéciales.

2ème Année MP/PC Page 3


Université Centrale PolyTech A.U : 2020/2021

Par exemple l'opérateur + est utilisable, car la classe a redéfini la méthode spéciale
__add__(). Ces méthodes portent des noms prédéfinis, précédés et suivis de deux
caractères de soulignement.
Elles servent à :
- Définir la représentation et l’affichage de l’objet ;
- Surcharger si possible les opérateurs arithmétiques (+, –, *, /, **,…), les
opérateurs de comparaison (==, !=) et autres (in, abs, del, len…)
Application
On propose de construire la classe Duree capable de contenir des durées et de les
manipuler. Ces durées sont définies sous la forme d’un nombre d’heures hh, un
nombre de minutes mm et un nombre de secondes ss.
Exemple :
>>> d=Duree(20,33,41)
1. Construire la classe Duree ;
2. Définir la méthode __repr__ permettant de représenter une durée comme suit :
Heure : hh Minutes : mm Secondes : ss
3. Ajouter les méthodes __add__ et __eq__ permettant respectivement d’additionner
et de comparer deux durées.

EXERCICE
On se propose de construire la classe Intervalle permettant de modéliser et manipuler des
intervalles fermés de réels strictement positifs.
Les attributs sont binf et bsup qui représentent respectivement la borne inférieure et la borne
supérieure.
1. Construire la classe Intervalle et définir le constructeur.
2. Ajouter la méthode __str__ permettant d’afficher l’intervalle en respectant le
format suivant : [binf..bsuf]
3. Définir la méthode __contains__ qui retourne True si un réel x donné appartient
à l’intervalle et False sinon.
4. Définir la méthode __add__ qui retourne l’intervalle somme de deux intervalles.
5. Définir la méthode __mul__ qui retourne l’intervalle produit de deux intervalles.
6. Définir la méthode Inverse qui retourne l’intervalle inverse d’un intervalle.
7. Définir la méthode __div__ qui retourne l’intervalle quotient de deux intervalles.
Soient deux résistances R1  1200   0.1% et R2  1800   0.1% placées en séries.
Ecrire le script python permettant d’exprimez les résistances R1 et R2 sous formes
d’objets de la classe Intervalle puis calculez et afficher l’intervalle de la résistance
1 R1 R 2
donnée par la formule puis avec la formule .
1

1 R 1  R 2
R1 R 2

2ème Année MP/PC Page 4


Université Centrale PolyTech A.U : 2020/2021

7. Héritage et polymorphisme en POO


L’héritage et le polymorphisme forment avec le principe d’encapsulation les trois
piliers de la programmation orientée objet. Dans cette partie, nous allons présenter et
étudier ces concepts en détail et comprendre pourquoi et comment les implémenter
dans notre code.
 Présentation du concept d’héritage
En programmation orientée objet, “hériter” signifie “avoir également accès à”.
Lorsqu’on dit qu’un objet “hérite” des méthodes de la classe qui l’a défini, cela
signifie que l’objet peut utiliser ces méthodes; qu’il y a accès.
La notion d’héritage va être particulièrement intéressante lorsqu’on va l’implémenter
entre deux classes. En Python, nous allons en effet pouvoir créer des “sous-classes” ou
des classes “enfants” à partir de classes de base ou classes “parentes”.
La syntaxe pour définir une sous-classe à partir d’une classe de base est la suivante :
class A :

Corps de la classe A

class B(A) :

Corps de la classe B (classe enfant) qui hérite de la classe A (classe parente)


Ce principe d’héritage va nous permettre de créer des classes de base qui vont définir
des fonctionnalités communes à plusieurs classes puis des sous-classes qui vont hériter
de ces fonctionnalités et pouvoir également définir leurs propres fonctionnalités.
Cela permet d’obtenir un code plus modulable, mieux organisé, plus clair et plus
concis qui sont des objectifs majeurs pour tout bon développeur.
Exemple :
a. Construire une classe Rectangle qui définit les objets géométriques rectangles
caractérisés par L et l représentants respectivement la longueur et la largeur,
ajouter les méthodes Surface, Perimetre et __str__ permettant respectivement le
calcul de la surface, le calcul du périmètre et l’affichage du format suivant
Rectangle(L,l).
b. Construire une classe Carre qui définit les objets géométriques carrés caractérisés
par c représentant le coté et qui hérite de la classe Rectangle.
c. Redéfinir la méthode __str__ dans la classe Carre afin d’avoir l’affichage suivant
Carré(c,c).
 Le 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.

2ème Année MP/PC Page 5


Université Centrale PolyTech A.U : 2020/2021

Exemple :
a. Construire une classe Cercle qui manipule les objets cercles de tailles variées. En
plus du constructeur (qui initialise l’attribut rayon), définir une méthode Surface
qui retourne la surface du cercle.
b. Construire une classe Cylindre qui hérite de la classe cercle. Le constructeur de
cette classe initialisera les deux attributs rayon (hérité de la classe Cercle) et
hauteur, définir dans cette classe la méthode Volume qui en exploitant la méthode
Surface héritée de la classe cercle retourne le volume du cylindre. On rappelle
que : volume cylindre  surface de section  hauteur
c. Construire une classe Cone qui hérite de la classe cylindre et dont le constructeur
initialisera les deux attributs rayon et hauteur (hérités de la classe Cylindre),
cette classe possédera sa propre méthode Volume qui en exploitant la méthode
Volume de la classe Cylindre retourne le volume du cône. On rappelle que :
volume cylindre
volume cône 
3
 L’encapsulation
Python n’implémente pas directement les concepts de visibilité des membres de classe
et il est donc impossible de définir un membre comme privé ou protégé : par défaut,
tous les membres de classe sont publics en Python.
En revanche, certaines conventions ont été mises en place par la communauté Python,
notamment au niveau des noms des membres de classe qui servent à indiquer aux
autres développeurs qu’on ne devrait accéder à tel membre que depuis l’intérieur de la
classe ou à tel autre membre que depuis la classe ou une classe fille.
Ces conventions sont les suivantes :
On préfixera les noms des membres qu’on souhaite définir comme “privés” avec deux
underscores comme ceci : __nom-du-membre ;
On préfixera les noms des membres qu’on souhaite définir comme “protégés” avec un
underscore comme ceci : _nom-du-membre.
Cela fait que si un développeur essaie d’utiliser un membre défini avec deux
underscores tel quel, Python renverra une erreur puisqu’il préfixera le nom avec un
underscore et le nom de la classe du membre.
Cette règle a été prévue par Python pour éviter les accidents de conflits entre plusieurs
membres de plusieurs classes qui auraient le même nom. Elle n’empêche pas
d’accéder ou de modifier un membre “privé”. En effet, il suffit de préfixer le membre
de la même façon que Python lors de son interprétation pour y accéder.

2ème Année MP/PC Page 6

Vous aimerez peut-être aussi