Vous êtes sur la page 1sur 31

Institut Supérieur de Gestion de Tunis

Langage évolué & Business Intelligence


Chapitre 4 – La programmation Orienté Objet en Python

D r. Z a h r a KO D I A A O U I N A

2 ÈME L F I G

DR ZAHRA KODIA AOUINA 1


Programmation Orienté Objet
Introduction
La Programmation Orientée Objet :
 Elle permet de mieux modéliser la réalité en concevant des ensembles
d’objets, les 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.

DR ZAHRA KODIA AOUINA 2


Programmation Orienté Objet
Classe Vs. Objet
Une classe est donc équivalente à un nouveau type de
données. On connaît déjà par exemple str ou dict.
Un objet ou une instance est un exemplaire particulier
d’une classe. Par exemple "bb" est une instance de la classe
str.
La plupart des classes encapsulent à la fois les données et
les méthodes applicables aux objets. Par exemple, un objet
str contient une chaîne de caractères Unicode (les données)
et de nombreuses méthodes comme upper().

DR ZAHRA KODIA AOUINA 3


Les classes
Syntaxe
La forme la plus simple de définition de classe ressemble à ceci :
class Nomclasse:
<instruction1>

<instructionN>
Dans la pratique, les instructions à l’intérieur de la définition de
classe seront souvent des définitions de fonctions, mais d’autres
instructions sont acceptées.

DR ZAHRA KODIA AOUINA 4


Les classes
Instanciation
Un objet est une instance d'une classe. On peut créer autant
d'objets que l'on désire avec une classe.

L’instanciation(création d’une instance (objet) Nomclasse):


x=Nomclasse() affecte la nouvelle instance à la variable x

La référence d’attributs : Nomclasse.i où i est un attribut de


Nomclasse et une référence d’attribut valide.

DR ZAHRA KODIA AOUINA 5


Les classes
Attributs
Les attributs d’une classe n’ont pas besoin d’être déclarés;
Comme les variables locales, elles apparaissent lorsqu’on leur affecte
une valeur la première fois
class MaClasse :
def aff(self,y):
print("hello World"*y)
i=123456
x= MaClasse()
x.compteur = 1 #création de l’attribut compteur
Vous pouvez à tout moment créer un attribut pour votre objet

DR ZAHRA KODIA AOUINA 6


Les classes
Méthodes
Une méthode est appelée comme suit:
x.f()
L’appel x.f() est donc équivalent à MaClasse.f(x).
Il n’est pas nécessaire que la définition de la méthode soit comprise
dans la définition de la classe.
Exemple :
def f1 (self, x,y):
return min(x,y)
class C:
f=f1
exemple=C()
print(exemple.f(5,78))

DR ZAHRA KODIA AOUINA 7


Les classes
Constructeur
Lorsqu’une class définit la méthode spéciale __init__(),
l’instanciation de la classe appelle automatiquement cette
méthode.
Bien sûr, la méthode __init__() peut prendre autant de
paramètre qu’on le veut, pour une flexibilité accrue…
class Voiture:
def __init__(self):
self.nom = "Ferrari"

DR ZAHRA KODIA AOUINA 8


Les classes
Attribut de classe / d’instance
Attribut de classe est un paramètre statique en dehors et
indépendamment de toute instanciation,
Attribut d’instance est déclaré généralement dans le constructeur et
précédé par self
class Test:
chat = "noir"
def __init__(self):
self.chat = "gris"
instance = Test()
print Test.chat
print instance.chat

DR ZAHRA KODIA AOUINA 9


Les classes
Méthodes spéciales
Python contient une liste de méthodes dites spéciales :

DR ZAHRA KODIA AOUINA 10


Les classes
Méthodes spéciales
Les noms de méthodes encadrés par deux soulignés de part et d'autre
sont des méthodes spéciales.

L'attribut spécial __dict__


Cet attribut spécial vous donne un dictionnaire contenant les couples
qui décrivent les valeurs des attributs de l'instance:
>>> v.__dict__
{'nom': 'Ferrari'}

DR ZAHRA KODIA AOUINA 11


Les classes
Méthodes spéciales
 Quand on affiche avec print une instance, la méthode __str__()
s’exécute implicitement pour récupérer la valeur à afficher. C’est le
même comportement que d’appeler str() sur un objet.
 On peut donc coder la méthode __str__ pour obtenir un
affichage personnalisé :
Sans redéfinition du __str__
class Livre(object):
print(l)
def __init__(self, titre, auteur):
self.titre = titre <__main__.Livre object at 0x01F17050>

self.auteur = auteur Suite à la redéfinition du __str__


def __str__(self): print(l)
return "{} de {}".format(self.titre, self.auteur)
L alchimiste de P. Coehlo
l= Livre("L alchimiste", "P. Coehlo")
DR ZAHRA KODIA AOUINA 12
Les classes
Méthodes spéciales
 Parfois il est intéressant de décortiquer un objet pour résoudre un bug ou
pour comprendre un script.
La fonction dir(x) vous donne un aperçu des méthodes de l'objet x:
>>> class Voiture:
def __init__(self):
self.nom = "Ferrari"

>>> v= Voiture()
>>>dir(v)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
'__format__', ……., 'nom']

DR ZAHRA KODIA AOUINA 13


Les classes
Accesseur et mutateurs (1/2)
Une convention de passer par :
o des getter (ou accesseur en français) pour récupérer un attribut
o des setter (mutateurs) pour changer la valeur d'un attribut.

DR ZAHRA KODIA AOUINA 14


Les classes
Accesseur et mutateurs (2/2)
class Voiture(object):
def __init__(self):
self._roues=4
def _get_roues(self):
print "Récupération du nombre de roues"
return self._roues
def _set_roues(self, v):
print "Changement du nombre de roues"
self._roues = v
roues=property(_get_roues, _set_roues)

DR ZAHRA KODIA AOUINA 15


Les classes
Exemple de classe (1/2)
class Etudiant:
“““Une classe qui représente un
étudiant”””
def __init__(self,n,a):
self.nom = n
self.age = a
def _get_age(self):
return self.age

DR ZAHRA KODIA AOUINA 16


Les classes
Exemple de classe (2/2)
>>> f = Etudiant(“Akrem”, 22)

>>> f.nom # Accès à l’attribut


“Akrem”
>>> f._get_age() # Accès à la méthode
22

DR ZAHRA KODIA AOUINA 17


Les classes
Les méthodes d’instance-self
Suite à la création d’un nouvel objet, les attributs de l'objet
sont propres à l'objet créé.
Par contre, les méthodes sont contenues dans la classe qui
définit notre objet.
Quand vous devez travailler dans une méthode de l'objet
sur l'objet lui-même, on DOIT passer par self. On parle de
méthodes d’instance.

DR ZAHRA KODIA AOUINA 18


Les classes
Méthodes de classe
 Une méthode de classe se définit exactement comme une
méthode d'instance, à la différence qu'elle ne prend pas en
premier paramètre self (l'instance de l'objet) mais cls (la classe
de l'objet).

 En outre, on utilise ensuite un décorateur de Python pour lui


faire comprendre qu'il s'agit d'une méthode de classe, pas
d'une méthode d'instance: @classmethod

DR ZAHRA KODIA AOUINA 19


Les classes
Méthodes de classe
class Compteur:
"""Cette classe a un attribut de classe qui s'incrémente à chaque fois que l'on crée un
objet de ce type"""
objets_crees = 0 # Le compteur vaut 0 au départ
def __init__(self):
"""À chaque fois qu'on crée un objet, on incrémente le compteur"""
Compteur.objets_crees += 1
@classmethod
def combien(cls):
"""Méthode de classe affichant combien d'objets ont été créés"""
print("Jusqu'à présent, {} objets ont été créés.".format(cls.objets_crees))
c= Compteur()
c1=Compteur()
c.combien()

DR ZAHRA KODIA AOUINA 20


Les classes
Méthodes statiques
Les méthodes statiques sont assez proches des méthodes de classe sauf
qu'elles ne prennent aucun premier paramètre, ni self ni cls.
Elles travaillent donc indépendamment de toute donnée, aussi bien
contenue dans l'instance de l'objet que dans la classe.
class Test:
"""Une classe de test tout simplement"""
@staticmethod
def afficher():
"""Fonction chargée d'afficher quelque chose"""
print("On affiche la même chose.")
print("peu importe les données de l'objet ou de la classe.")
t=Test()
t.afficher()

DR ZAHRA KODIA AOUINA 21


Héritage
Syntaxe
La syntaxe pour définir une classe dérive est la suivante :
Class NomClasseDerivee(NomClassedeBase):
<instruction1>

<instructionN>
A la place de d’un nom de classe de base, une expression est acceptée :
class NomClasseDerivee(nommod.NomClasseDeBase):
L’exécution d’une définition de classe dérivée se déroule comme une
classe de base. Quand l’objet classe est construit, la classe de base est
mémorisée. C’est ce qui permet de trouver facilement un attribut.
Lorsqu’un attribut est référencé, il est recherché dans la classe dérivée s’il
ne s’y trouve pas on le recherchera dans la classe de base.

DR ZAHRA KODIA AOUINA 22


Héritage
Héritage multiple
Python supporte également l’héritage multiple.
Une définition de classe avec plusieurs classes de base ressemble à :
Class NomClasseDerivee (Base1,Base2,..,BaseN)
<instruction1>

<instructionN>
Lorsqu’on référence un attribut, la recherche s’effectue en profondeur càd de
gauche à droite. Donc si un attribut n’est pas trouvé dans NomClasseDerivee, on
le cherchera d’abord dans base1, puis dans base2, et ainsi de suite jusqu’à ce
qu’on le trouve…
Remarque : Il faut faire attention aux conflits accidentelles!! Par exemple, si on
crée une classe dérivée de deux autres classes dérivées de la même classe de
base…risque de problèmes!!!!
DR ZAHRA KODIA AOUINA 23
Héritage
Surcharge
Il est possible d'écraser la méthode de la classe parente en la
redéfinissant. On parle alors de surcharger une méthode.
class Voiture: class VoitureSport(Voiture):
roues = 4 def __init__(self):
moteur = 1 self.nom = "Ferrari"
def __init__(self): def allumer(self):
self.nom = "A déterminer" print "La voiture de sport démarre"
def allumer(self): ma_voiture_sport = VoitureSport()
print "La voiture démarre" ma_voiture_sport.allumer()

DR ZAHRA KODIA AOUINA 24


Héritage
Surcharge
class Etudiant:
...
def __repr__(self):
return “Je m’appelle “ + self.nom
...

>>> f = Etudiant(“Akrem”, 22)


>>> print f
Je m’appelle Akrem
>>> f
“Je m’appelle Akrem”

DR ZAHRA KODIA AOUINA 25


Héritage
Exemple d’Héritage
class Etudiant:
“““A class representing a student ”””
def __init__(self,n,a):
self.nom = n
self.age = a
self.moyenne = 0
def get_age(self):
return self.age
Class Cs_etudiant (Etudiant):
“Une classe qui hérite de la classe etudiant.”
def __init__(self,n,a,s):
Etudiant.__init__(self,n,a) #Appel de __init__ pr Etudiant
self.section_num = s
def get_age(self): #Surcharge de la méthode get_age
print “Age: ” + super().get_age()

DR ZAHRA KODIA AOUINA 26


Liste d’Objets
Création
Il suffit de créer une liste et d’y insérer les instances d’objets.
Exemple :
ListeEtu=[]
ListeEtu.append(Etudiant("manel",22))
ListeEtu.append(Etudiant("akrem",19)
print("Affichage des étudiants : \n")
for i in range(len(ListeEtu)) :
ListeEtu [i].calculMoyenne()
print(ListeEtu[i])

DR ZAHRA KODIA AOUINA 27


Liste d’Objets
Tri d’une liste d’objets
La fonction sorted possède un paramètre optionnel, appelé key.
Pour préciser la méthode de tri, il nous faut une fonction lambda qui prenne
en paramètre un élément de la liste à trier et retourne l'élément qui doit être
utilisé pour trier.
lambda classe: classe.attribut
Exemple:
>>> sorted(ListeEtu, key=lambda etudiant: etudiant.age, reverse=True)
[ <Étudiant Akrem (âge=19, moyenne=16)>,
<Étudiant Sonia (âge=20, moyenne=15)>,
<Étudiant Manel (âge=21, moyenne=8.5)>,
<Étudiant Sami (âge=21, moyenne=16.1)>,
<Étudiant Mehdi (âge=22, moyenne=13.8)>]

DR ZAHRA KODIA AOUINA 28


POO en Python
En résumé
On définit une classe en suivant la syntaxe class NomClasse:
Les méthodes se définissent comme des fonctions, sauf qu'elles se
trouvent dans le corps de la classe.
Les méthodes d'instance prennent en premier paramètre self,
l'instance de l'objet manipulé.
On construit une instance de classe en appelant son constructeur, une
méthode d'instance appelée __init__.
On définit les attributs d'une instance dans le constructeur de sa
classe, en suivant cette syntaxe : self.nom_attribut = valeur.

DR ZAHRA KODIA AOUINA 29


POO en Python
En résumé
 L'héritage permet à une classe d'hériter du comportement d'une
autre en reprenant ses méthodes.
 La syntaxe de l'héritage est class NouvelleClasse(ClasseMere):.
 On peut accéder aux méthodes de la classe mère directement via la
syntaxe : ClasseMere.methode(self).
 L'héritage multiple permet à une classe d'hériter de plusieurs classes
mères.
 La syntaxe de l'héritage multiple s'écrit donc de la manière suivante:
class NouvelleClasse(ClasseMere1, ClasseMere2, ClasseMereN):.

DR ZAHRA KODIA AOUINA 30


Annexe
Surcharge de la méthode __eq__
La surcharge de la méthode __eq__() permet de surcharger
l’opérateur ==
Exemple:
def __eq__(self, other):
if isinstance(other, self.__class__):
return self.__dict__ == other.__dict__
else:
return False

DR ZAHRA KODIA AOUINA 31