B201A Informatique

appliquée

Séance 3
Classe et
objet

Sébastien Combéfis, Quentin Lurkin 2017–2018

Ce(tte) œuvre est mise à disposition selon les termes de la Licence Creative Commons
Attribution – Pas d’Utilisation Commerciale – Pas de Modification 4.0 International.
Rappels

Tuple

Séquence ordonnée non modifiable d’éléments

Emballage et déballage, affectation multiple
Définition et utilisation de tuples nommés

Objet

Création d’un objet

Accès aux attributs et appels de méthode
Introduction à la programmation orientée objet

3
Objectifs

Définition de classes

Définition, constructeur et initialisation

Variable d’instance
Définition et appel de méthode

Programmation orientée objet

Méthodes « spéciales » (égalité et représentation

d’objets) Visibilité des attributs, encapsulation
Conception orientée objet

4
Class
e
Objet et
classe
Un objet est une instance d’une classe
Une classe est un modèle à partir duquel on construit des
objets

La classe définit deux éléments constitutifs des objets

Les attributs et les fonctionnalités de l’objet
Marque : Sony-Ericsson
Modèle : S500i
Couleur : Mysterious Green
Batterie : 80%
Luminosité : 60%

Marque : Sony-Ericsson
Modèle : S500i
Couleur : Spring Yellow
Batterie : 35%
Luminosité : 90%

6
Attribut et fonctionnalité

Un attribut est une donnée stockée dans un objet

Les valeurs des attributs définissent l’état de l’objet

Une fonctionnalité permet d’effectuer une action

Obtenir une information sur l’objet ou donner un
ordre
GSM
GSM Marque
Modèle
g Couleur
GSM
envoyerSMS
Sony Ericsson recevoirAppel
w200i voirNiveauBatterie
Orange-Blanc

7
 Utilisation d’un
objet
Pour pouvoir créer des objets, il faut une classe
Une définition unique permet de créer plusieurs objets

Une fois créée, interaction avec attribut et

fonctionnalité
Utilisation de l’opérateur d’accès/appel sur l’objet
1 # Construction d ’ objets
2 maxime = Perso n ( " Maxime " , " Hockey " )
3 e l i s e = Perso n ( " E l i s e " , " S pac e " )
4
5 # Ac c è s à un a t t r i b u t
6 p r i n t ( maxime . f i r s t n a m e ) # A f f i c h e ’ Hockey ’
7
8 # Appel d ’ une méthode
9 p r i n t ( maxime . h a s f r i e n d ( e l i s e ) ) # A f f i c h e ’ True ’

8
 Définir une
classe

Définition d’une classe avec le mot réservé c l a s s

Corps de la classe est un bloc de code indenté

Le corps de la classe peut contenir des définitions de
méthodes

Classe minimale grâce à l’instruction pass

Aussi appelée instruction vide car ne fait rien

1 class Contact:
2 pass

9
 Créer une instance

Un objet est une instance d’une classe

À partir d’une classe, on crée autant d’objets que l’on veut

1 a = Contact ()
2 b = Contact ()

Contact

a
Contact

Contact

b Contact Contact

10
 Définir un constructeur

Initialisation d’un objet par la méthode spéciale init

Admet au moins un paramètre qui est s e l f

Le paramètre s e l f référence l’objet à construire

Permet d’accéder aux attributs et fonctionnalités de l’objet

1 class Contact:
2 def init ( s e l f , f i r s t n a m e , l as t name , phonenumber ) :
3 s e l f . firstname = firstname
4 s e l f . l a s t n a m e = l as t name
5 s e l f . phonenumber = phonenumber

11
 Appeler un constructeur

Méthode appelée au moment de la création d’un

objet
Initialise l’objet, en donnant une valeur à ses variables
1 marchand = C o n t a c t ( " C é d r i c " , " Marchand " , 2693)
2 f l e m a l = C o n t a c t ( " Clé mence " , " F l e m a l " , 0)

Contact Contact
firstname
lastname
marchand phonenumber
Contact
Cédric
Marchand
Contact
8172
Contact
Clémence
flemal Flemal
0

12
 Objet et référence

Un objet est une instance d’une classe

L’instanciation d’une classe produit un objet

Stockage d’une référence vers l’objet dans une

variable
L’adresse où l’objet se situe en mémoire
1 p r i n t ( marchand )
2 print ( flemal )

< main . Contact object a t 0 x109678748 >

< main . Contact object a t 0 x109678780 >

13
 Variable d’instance

Variables d’instance attachées à un objet définissent son

état
Chaque objet possède ses propres copies de ces variables

Accès aux variables d’instance avec l’objet cible

Ou s e l f à l’intérieur du code de la classe
1 p r i n t ( marchand . f i r s t n a m e )
2 p r i n t ( f l e m a l . phonenumber )

Cé dric
0

14
 Plusieurs constructeurs

Paramètre optionnel pour offrir plusieurs constructeurs

Définit une valeur par défaut pour les variables

d’instance D’abord les obligatoires, puis les optionnelles

1 class Contact:
2 def init ( s e l f , f i r s t n a m e , l as t name , phonenumber = 0 ) :
3 s e l f . firstname = firstname
4 s e l f . l a s t n a m e = l as t name
5 s e l f . phonenumber = phonenumber
6
7 marchand = C o n t a c t ( " C é d r i c " , " Marchand " , 2693)
8 f l e m a l = C o n t a c t ( " Clé mence " , " F l e m a l " )

15
 Méthode

Méthode attachée à un objet réalisant une action

dessus
La méthode reçoit d’office un paramètre s e l f , l’objet cible

Appel d’une méthode sur un objet cible avec le point

1 c l a s s( . )
Contact:
2 def init ( s e l f , f irst name , lastname ) :
3 s e l f . firstname = firstname
4 s e l f . l a s t n a m e = l as t name
5 s e l f . phonenumber = 0
6
7 def setphonenumber ( s e l f , number):
8 s e l f . phonenumber = number
9
10 marchand = C o n t a c t ( " C é d r i c " , " Marchand " )
11 marchand . setphonenumber (2693 )

16
 Plusieurs
méthodes
Comme pour le constructeur pour avoir plusieurs
méthodes
Utilisation de la valeur spéciale None comme valeur par défaut
1 class Contact:
2 # [...]
3 def changename ( s e l f , f i r s t n a m e = None , l a s t n a m e = None ) :
4 i f f i r s t n a m e i s not None :
5 s e l f . firstname = firstname
6 i f l a s t n a m e i s not None :
7 s e l f . l a s t n a m e = l as t name

[Link](’John’, ’Doe’)

[Link](’John’)

[Link](lastname=’Doe’)

17
 Définir un vecteur dans le plan (1)

Deux variables d’instance pour représenter les coordonnées

Les deux variables s e l f . x et s e l f . y représentent (x, y )

Une méthode norm pour calculer la longueur du vecteur

√
La norme vaut x 2 +y2

1 c l a s s Ve c t o r :
2 def init ( self , x , y):
3 self. x = x
4 self. y = y
5
6 def norm ( s e l f ) :
7 r e t u r n s q r t ( s e l f . x * * 2 + s e l f . y * * 2)
8
9 u = Ve c t o r (1 , - 1)
10 p r i n t ( u . norm ( ) )

1 .4142135623730951
18
 Exemple : Définir une musique

Un titre, une liste d’artistes et une durée

Méthode hasArtist teste si un artiste a composé la

musique
1 c l a s s Music:
2 def init ( self , title , artists , duration ) :
3 self. title = title
4 s e l f . artists = artists
5 s e l f . durat io n = duration
6
7 def h a s A u t h o r ( s e l f , name ) :
8 r e t u r n name in s e l f . a r t i s t s
9
10 m1 = M u s i c ( ’ Easy Come Easy Go ’ , [ ’ A l i c e on t h e r o o f ’ ] , 213)
11 p r i n t ( m1 . h a s A u t h o r ( ’ Stromae ’ ) )

Fa l s e

19
 Exemple : Définir une personne

Deux éléments particuliers à relever dans la classe Person

Variables d’instance pas en paramètre du constructeur

Une méthode ne renvoie pas forcément quelque
chose

1 c l a s s Perso n :
2 def init ( s e l f , f irst name , lastname ) :
3 s e l f . firstname = firstname
4 s e l f . l a s t n a m e = l as t name
5 s e l f . friends = []
6
7 def a d d f r i e n d ( p ) :
8 s e l f . f r i e n d s . append ( p)
9
10 def h a s f r i e n d ( p ) :
11 r e t u r n p in s e l f . f r i e n d s

20
 Mot réservé s e l f

La variable d’instance est accessible dans toute la classe

Existe en mémoire pendant toute la durée de vie de l’objet

Opposée à la variable locale qui n’existe que dans la

méthode
1 c l a s s Ve c t o r :
2 def init ( self , x , y):
3 pass
4
5 def norm ( s e l f ) :
6 r e t u r n s q r t ( x * * 2 + y * * 2)
7
8 u = Ve c t o r (1 , - 1)
9 p r i n t ( u . norm ( ) )

Tra c e b a c k ( most r e c e n t c a l l l a s t ) :
F i l e " program . p y " , l i n e 38 , i n <module >
p r i n t ( u . norm ( ) )
F i l e " program . p y " , l i n e 35 , i n norm
r e t u r n s q r t ( x * * 2 + y * * 2)
Name E r r o r : name ’ x ’ i s no t d e f i n e d
21
 Fonction vs méthode (1)

Une méthode est une fonction associée à un objet

La méthode peut agir sur les variables d’instance de

l’objet La méthode est appelée sur un objet cible

Fonction agissant sur un tuple nommé

Tuple passé en paramètre de manière explicite

1 Ve c t o r = namedtuple ( ’ Ve c t o r ’ , [’x’, ’y’])

2
3 def norm ( v ) :
4 r e t u r n s q r t ( v . x * * 2 + v . y * * 2)
5
6 u = Ve c t o r (1 , - 1)
7 p r i n t ( norm ( u ) )

22
 Fonction vs méthode (2)

Une méthode est une fonction associée à un objet

La méthode peut agir sur les variables d’instance de
l’objet La méthode est appelée sur un objet cible

Méthode agissant sur un objet cible

Objet cible passé de manière implicite

1 c l a s s Ve c t o r :
2 def init ( self , x , y):
3 self. x = x
4 self. y = y
5
6 def norm ( s e l f ) :
7 r e t u r n s q r t ( s e l f . x * * 2 + s e l f . y * * 2)
8
9 u = Ve c t o r (1 , - 1)
10 p r i n t ( u . norm ( ) )

23
 Résumé : définition d’une
classe
Deux éléments à définir dans le corps d’une
classe

Le constructeur initialise les variables

d’instance Les méthodes interrogent ou
agissent sur l’objet

Plusieurs constructeurs et versions d’une

1
méthode
c l a s s Nom De La C l a s s e :
2 def init ( s e l f , pc1 , pc2 , . . . ) :
3 sÀe ll’aide
f . v a r ides
n s t 1paramètres
= pc1 optionnels
4 s e l f . v a r i n s t 2 = pc2
5 s e l f . a u t r e v a r i n s t = valeur
6
7 def methode ( s e l f , pm1 , pm2 , . . . ) :
8 # . . . a g i r sur l ’ o b j e t . . .

24
 Résumé : utilisation d’un
objet

Création d’un objet à partir du nom de la classe

Appel implicite du constructeur ( i n i t )

Même nombre de valeurs (vci ) que de paramètres (pci )

Stockage d’une référence vers l’objet dans une variable

Utilisation de cette variable pour agir sur l’objet

1 var = Nom De La C l a s s e ( vc1 , vc2 , ...)

2
3 v a r . methode ( vm1 , vm2 , ...)

25
Programmation
orientée
 Représentation d’un objet

La méthode s tr construit une représentation de

l’objet
Renvoie une chaine de caractères lisible de l’objet
1 c l a s s Ve c t o r :
2 def init ( self , x , y):
3 self. x = x
4 self. y = y
5
6 def str ( self):
7 return ’ ( ’ + s t r ( s e l f . x) + ’ , ’ + s tr ( s e l f . y) + ’ ) ’
8
9 u = Ve c t o r (1 , - 1)
10 p r i n t ( u)

(1 , - 1)

27
 Égalité
(1)
L’opérateur d’égalité compare les références des
variables
Le contenu des objets n’est pas comparé
1 u = Ve c t o r (1 , - 1)
2 v = Ve c t o r (1 , - 1)
3 p r i n t ( u == v) # Fa l s e

Vector Vector

u v
Vector Vector
1 1
-1 -1

28
 Alias
(1)
Un alias est une copie de la référence vers un
objet
Il n’y a qu’une seule copie de l’objet en mémoire
1 u = Ve c t o r (1 , - 1)
2 v = u
3 p r i n t ( u == v) # True

Vector Vector

u v
Vector
1
-1

29
 Alias
(2)
Qu’affiche le code suivant après
exécution ?

magic1 appelle une méthode sur data

magic2 modifie la variable locale data
1 def magic1 ( d a t a ) :
2 d a t a . append ( " Coucou " )
3
4 def magic2 ( d a t a ) :
5 d a t a = " Coucou "
6
7 a = [0 , 1 , 2, 3]
8 prin t ( a)
9
10 magi c1 ( a)
11 prin t ( a)
12
13 magi c2 ( a)
14 prin t ( a)

30
 Surcharge d’opérateur (1)

On peut redéfinir les opérateurs arithmétiques

add pour +, sub pour - , mul pour *...

1 c l a s s Ve c t o r :
2 def init ( self , x , y):
3 self. x = x
4 self. y = y
5
6 def add ( s e l f , o t h e r ) :
7 r e t u r n Ve c t o r ( s e l f . x + o t h e r . x , s e l f . y + o t h e r . y)
8
9 # ...
10
11 u = Ve c t o r (1 , - 1)
12 v = Ve c t o r (2 , 1)
13 p r i n t ( u + v)

(3 , 0)

31
 Surcharge d’opérateur (2)

On peut redéfinir les opérateurs de

comparaison
lt pour <, le pour <=, eq pour ==...
1 c l a s s Ve c t o r :
2 def init ( self , x , y):
3 self. x = x
4 self. y = y
5
6 def lt ( self , other):
7 r e t u r n s e l f . x < o t h e r . x or ( s e l f . x == o t h e r . x and s e l f . y <
o t h e r . y)
8
9 # ...
10
11 u = Ve c t o r (1 , - 1)
12 v = Ve c t o r (2 , 1)
13 p r i n t ( u < v)

True

32
 Définir un vecteur dans le plan (2)

Une seule variable d’instance pour les

coordonnées
Stockée dans un tuple par exemple

Choix d’implémentation complètement libres

Il n’y a pas qu’une seule solution unique
1 c l a s s Ve c t o r :
2 def init ( s e l f , x , y):
3 s e l f . c o o rds = ( x , y)
4
5 def norm ( s e l f ) :
6 r e t u r n s q r t ( s e l f . c o o rds [ 0 ] * * 2 + s e l f . c o o rds [ 1 ] * * 2)
7
8 u = Ve c t o r (1 , - 1)
9 p r i n t ( u . norm ( ) )

33
 Égalité
(2)
Surcharge de l’opérateur d’égalité pour comparer les
objets
Le contenu des objets sera comparé, et non plus les
références

Comparaison des identités avec l’opérateur i s

1
Comparaison
c l a s s Ve ctor: des références des objets
2 # ...
3
4 def eq
5 ( self ,
other):
return
self.
c o o rd
s ==
other
.
c o o rd 34
s
 Encapsulation (1)

Les données de l’objet sont encapsulées dans l’objet

Ne pas dévoiler les détails d’implémentation en dehors de l’objet

Pas d’accès direct aux variables d’instance

Pas recommandé d’accéder directement aux variables
d’instance
1 u = Ve c t o r (1 , - 1)
2 v = Ve c t o r (2 , 1)
3
4 s = Ve c t o r ( u . x + v . x , u . y + v . y)
5
6 # ou
7 # s = Ve c t o r ( u . c o o rds [ 0 ] + v . c o o rds [ 0 ] , u . c o o rds [ 0 ] + v . c o o rds [ 0 ] )

35
 Variable
privée
Variable privée en préfixant son nom avec
Ne pourra pas être accédée en dehors de la
classe
1 c l a s s Ve c t o r :
2 def init ( self , x , y):
3 self. x = x
4 self. y = y
5
6 u = Ve c t o r (1 , - 1)
7 print ( u . x)

Tra c e b a c k ( most r e c e n t c a l l l a s t ) :
F i l e " program . p y " , l i n e 9 , i n <module >
print( u. x)
A t t r i b u t e E r r o r : ’ Ve c t o r ’ o b j e c t has no
attribute ’ x’

36
 Accesseur

Accès à une variable privée à l’aide d’un accesseur

Méthode qui renvoie une variable d’instance

Un accesseur se définit avec la décoration @property

L’appel se fait comme si c’était une variable d’instance
publique
1 from math import s qr t
2
3 c l a s s Ve c t o r :
4 # ...
5
6 @ pr oper ty
7 def x ( s e l f ) :
8 return s e l f . x
9
10 u = Ve c t o r (1 , - 1)
11 pr int ( u . x) # 1

37
 Mutateur

Modification d’une variable privée à l’aide d’un

mutateur
Méthode qui change la valeur d’une variable d’instance

Un mutateur se définit avec la décoration @[Link]

Où nom est celui de la variable à modifier
1 c l a s s Ve c t o r :
2 # ...
3
4 @[Link] er
5 def x ( s e l f , v a l u e ) :
6 self. x = va l u e
7
8 u = Ve c t o r (1 , - 1)
9 u . x = 12
10 pr int ( u . x) # 12

38
 Encapsulation (2)

Accès à un objet uniquement via les méthodes publiques

Utilisateur indépendants de la représentation interne de l’objet

1 c l a s s Ve c t o r :
2 def init ( self , x , y):
3 self. c o o rd s = ( x , y)
4
5 @ pr oper ty
6 def x ( s e l f ) :
7 return s e l f . c o o rd s [ 0 ]
8
9 @[Link] er
10 def x ( s e l f , v a l u e ) :
11 self. c o o rd s = ( va l u e , self. c o o rd s [ 1 ] )
12
13 u = Ve c t o r (1 , - 1)
14 u . x = 12
15 pr int ( u . x) # 12

39
Interface

L’interface publique d’un objet expose ses

fonctionnalités
Définit ce que l’utilisateur peut faire avec l’objet

Interface publique de la classe Vector

Une variable d’instance coords privée

Un accesseur et un mutateur pour la coordonnée x
Une méthode coords publique
Vector
−coords
+x
+norm()

40
 Composition
d’objets

On peut composer plusieurs objets ensemble

En utilisant des variables d’instance de type objet

1 c las s Rectangle :
2 def init ( s e l f , l o w e r l e f t , width , height , angle =0):
3 self. l owerl ef t = lowerleft
4 self. widt h = width
5 self. hei gh t = height
6 self. angl e = angle
7
8 @ pr oper ty
9 def l o w e r l e f t ( s e l f ) :
10 return s e l f . lowerleft
11
12 p = Ve c t o r (1 , - 1)
13 r = R e c t a n g l e ( p , 100 , 50)
14 print ( r . l o we r l e f t ) # (1 , - 1)

41
 Réutilisation de
code
On peut réutiliser le code définit pour les objets
composés
Il suffit d’appeler les méthodes des variables objet
1 c las s Rectangle :
2 # ...
3
4 def str ( self):
5 r e t u r n " R e c t a n g l e en " + s t r ( s e l f .
l o w e r l e f t ) + " de l o n g u e u r " + s t r ( s e l f . width ) + " e t
de h a u t e u r " + s t r ( s e l f . h e i g h t ) + " i n c l i n é de " + s t r (
self. angle ) + " degré s"
6
7 r = R e c t a n g l e ( Ve c t o r (1 , - 1 ) , 100 , 50)
8 print ( r)

R e c t a n g l e en (1 , - 1) de l o n g u e u r 100 e t de h a u t e u r 50 i n c l i n é de
0 deg ré s

42
 Chaine de caractères
formatée
Chaine de caractères formatée à partir de valeurs
Incrustation de valeurs définie avec des balises {}
Valeurs à incruster passées en paramètres de format

Même nombre de balises que de valeurs passées en

paramètre
Sinon, l’interpréteur Python produit une erreur d’exécution

1 c las s Rectangle :
2 # ...
3
4 def str ( self):
5 r e t u r n " R e c t a n g l e en { } de l o n g u e u r { } e t de h a u t e u r { }
i n c l i n é de { } d e g r é s " . f o r m a t ( s e l f . lowerleft , s e l f . width
, self. height , s e l f . angle )
6
7 r = R e c t a n g l e ( Ve c t o r (1 , - 1 ) , 100 , 50)
8 print ( r) 43
Crédits

[Link]
[Link]

44