1
LA
PYTHON
&
PROGRAMMATION ORIENTÉ
OBJET
PRÉSENTÉ PAR
SOUMAYA DARRAGI
Plan
2
Complexité des logiciels
Qualité d’un bon logiciel
Limite de la programmation procédurale
Introduction à la POO
Concepts de bases
Classes / Objets
Attributs /Méthodes
Méthodes spéciales
Héritage
Des logiciels de plus en plus complexes
3
Les
problèmes que les logiciels doivent solutionner
comportent
souvent
des
éléments
extrêmement
complexes.
Le fonctionnement de ces systèmes est déjà difficile à
cerner, et pourtant il faut y ajouter des exigences non
fonctionnelles (et surtout implicites) telles que la facilite
d'emploi, les performances, le coût, la robustesse ...
La tâche fondamentale de l‘équipe de développement de
logiciel est de promouvoir une illusion de simplicité afin de
protéger l'utilisateur de cette complexité
externe
arbitraire.
L’idée est de s’efforçer d‘écrire moins de code, cependant
il faut faire face à un énorme volume de spécifications.
Complexité (suite)
4
Plus
un système est complexe, plus il est
susceptible d'effondrement [Peter, 1986]
Est ce qu'un entrepreneur songe à ajouter une
nouvelle assise à un immeuble de 100 étages
existants?
Ce genre de considérations est pourtant demandé
par certains utilisateurs de logiciels !
Comment y répondre ?
Qualité d’un bon logiciel
5
Un bon logiciel doit répondre aux qualités suivantes:
Extensibilité : sa faculté d'adaptation d'un
logiciel aux changements de spécification.
Simplicité de la conception : une architecture simple sera
toujours plus facile à
modifier qu'une architecture
complexe.
Décentralisation: plus les modules d'une architecture
logicielle sont autonomes, plus il est probable qu'une
modification simple n'affectera qu'un seul module, ou un
nombre restreint de modules, plutôt que de déclencher une
réaction en chaîne sur tout le système.
Qualité d’un bon logiciel (suite)
6
Réutilisabilité: aptitude d'un logiciel à être réutilisé
en tout ou en partie pour de nouvelles applications.
L'idée à retenir est de "ne pas réinventer la roue !".
Il s'agit de programmer moins pour programmer
mieux.
C'est
la finalité du modèle objet en
programmation!!
Il apporte une sémantique facilitant ce processus
en programmation.
Limite de la programmation procédurale
7
Dans ce style de programmation les données et le code sont
séparés.
Concrètement, on utilise :
Des variables (globales) qui
contiennent vos données
sont utilisées par des fonctions/procédures.
Des fonctions qui
Peuvent modifier une variable
Peuvent passer cette variable à une autre fonction/procédure.
Limites
Le code devient vite fastidieux.
Sans être le concepteur, comment interpréter facilement les
données de chaque conteneur
La POO présente des réponses
Introduction à la POO
8
Concepts de bases
Classes:
On appelle classe un ensemble d'objets
partageant certaines propriétés (attributs) et fonctions
(méthodes). Il s'agit d'un concept abstrait, comme par
exemple les plans d'une maison.
objet est une définition de
caractéristiques propres à un élément particulier.
Il s'agit d'un élément concret qui contient les
propriétés de sa classe, comme une maison qui suit
les plans définis préalablement.
Objet:
Un
Introduction à la POO (suite)
9
Vocabulaire …
Des objets similaires peuvent être informatiquement
décrits par une même abstraction : une classe.
Une classe est donc un moule pour fabriquer des
objets. Elle décrit la structure de données et définit
les méthodes de traitements.
Une classe est composée de plusieurs membres dont
chacun est soit
un attribut
variable
une méthode : (une opération) ensemble d'instructions de
traîtement
Un objet créé à partir d'une classe A est une
instance de la classe A
POO sous Python
10
Déclaration de classe
class nom_classe() :
'' '' '' ici vous pouvez déclarer ce que vous voulez'' '' ''
class nom_classe(object) :
'' '' '' ici nous avons rajouter object c'est parce
que class que nous utilisons est en effet elle même une instance
de la classe objet ancêtre définie par Python !!!'' '' '' elle
admet déjà un dictionnaire prédéfini __dict__
Classe et objet
11
La création d’un objet se fait par
Nom_objet=nomclasse()
L’accès à ses membres se fait par
Nom_objet.nom_attribut
Nom_objet.methode()
Exemple 1 :
Class Bidon():
'' '' '' c’est une classe bidon qui ne sert à rien '' '' '' '‘
Et pourtant on peut déjà créer des objets bidons
>>>A=Bidon()
>>>B=Bidon()
>>>id(A), id(B)
Dans cette classe on n’a pas encore déclarer des propriétés
Class vs Objet
12
Exemple 2
class point():
abs=0
ord=0
A=point()
B=point()
print(A.abs,A.ord)
print(B.abs,B.ord)
Chaque objet créé aura accès à ses propriétés abs et
ord dits attributs de classe, les valeurs seront par
défaut 0 et 0
Attributs de classe VS Attributs d’instance
13
Les données (non pas des méthodes) stockées par les
objets sont appelées attributs
Attributs de données
Variable appartenant à une instance particulière d'une classe
Chaque instance a sa propre valeur pour cela
Ce sont les attributs les plus courants
Attributs de classe
Appartient à la classe dans son ensemble
Toutes les instances de la classe partagent la même valeur
Appelés variables "statiques" dans certains langages
Bon pour (1) les constantes à l'échelle de la classe et (2)
compteur de construction du nombre d'instances de la classe
Attribut de classe / Attribut d’objets
14
Trace d’exécution
15
Trace
Aprés déclaration de la classe A.abs=0, A.ord=0
Aprés déclaration de la classe B.abs=0, B.ord=0
Aprés modification de l'attribut de classe A.abs=5, A.ord=0
Aprés modification de l'attribut de classe B.abs=5, B.ord=0
Attribut de classes
16
>>> A.abs
0
>>> A.ord
0
>>> A.abs=1
>>> A.ord
0
>>> A.abs
1
>>> B.abs
0
>>> point.abs=5
>>> B.abs
5
>>> B.abs=12 #modification interne
>>> point.abs=1
>>> B.abs
12
>>> A.abs
1
>>> C=point()
>>> C.abs
1
>>> D=point()
>>> D.abs
1
>>>
Attributs d’instances
17
Les attributs de données sont créés et initialisés
par la méthode __init __ () [constructeur de
classe ]
Il suffit d'attribuer un nom pour créer l'attribut
Dans la classe, one se reporte aux attributs de
données en utilisant self
Par exemple: self.abs
Attribut d’instance
18
Un point doit être créé à partir de ses coordonnés
et non pas défini par l’origine constructeur de
classe: la méthode __init__ première méthode
invoquée au moment de l’instanciation des objets.
Attribut spécial
19
>>> A=point()
>>> B=point(-2,3)
>>> A.__dict__
{'ord': 0, 'abs': 0}
>>> help(A)
Help on point in module __main__ object:
class point(builtins.object)
| Methods defined here:
|
| __init__(self, x=0, y=0)
| | ---------------------------------------------------------------------| Data descriptors defined here:
| | __dict__
|
dictionary for instance variables (if defined)
Classe - Méthodes
20
Ajouter à la classe point une fonction appelée
méthode au sens de la POO, permettant d’afficher
les coordonnées de A ainsi qu’une deuxième
méthode permettant de calculer la distance entre
deux points A (x1,y1) et B(x2,y2) donnée par la
formule suivante
Attributs / Méthodes (suite)
21
>>> A=point(3,4),B=point(-1,5)
>>> A.distance(B)
4.123
>>> B.distance(A)
4.123
>>> A.affiche()
le point est de coordonnées (3, 4)
>>>A.abs
3
>>>A.ord
4
Accés aux attributs
Méthode Exemple 2
22
class etudiant:
""" Cette classe représente un étudiant
"""
def __init__(self,n,a):
self.nom_complet = n
self.age = a
def get_age(self):
return self.age
Accés Attributs et méthodes
23
e = etudiant(“Sara Smith”, 22)
e.nomcomplet # Accès à un attribut
‘Sara Smith'
f.age() # Accès à une méthode
22
Accéder aux membres inconnus
24
Problème:
Parfois, le nom d'un attribut ou d'une méthode d'une classe n'est
donné qu'à l'exécution ...
Solution:
getattr (instance_objet, string)
string est une chaîne qui contient le nom d'un attribut ou d'une
méthode d'une classe.
getattr (object_instance, string) renvoie une référence à cet
attribut ou méthode.
Exemple
>>> e=etudiant('sara smith',22)
>>> getattr(e,'nom_complet')
'sara smith'
25
>>> getattr(e,'age') #attribut
22
>>> getattr(e,'get_age')() #Méthode
22
>>> getattr(e, ‘age’)
>>>setattr(e,’age’,21)
>>> getattr(e, ‘age’)
21
>>> hasattr(e,’adresse’)
False
>> hasattr(e,’age’)
True
Méthode – Méthode spéciales
26
Les méthodes spéciales sont des méthodes
d'instance que Python reconnaît et sait utiliser,
dans certains contextes. Elles peuvent servir à
indiquer à Python ce qu'il doit faire quand il se
retrouve
devant
une
expression
comme
mon_objet1 + mon_objet2
Plusieurs Méthodes existent permettant de
surcharger des opérteurs même
__add__ ‘+’
__sub__ ‘-’
__str__ ‘print’
__repr__ nom de l’objet et print
la liste est longue……….
Méthode vs Méthode Spéciales
27
Exemple
>>> A=point()
>>> A
point de coordonnées (0;0)
>>> print(A)
point de coordonnées (0;0)
Héritage
28
Il est possible de définir une classe spécialisée à partir
d'une autre classe plus générale (dite classe de base ou
classe mère ou super-classe)
La nouvelle classe (dite dérivée) permet a un objet qui
l'instancie d'hériter des caractéristiques (attributs
et méthodes) décrites par la classe héritée
La classe dérivée peut ensuite subir des
modifications:
Définition de nouveaux attributs et de nouvelles méthodes
Redéfinition de méthodes de la classe de base
Extension de méthodes de la classe de base
Héritage(suite)
29
Lorsqu'une classe hérite d'une autre elle peut :
Utiliser les attributs de la classe parent
Utiliser les méthodes de la classe parent
définir de nouveaux attributs
définir de nouvelle méthodes
Redéfinir certaines méthodes
Héritage (suite)
30
L'héritage dénote une relation de
généralisation /spécialisation
● Toute relation d'héritage peut se traduire
par la phrase : « La classe dérivée est une
version spécialisée de la classe de base »
● Le principe de généralisation/spécialisation
invoque donc une relation dite relation est-un
Héritage
31
Un pixel est un point sur écran La classe pixel
hérite les attributs du point ainsi que ses méthodes
Héritage (suite)
32
class Voiture:
roues = 4
moteur = 1
def __init__(self):
self.nom = "A determiner"
def allumer(self):
print "La voiture demarre"
class VoitureSport(Voiture):
def __init__(self):
self.nom = "Ferrari"
def allumer(self):
Voiture.allumer(self)
print "La voiture de sport demarre"
ma_voiture_sport = VoitureSport()
ma_voiture_sport.allumer()
Héritage Multiples
33
Python supporte également l’héritage multiple.
Une définition de classe avec plusieurs classes de base ressemble a:
Class NomClasseDerivee (Base1,Base2,..,BaseN) :
<instruction1>
…
<instructionN>
Lorsqu’on référencie un attribut, la recherche s’effectue en
profondeur cad de gauche a droite? Donc si un attribut n’est pas
trouve dans ClasseDerivee, on le cherchera d’abord dans base1, puis
dans base2, et ainsi de suite jusqu’a 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!!!!
34
A vous de jouer ….