HAL Id: cel-02182422
https://hal.archives-ouvertes.fr/cel-02182422
Submitted on 12 Jul 2019
HAL is a multi-disciplinary open access archive for the deposit and dissemination of sci-entific research documents, whether they are pub-lished or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers.
L’archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d’enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.
Introduction à la programmation orientée objet
-Comment créer ses propres structures en Python ?
Stéphane Guinard
To cite this version:
Stéphane Guinard. Introduction à la programmation orientée objet - Comment créer ses propres structures en Python ?. École d’ingénieur. France. 2018. �cel-02182422�
Introduction `
a la programmation orient´
ee
objet
Comment cr´eer ses propres structures en Python ?
Qu’est-ce que c’est ?
La programmation orient´ee objet consiste en la d´efinition et l’interaction de briques logicielles appel´ees objets ; un objet repr´esente un concept, une id´ee ou toute entit´e du monde physique, comme une voiture, une personne ou encore une page d’un livre. Il poss`ede une structure interne et un comportement, et il sait interagir avec ses pairs. Il s’agit donc de repr´esenter ces objets et leurs relations ; l’interaction entre les objets via leurs relations permet de concevoir et r´ealiser les fonctionnalit´es attendues, de mieux r´esoudre le ou les probl`emes.
Pour quoi faire ?
Qu’est-ce qu’un rectangle ?
• Objet dans l’espace • Poss`ede 4 sommets
• Chaque sommet a ses propres coordonn´ees X, Y, Z
• Poss`ede 4 cˆot´es • Cˆot´es sont 2 `a 2 ´egaux • Cˆot´es perpendiculaires
Pour quoi faire ?
Qu’est-ce qu’un rectangle ? • Objet dans l’espace • Poss`ede 4 sommets
• Chaque sommet a ses propres coordonn´ees X, Y, Z
• Poss`ede 4 cˆot´es • Cˆot´es sont 2 `a 2 ´egaux • Cˆot´es perpendiculaires
La POO c’est pas si nouveau
Quand on ajoute des ´el´ements `a une liste : > > > l . a p p e n d (" e l e m e n t ")
Quand on compte le nombre d’´el´ements (e.g. “a”) dans une chaˆıne de caract`eres :
> > > s . c o u n t ( a ) Quand on ouvre un fichier :
Principes de la POO
Il y a 4 principes fondamentaux dans la POO :
• H´eritage • Polymorphisme • Encapsulation • Abstraction
D´eclaration d’une classe
• Utilisation du mot-cl´e ‘class‘
c l a s s M a C l a s s e (o b j e c t) : ...
... • Convention :
• 1`ere lettre des mots en majuscule • pas d’espace, tiret, underscore... • MonNomDeClasse
Instanciation d’un objet
L’objet cr´e´e est une instance de classe. On en cr´ee autant que l’on veut.
> > > m o n _ o b j e t 1 = M a C l a s s e () > > > m o n _ o b j e t 2 = M a C l a s s e () > > > m o n _ o b j e t 3 = M a C l a s s e ()
> > > p r i n t( m o n _ o b j e t 1 is m o n _ o b j e t 2 ) F a l s e
Les m´ethodes
Une m´ethode est une fonction d´efinie `a l’int´erieur d’une classe. Pour l’utiliser on fait pr´ec´eder le nom de la m´ethode du nom de l’objet. > > > c l a s s M a C l a s s e (o b j e c t) : def u n e _ m e t h o d e ( p a r a m ) : p r i n t(" Une m ´e t h o d e qui f a i t q u e l q u e c h o s e ") > > > m o n _ o b j e t = M a C l a s s e () > > > m o n _ o b j e t . u n e _ m e t h o d e () Une m ´e t h o d e qui f a i t q u e l q u e c h o s e
Les m´ethodes
Instance appelant la m´ethode = 1er param`etre de la m´ethode • nomm´e self par convention
• sp´ecificit´e de Python > > > c l a s s M a C l a s s e (o b j e c t) : def u n e _ m e t h o d e ( s e l f ) : p r i n t( s e l f ) > > > m o n _ o b j e t = M a C l a s s e () > > > p r i n t( m o n _ o b j e t ) < _ _ m a i n _ _ . D e s c r i p t i o n D e L O b j e t o b j e c t at 0 x 0 5 9 F 0 1 9 0 > > > > m o n _ o b j e t . u n e _ m e t h o d e () < _ _ m a i n _ _ . D e s c r i p t i o n D e L O b j e t o b j e c t at 0 x 0 5 9 F 0 1 9 0 >
Les attributs
Un attribut est une variable d´efinie `a l’int´erieur d’une classe. Pour y acc´eder :
• on fait pr´ec´eder le nom de l’attribut du nom de l’instance • ou de self si on est dans la classe
> > > c l a s s M a C l a s s e (o b j e c t) : def a f f i c h e r ( s e l f ) : p r i n t( s e l f . u n _ a t t r i b u t ) > > > m o n _ o b j e t = M a C l a s s e () > > > m o n _ o b j e t . u n _ a t t r i b u t = 42 > > > m o n _ o b j e t . a f f i c h e r () 42 > > > u n _ a t t r i b u t # n ’ e x s i t e pas en d e h o r s de la c l a s s e N a m e E r r o r : n a m e ’ u n _ a t t r i b u t ’ is not d e f i n e d
Le constructeur
• C’est une m´ethode appel´ee lors de la cr´eation d’objets. • Elle permet d’initialiser les valeurs des attributs. • Nomm´e init . > > > c l a s s M a C l a s s e (o b j e c t) : def _ _ i n i t _ _ ( s e l f ) : s e l f . u n _ a t t r i b u t = " v a l e u r i n i t i a l e " p r i n t(" O b j e t cr ´e ´e . A t t r i b u t s i n i t i a l i s ´e s . ") > > > m o n _ o b j e t = M a C l a s s e () O b j e t cr ´e ´e . A t t r i b u t s i n i t i a l i s ´e s . > > > m o n _ o b j e t . u n _ a t t r i b u t " v a l e u r i n i t i a l e "
Le constructeur
Possibilit´e de passer des param`etres pour personnaliser les objets. > > > c l a s s M a C l a s s e (o b j e c t) : def _ _ i n i t _ _ ( self , v a l e u r ) : s e l f . u n _ a t t r i b u t = v a l e u r > > > m o n _ o b j e t = M a C l a s s e (" v a l e u r p e r s o n n a l i s ´e e ") > > > m o n _ o b j e t . u n _ a t t r i b u t " v a l e u r p e r s o n n a l i s ´e e "
Le constructeur
Le constructeur peut aussi avoir des valeurs par d´efaut. > > > c l a s s M a C l a s s e (o b j e c t) :
def _ _ i n i t _ _ ( self , v a l e u r =" v a l e u r par d ´e f a u t ") : s e l f . u n _ a t t r i b u t = v a l e u r > > > m o n _ o b j e t 1 = M a C l a s s e () > > > m o n _ o b j e t 1 . u n _ a t t r i b u t " v a l e u r par d ´e f a ut " > > > m o n _ o b j e t 2 = M a C l a s s e (" v a l e u r p e r s o n n a l i s ´e e ") > > > m o n _ o b j e t 2 . u n _ a t t r i b u t " v a l e u r p e r s o n n a l i s ´e e "
M´ethodes sp´eciales
Nous appelerons m´ethode sp´eciale une m´ethode ex´ecut´ee sans qu’on ai besoin de l’appeler explicitement.
• init () en est une.
• Leur nom commence et termine par .
• Utile pour personnaliser le comportement d’un objet.
Remarque
Pour chaque m´ethode sp´eciale, Python a un comportement par d´efaut. Vous n’avez donc pas besoin de toutes les red´efinir. Il faut se concentrer sur les m´ethodes sp´eciales dont on a besoin et ou le comportement par d´efaut de Python ne convient pas.
M´ethodes sp´eciales
Nous appelerons m´ethode sp´eciale une m´ethode ex´ecut´ee sans qu’on ai besoin de l’appeler explicitement.
• init () en est une.
• Leur nom commence et termine par .
• Utile pour personnaliser le comportement d’un objet.
Remarque
Pour chaque m´ethode sp´eciale, Python a un comportement par d´efaut. Vous n’avez donc pas besoin de toutes les red´efinir. Il faut se concentrer sur les m´ethodes sp´eciales dont on a besoin et ou le comportement par d´efaut de Python ne convient pas.
M´ethodes sp´eciales > > > c l a s s M a C l a s s e (o b j e c t) : def _ _ i n i t _ _ ( self , v a l e u r ) : s e l f . u n _ a t t r i b u t = v a l e u r > > > m o n _ o b j e t = M a C l a s s e (" 17 ") > > > p r i n t( m o n _ o b j e t ) < _ _ m a i n _ _ . M a C l a s s e o b j e c t at 0 x 0 5 1 D 5 D F 0 >
M´ethodes sp´eciales > > > c l a s s M a C l a s s e (o b j e c t) : def _ _ i n i t _ _ ( self , v a l e u r ) : s e l f . u n _ a t t r i b u t = v a l e u r def _ _ s t r _ _ ( s e l f ) : p r i n t(" I n s t a n c e de M a C l a s s e ( v a l e u r de u n _ a t t r i b u t = {}) ". f o r m a t( s e l f . u n _ a t t r i b u t ) > > > m o n _ o b j e t = M a C l a s s e (" 17 ") > > > p r i n t( m o n _ o b j e t ) I n s t a n c e de M a C l a s s e ( v a l e u r de u n _ a t t r i b u t = 17)
M´ethodes sp´eciales
Quelques m´ethodes sp´eciales :
• str () : appel´ee suite `a un : print(objet). • add () : pour pouvoir ´ecrire : objet1 + objet2. • eq () : permet de comparer deux objets : objet1 ==
objet2.
• ne () : permet de tester si deux objets sont diff´erents : objet1 != objet2.
• len () : pour pouvoir calculer la longueur d’un objet : len(objet).
Port´ee des objets
`
A quel moment la fonction del () (destructeur ) est-elle appel´ee ?
• quand on l’appelle explicitement
• lorsque le contexte local est d´etruit (par exemple `a la fin d’une fonction)
Port´ee des objets
`
A quel moment la fonction del () (destructeur ) est-elle appel´ee ?
• quand on l’appelle explicitement
• lorsque le contexte local est d´etruit (par exemple `a la fin d’une fonction)
L’h´eritage
L’h´eritage
L’h´eritage
L’h´eritage
• Principe permettant de cr´eer une classe `a partir d’une autre. • Nom de la classe m`ere entre paranth`eses lors de la d´efinition. • M´ethodes et attributs de la classe m`ere transmis `a la classe
fille. c l a s s C l a s s e M e r e (o b j e c t) : ... ... c l a s s C l a s s e F i l l e ( C l a s s e M e r e ) : ... ...
L’h´eritage > > > c l a s s C l a s s e M e r e (o b j e c t) : def u n e _ m e t h o d e ( s e l f ) : p r i n t(" Je s u i s d a n s la c l a s s e m `e re ") > > > c l a s s C l a s s e F i l l e ( C l a s s e M e r e ) : p a s s > > > C l a s s e F i l l e () . u n e _ m e t h o d e () Je s u i s d a n s la c l a s s e m `e re
L’h´eritage
Un objet de la classe fille peut appeler une m´ethode ou un attribut de la classe m`ere : > > > c l a s s C a n a r d (o b j e c t) : def _ _ i n i t _ _ ( s e l f ) : s e l f . c o u l e u r = " j a u n e " > > > c l a s s C a n a r d Y o d a ( C a n a r d ) : def _ _ i n i t _ _ ( self , c o u l e u r ) : C a n a r d . _ _ i n i t _ _ ( s e l f ) s e l f . c o u l e u r = c o u l e u r # A p p e l l e l ’ a t t r i b u t c o u l e u r d ´e f i n i d a n s la c l a s s e m `e re > > > C a n a r d . c o u l e u r ’ j a u n e ’ > > > C a n a r d Y o d a (" v e r t ") . c o u l e u r ’ v e r t ’
Le polymorphisme
Principe permettant de donner plusieurs d´efinitions `a une m´ethode. En programmation orient´ee objet, cela se traduit par :
• la possibilit´e de red´efinir une m´ethode d’une classe m`ere dans une classe fille
• le fait que Python se charge de trouver la bonne m´ethode `a utiliser
Le polymorphisme > > > c l a s s C l a s s e M e r e (o b j e c t) : def u n e _ m e t h o d e ( s e l f ) : p r i n t(" Je s u i s d a n s la c l a s s e m `e re ") > > > c l a s s C l a s s e F i l l e ( C l a s s e M e r e ) : def u n e _ m e t h o d e ( s e l f ) : p r i n t(" Je s u i s d a n s la c l a s s e f i l l e ") > > > C l a s s e M e r e () . u n e _ m e t h o d e () Je s u i s d a n s la c l a s s e m `e re > > > C l a s s e F i l l e () . u n e _ m e t h o d e () Je s u i s d a n s la c l a s s e f i l l e
L’encapsulation
Un arbre est compos´e de : • un tronc
• des branches • des brindilles • des feuilles
Quand on parle d’un arbre, on sait qu’il contient toutes ces parties mais on ne le d´etaille pas.
L’encapsulation
Un arbre est compos´e de : • un tronc
• des branches • des brindilles • des feuilles
Quand on parle d’un arbre, on sait qu’il contient toutes ces parties mais on ne le d´etaille pas.
L’encapsulation
Un arbre est compos´e de : • un tronc
• des branches • des brindilles • des feuilles
Quand on parle d’un arbre, on sait qu’il contient toutes ces parties mais on ne le d´etaille pas.
L’encapsulation
Principe visant `a cacher les d´etails de l’impl´ementation `a l’utilisateur : les attributs de chaque classe doivent ˆetre priv´es, c’est-`a-dire inaccessibles en dehors de la classe. En Python cette notion n’existe pas : tout est public. Par convention on ajoutera un “ ” avant chaque attribut pour faire comme s’il ´etait priv´e.
L’encapsulation
> > > c l a s s M a C l a s s e (o b j e c t) :
def _ _ i n i t _ _ ( self , valeur1 , v a l e u r 2 ) : s e l f . a t t r i b u t _ p u b l i c = v a l e u r 1 s e l f . _ a t t r i b u t _ p r i v e = v a l e u r 2
Lecture/´ecriture d’attributs
Comment lire/´ecrire les valeurs des attributs priv´es ?
On utilise des m´ethodes sp´ecifiques. On les appellent des getter (pour lire une valeur) et des setter (pour changer une valeur).
Lecture/´ecriture d’attributs
> > > c l a s s C a n a r d (o b j e c t) :
def _ _ i n i t _ _ ( self , couleur , t a i l l e ) : s e l f . _ c o u l e u r = c o u l e u r s e l f . _ t a i l l e = t a i l l e def g e t _ c o u l e u r ( s e l f ) : r e t u r n s e l f . _ c o u l e u r def s e t _ c o u l e u r ( self , c o u l e u r ) : s e l f . _ c o u l e u r = c o u l e u r > > > c a n a r d = C a n a r d (" j a u n e ", 5) > > > c a n a r d . s e t _ c o u l e u r (" v e r t ") > > > c a n a r d . g e t _ c o u l e u r () ’ v e r t ’
Id´ee g´en´erale
Ce que veut l’utilisateur : • Appuyer sur un bouton • Mettre de l’argent
• R´ecup´erer son soda/snack Ce que l’utilisateur ne voit pas :
• Interpr´etation de la commande • V´erification du paiement • Donner le soda/snack
Id´ee g´en´erale
Ce que veut l’utilisateur : • Appuyer sur un bouton • Mettre de l’argent
• R´ecup´erer son soda/snack
Ce que l’utilisateur ne voit pas : • Interpr´etation de la commande • V´erification du paiement • Donner le soda/snack
Id´ee g´en´erale
Ce que veut l’utilisateur : • Appuyer sur un bouton • Mettre de l’argent
• R´ecup´erer son soda/snack Ce que l’utilisateur ne voit pas :
• Interpr´etation de la commande • V´erification du paiement • Donner le soda/snack
Les classes abstraites
Une classe abstraite est une classe qui ne peut ˆetre instanci´ee. C’est une notion qui est difficile `a mettre en œuvre en Python.
Les classes abstraites
c l a s s M a C l a s s e A b s t r a i t e (o b j e c t) :
def _ _ i n i t _ _ ( self , param1 , p a r a m 2 . . . ) :
r a i s e N o t I m p l e m e n t e d E r r o r def m e t h o d e 1 ( self , p a r a m . . . ) : # m e t h o d e 1 est une m ´e t h o d e a b s t r a i t e r a i s e N o t I m p l e m e n t e d E r r o r def m e t h o d e 2 ( self , p a r a m . . . ) : # m e t h o d e 2 est une m ´e t h o d e c o n c r `e te : on l ’ i m pl ´e m e n t e ici
Les classes abstraites c l a s s A n i m a l (o b j e c t) : def _ _ i n i t _ _ ( s e l f ) : r a i s e N o t I m p l e m e n t e d E r r o r def m a n g e r () : # m e t h o d e a b s t r a i t e r a i s e N o t I m p l e m e n t e d E r r o r c l a s s C a n a r d ( A n i m a l ) : def _ _ i n i t _ _ ( self , c o u l e u r ) : s e l f . _ c o u l e u r = c o u l e u r def m a n g e r ( i n g r e d i e n t ) : # m e t h o d e c o n c r `e te ...
Diff´erences abstraction/encapsulation
Quelles sont les diff´erences entre abstraction et encapsulation ?
Diff´erences abstraction/encapsulation
Quelles sont les diff´erences entre abstraction et encapsulation ?
Diff´erences abstraction/encapsulation
Abstraction Encapsulation • G´en´eralisation • Structuration • Cache les donn´ees /
struc-tures pour mettre en avant les id´ees
• Cache les d´etails de l’impl´ementation
• Se concentrer sur ce que fait un objet et pas sur comment il le fait
• cache les d´etails / m´echanismes utilis´es par l’objet
