Introduction à la programmation Python

Programmation orientée objet

Solemane Coulibaly

27 avril
Plan

1 Classe

2 Héritage

3 Encapsulation

4 Polymorphisme

5 Classe abstraite

6 Compléments

7 dataclasses

Solemane Coulibaly Introduction à la programmation Python 27 avril 2 / 59

Présentation
Dans les programmes décrit jusqu’à maintenant, les notions
données décrit par les variables/types de variables
et les traitements sur ces données
sont séparées

Figure – Programmation impérative/procédurale

Solemane Coulibaly Introduction à la programmation Python 27 avril 3 / 59

1 def surface ( largeur , longueur ) :
2 return largeur * longueur ;
3
4 if __name__ == " __main__ " :
5 largeur = 3.0;
6 longueur = 2.0;
7 print ( " surface du rectangle : " , surface ( largeur , longueur ) )
8
9
10 }

Solemane Coulibaly Introduction à la programmation Python 27 avril 4 / 59

Présentation
Objet

Nous allons maintenant utiliser des outils pour organiser ces

programmes de façon plus efficace.
C’est l’un des objectifs principaux de la notion d’objet.
Les objets permettent de mettre en œuvre dans les programmes les
notions :
d’encapsulation
d’abstraction
d’héritage
et de polymorphisme

Solemane Coulibaly Introduction à la programmation Python 27 avril 5 / 59

Encapsulation

Le principe d’encapsulation permet de regrouper dans un même objet

informatique, les données et les traitements qui leurs sont spécifiques :
Attributs : les données incluses dans les objets.
Méthodes : fonctions (= traitements) définies dans les objets.

Un objet est défini par ses attributs et méthodes.

Solemane Coulibaly Introduction à la programmation Python 27 avril 6 / 59

Encapsulation

Figure –

Solemane Coulibaly Introduction à la programmation Python 27 avril 7 / 59

Abstraction

Un objet doit permettre un certain degré d’abstraction.

Le processus d’abstraction permet de regrouper pour un ensemble
d’éléments :
I Regroupe les caractéristiques communes à un ensemble d’éléments.
I Définit des mécanismes communs à ces éléments.

Solemane Coulibaly Introduction à la programmation Python 27 avril 8 / 59

Abstraction

Le processus d’abstraction permet de se focaliser sur l’essentiel.

Exemple : L’objet Rectangle

L’objet Rectangle n’a de sens que s’il possède des propriétés et des
mécanismes généraux.
Attributs : Les propriétés largeur et longueur sont communes à tous
les rectangles, et non à un rectangle particulier.
Méthodes : Le mécanisme permettant de calculer la surface d’un
rectangle (surface = largeur × longueur ) est commun à tous les
rectangles.

Solemane Coulibaly Introduction à la programmation Python 27 avril 9 / 59

Abstraction
Classe vs Objet 1

1. EPFL programmation orienté objet en java

Solemane Coulibaly Introduction à la programmation Python 27 avril 10 / 59
Définition

le résultat du processus d’abstraction s’appelle une classe

classe = catégorie d’objets
une classe définit un type (au sens du langage de programmation)
une réalisation particulière d’une classe s’appelle une instance
instance = objet

Solemane Coulibaly Introduction à la programmation Python 27 avril 11 / 59

Définition

Les classes sont un moyen de réunir des données et leurs traitement.

Créer une nouvelle classe crée un nouveau type d’objet et
Nous pouvons construire de nouvelles instances de ce type d’objet.
Une instance peut avoir ses propres attributs, ce qui définit son état.
Une instance peut aussi avoir des méthodes (définies par la classe de
l’instance) pour modifier son état.

Solemane Coulibaly Introduction à la programmation Python 27 avril 12 / 59

 Les classes en Python

En Python une classe se déclare par le mot-clé class.

Exemple :
1 class MaClass :
2 ''' This is a docstring . I have created a new class '''

L’initialisation d’une instance d’une classe se fait de la façon similaire à la

initialisation d’une variable classique :
1 nom_instance = MaClass ()

Exemple :
1 obj1 = MaClass () ;

déclare une instance obj1 de la classe MyClass.

Solemane Coulibaly Introduction à la programmation Python 27 avril 13 / 59

 Attributs d’objet

class Point :
''' definition d ' une classe de
point '''

Solemane Coulibaly Introduction à la programmation Python 27 avril 14 / 59

 Attributs d’objet

class Point :
''' definition d ' une classe de
point '''

>>> p1 = Point ()
>>> p1 . x = 3.5
>>> p1 . y = 4.0
>>> print ( p1 . x )
3.5
>>> print ( p1 . x **2 + p1 . y **2)
28.25

Solemane Coulibaly Introduction à la programmation Python 27 avril 14 / 59

 Attributs d’objet

class Point : 1 class Rectangle :

''' definition d ' une classe de 2 ''' definition d ' une classe
point ''' de rectangle '''

>>> p1 = Point () 1 >>> rect = Rectangle ()

>>> p1 . x = 3.5 2 >>> rect . longueur = 50.0
>>> p1 . y = 4.0 3 >>> rect . largeur = 30.0
>>> print ( p1 . x ) 4 >>> rect . coin = Point ()
3.5 5 >>> rect . coin . x = 12.0
>>> print ( p1 . x **2 + p1 . y **2) 6 >>> rect . coin . y = 27.0
28.25
La notion d’« objet Point »n’est
>>> p2 = Point () intéressante que si l’on peut lui
>>> p2 . z = 12 associer des propriétés (attributs)
>>> dir ( p1 ) et/ou mécanismes généraux
[ 'x ' , 'y ']
>>> dir ( p2 ) (méthodes).
[ 'z ']

Solemane Coulibaly Introduction à la programmation Python 27 avril 14 / 59

 Attributs d’instances
Comment réserver de l’espace pour les attributs et les comment initialiser
(i.e. leur attribuer des valeurs) ?

+ nous pouvons utiliser un constructeur.

+ le nom imposé Python à cet effet : __init__().

C’est la méthode d’initialisation qui est exécutée en premier dès que l’objet
est créé.

1 class Person :
2 def __init__ ( self , name , age ) :
3 self . name = name
4 self . age = age

1 >>> p = Person ( ' Toto ' , 10)

2 >>> print ( p . name )
3 Toto
4 >>> p . name = ' Amara '
5 >>> print ( p . name )
6 AmaraSolemane Coulibaly Introduction à la programmation Python 27 avril 15 / 59
 Attributs d’instances
Comment réserver de l’espace pour les attributs et les comment initialiser
(i.e. leur attribuer des valeurs) ?

+ nous pouvons utiliser un constructeur.

+ le nom imposé Python à cet effet : __init__().

C’est la méthode d’initialisation qui est exécutée en premier dès que l’objet
est créé.

1 class Person :
2 def __init__ ( self , name , age ) :
3 self . name = name
4 self . age = age
L’initialisation des attributs name et age sont obligatoire.
1 >>> p = Person ( ' Toto ')
2 Traceback ( most recent call last ) :
3 File " < stdin > " , line 1 , in < module >
4 TypeError : __init__ () missing 1 required positional
argument
Solemane Coulibaly : ' age ' Introduction à la programmation Python 27 avril 15 / 59
 Afficher un objet

Lorsque vous utilisez la fonction print() pour afficher l’instance de la

classe, la fonction elle,affiche l’adresse mémoire de cette instance.
1 class Personne :
2 def __init__ ( self , nom , age , email ) :
3 self . nom = nom
4 self . age = age
5 self . email = email
6
7 >>> person = Personne ( ' Amara ' , ' Diallo ' , 25)
8 >>> print ( person )
9 < __main__ . Personne object at 0 x7f8550264820 >

__str__ ou __repr__ sont utilisées par print pour l’affichage ;

elles renvoient une représentation sous forme de chaîne ;
__repr__ est utilisée par print si __str__ n’est pas définie.

Solemane Coulibaly Introduction à la programmation Python 27 avril 16 / 59

 Classes
Exemple

1 class Personne :
2 def __init__ ( self , nom , age , email ) :
3 self . nom = nom
4 self . age = age
5 self . email = email
6 def __repr__ ( self ) :
7 return f " { self . nom } , { self . age } ans , email :{ self . email } "

Solemane Coulibaly Introduction à la programmation Python 27 avril 17 / 59

 Classes
Exemple

1 class Personne :
2 def __init__ ( self , nom , age , email ) :
3 self . nom = nom
4 self . age = age
5 self . email = email
6 def __repr__ ( self ) :
7 return f " { self . nom } , { self . age } ans , email :{ self . email } "

1 if __name__ == ' __main__ ':

2 personnes = [
3 Personne ( ' pierre ' , 25 , ' pierre@foo . com ') ,
4 Personne ( nom = ' paul ' , age =18 , email = ' paul@bar . com ') ,
5 Personne ( ' bouba ' , 52 , email = ' bouba@cool . com ')
6 ]
7 for personne in personnes :
8 print ( personne )

Solemane Coulibaly Introduction à la programmation Python 27 avril 17 / 59

 Classes
Méthodes d’instance

La syntaxe de la définition d’une méthodes d’une classe est similaire à

d’une fonction
1 def nom_methode ( self , param1 , param2 , ...) :
2 # corps de la methode ...

De plus, a pas besoin de passer les attributs de la classe comme arguments

aux méthodes de cette classe.
1 class Person :
2 def __init__ ( self , name , age ) :
3 self . name = name
4 self . age = age
5
6 def greet ( self ) :
7 return f ' Hello { self . name } '

Solemane Coulibaly Introduction à la programmation Python 27 avril 18 / 59

 Classes
Méthodes d’instance

L’appel aux méthodes définies pour une instance de nom nom_instance se

fait à l’aide d’expressions de la forme :
nom_instance.nom_methode(val_arg1,...)

1 >>> p = Personne ( ' Toto ' , 25)

2 >>> print ( person . greet () )
3 Hello Toto

Solemane Coulibaly Introduction à la programmation Python 27 avril 19 / 59

 Les classes
Attribut de classe

Contrairement aux attributs d’instance, les attributs de classe sont

partagés par toutes les instances de la classe.
Ils sont utiles si vous souhaitez définir des constantes de classe ou des
variables qui gardent une trace du nombre d’instances d’une classe.
Syntaxe :
1 class MaClass :
2 attribut = valeur

L’accès aux attributs de classe se fait par l’une des instruction suivante :
1 instance . attribut # ou
2 MaClass . attribut # ou
3 intance . __class__ . name

Solemane Coulibaly Introduction à la programmation Python 27 avril 20 / 59

 Les classes
Attribut de classe

Exemple :
1 class Personne :
2 counter = 0
3
4 def __init__ ( self , name , age ) :
5 self . name = name
6 self . age = age
7 Personne . counter += 1
8
9 def greet ( self ) :
10 return f " Hello { self . name } "
11
12 if __name__ == ' __main__ ':
13 p1 = Personne ( ' Toto ' , 21)
14 p2 = Personne ( ' Nana ' , 20)
15 print ( Personne . counter )
16 print ( p2 . counter )

Solemane Coulibaly Introduction à la programmation Python 27 avril 21 / 59

 Attribut de classe
Les attributs de classe sont les mêmes pour toutes les instances d’une
classe que nous venons de créer.
1 class Person :
2 hobbie = ' Action ' # class variable shared by all instances
3 def __init__ ( self , name ) :
4 self . name = name
5
6 >>> p1 = Person ( ' Toto ')
7 >>> p2 = Person ( ' Amara ')
8 >>> p1 . hobbie
9 ' Action '
10 >>> p2 . hobbie
11 ' Action '
12 >>> p1 . name # unique a p1
13 ' Toto '
14 >>> p2 . name # unique a p2
15 ' Amara '

Solemane Coulibaly Introduction à la programmation Python 27 avril 22 / 59

 Attribut de classe
Les attributs de classe sont les mêmes pour toutes les instances d’une
classe que nous venons de créer.
Les données partagées (telles que les listes, dictionnaires, etc.) peuvent avoir
des effets surprenants
1 class Person :
2 name = ' Inconnu '
3 hobbies = [] # utilisation erronee d ' une variable de classe
4 def __init__ ( self , name ) :
5 self . name = name
6 def add_hobbies ( self , hobbie ) :
7 self . hobbies . append ( hobbie )
8
9 >>> p1 = Person ( ' Toto ')
10 >>> p2 = Person ( ' Amara ')
11 >>> p1 . add_hobbies ( ' Aventure ')
12 >>> p2 . add_hobbies ( ' Escalde ')
13 >>> print ( p1 . hobbies )
14 [ ' Aventure ' , ' Escalde ']

Solemane Coulibaly Introduction à la programmation Python 27 avril 22 / 59

Attribut de classe vs attribut d’instance

Les attributs de classes sont des variables créées au sein de la classe (en
dehors de toute méthode).

+ Elles contiennent des propriétés générales à la classe puisqu’ils vont

prendre la même valeur quelle que soit l’instance (objet).

Solemane Coulibaly Introduction à la programmation Python 27 avril 23 / 59

Attribut de classe vs attribut d’instance

Les attributs de classes sont des variables créées au sein de la classe (en
dehors de toute méthode).

+ Elles contiennent des propriétés générales à la classe puisqu’ils vont

prendre la même valeur quelle que soit l’instance (objet).

Les attributs d’instance sont spécifiques à chaque instance.

+ Pour en créer, il suffisait de les initialiser dans la méthode __init__()

en utilisant avec la syntaxe [Link] = valeur.
"Nous pouvait ajouter un attribut d’instance de l’extérieur avec une
syntaxe instance.nouvel_attribut = valeur (non recommandé).

Solemane Coulibaly Introduction à la programmation Python 27 avril 23 / 59

 Mécanisme de surcharges de méthodes

Pas de surcharge du constructeur (ou des méthodes) + Construire des

initialiseurs d’objets flexibles
1 # greet . py
2 class Greeter :
3 def __init__ ( self , name , formal = False ) :
4 self . name = name
5 self . formal = formal
6
7 def greet ( self ) :
8 if self . formal :
9 print ( f " Good morning , { self . name }! " )
10 else :
11 print ( f " Hello , { self . name }! " )

Solemane Coulibaly Introduction à la programmation Python 27 avril 24 / 59

 Méthode de classe
Une méthode de classe peut partagée par toutes les instances de la classe.
Cette méthode est appelé sans utilisé une instance de la classe.
Nous utilisons le décorateur@classmethod pour décorer une méthode de
classe.

1 class Personne :
2 ...
3
4 def greet ( self ) :
5 return f " Hello { self . name }. "
6
7 @classmethod
8 def create_anonymous ( cls ) :
9 return Personne ( ' Anonymous ' , 22)
10
11 if __name__ == ' __main__ ':
12 anonymous = Personne . create_anonymous ()
13 print ( anonymous . name ) # Anonymous

Solemane Coulibaly Introduction à la programmation Python 27 avril 25 / 59

Classe
La méthode statique

Les méthodes d’instance sont liées à une instance spécifique + les

méthodes d’instance peuvent accéder à l’état de l’objet lié et le modifier.

Les méthodes de classe qui sont liées à une classe + les méthodes de
classe peuvent accéder à l’état de la classe et le modifier.

Contrairement aux méthodes d’instance, les méthodes statiques ne sont

pas liées à un objet. + elle ne peuvent pas accéder à l’état d’un objet ni le
modifier.

Solemane Coulibaly Introduction à la programmation Python 27 avril 26 / 59

 Classe
La méthode statique

Une méthode statique n’est pas liée à une classe ou à des instances de la
classe. Pour définir une méthode statique, nous allons utilisez le décorateur
@staticmethod.
Syntaxe de déclaration :
1 class MaClass :
2 @staticmethod
3 def ma_meth ode_s tatic ( param1 , ...) :
4 ...

Pour appeler une méthode statique :

1 MaClass . ma_meth ode_static ( arg1 , ...)

Solemane Coulibaly Introduction à la programmation Python 27 avril 27 / 59

 Classe
La méthode statique

1 class Temp e r a t u r e C o n verter :

2 @staticmethod
3 def cels i u s _ t o _ f a h renh eit ( c ) :
4 return 9 * c / 5 + 32
5
6 @staticmethod
7 def fahr e n h e i t _ t o _ cels ius ( f ) :
8 return 5 * ( f - 32) / 9
9
10
11
12 if __name__ == ' __main__ ':
13 print ( Te m p e r a t u r e C onverter . cel sius_ to_f ahre nheit (25) ) #
Output : 77.0

Solemane Coulibaly Introduction à la programmation Python 27 avril 28 / 59

 Héritage
L’héritage est un moyen de créer une nouvelle classe pour utiliser les
détails d’une classe existante sans la modifier.
Exemple :
1 class Personne :
2 pass
3
4 class Employee ( Personne ) :
5 pass

La classe Personne est la classe parent, la classe de base ou la super classe

de la classe Employe.
Et la classe Employe est une classe enfant (ou fille), une classe dérivée ou
une sous-classe de la classe Personne.
Syntaxe :
1 class DerivedClassName ( BaseClassName ) :
2 pass

Solemane Coulibaly Introduction à la programmation Python 27 avril 29 / 59

 Héritage
Si vos sous-classes fournissent une méthode __init__(),
+ alors cette méthode doit appeler explicitement la méthode __init__()
de la classe de base + avec les arguments appropriés pour garantir
l’initialisation correcte des instances.

Pour ce faire, vous devez utiliser la fonction intégrée super() :

1 super () . __init__ ( arg1 , arg2 , ...)

1 class Person :
2 def __init__ ( self , name , birth_date ) :
3 self . name = name
4 self . birth_date = birth_date
5 class Employe ( Person ) :
6 def __init__ ( self , name , birth_date , position ) :
7 super () . __init__ ( name , birth_date )
8 self . position = position

Solemane Coulibaly Introduction à la programmation Python 27 avril 30 / 59

 Héritage
Appel à la classe de base avec super()

1 class Person :
2 def __init__ ( self , name , birth_date ) :
3 self . name = name
4 self . birth_date = birth_date
5 class Employee ( Person ) :
6 def __init__ ( self , name , birth_date , position ) :
7 super () . __init__ ( name , birth_date )
8 self . position = position
9
10 >>> john = Employee ( " John Doe " , " 2001 -02 -07 " , " Python
Developer " )
11 >>> john . name
12 ' John Doe '
13 >>> john . birth_date
14 ' 2001 -02 -07 '
15 >>> john . position
16 ' Python Developer '

Solemane Coulibaly Introduction à la programmation Python 27 avril 31 / 59

 Héritage
Appel à la classe de base avec super()

1 class Personne :
2 # ...
3 def affiche ( self ) :
4 print ( f '{ self . name } nee le { self . birth_date } ')
5
6 class Employe ( Personne ) :
7 # ...
8 def affiche ( self ) :
9 super () . affiche ()
10 print ( f ' occupe le poste { self . position } ')
11
12
13 >>> john = Employe ( " John Doe " , " 2001 -02 -07 " , " Python
Developer " )
14 >>> john . affiche ()
15 John Doe nee le 2001 -02 -07
16 occupe le poste Python Developer

Solemane Coulibaly Introduction à la programmation Python 27 avril 32 / 59

Héritage

Les classes dérivées peuvent surcharger des méthodes de la super classes.

Une méthode dans une classe dérivée peut aussi, en fait, vouloir étendre
plutôt que remplacer la méthode du même nom de la super classe.
L’appel direct à la méthode de la classe de base s’écrit simplement
[Link](self, arg1, arg2, ...).

Solemane Coulibaly Introduction à la programmation Python 27 avril 33 / 59

 Héritage
isinstance(), issubclass

1 class Personne :
2 pass
3
4 class Employe ( Personne ) :
5 pass

Pour vérifier si un objet est une instance d’une classe, nous utilisons la
fonction isinstance() plutôt que la fonction type() :
1 print ( type ( emp ) ) # < class ' __main__ . Employe '>
2 print ( " L ' objet emp est - il une employ 'e ? " , isinstance ( emp ,
Employe ) ) # True
3 print ( " L ' objet emp est - il une personne ? " , isinstance ( emp ,
Personne ) ) # Trye

Solemane Coulibaly Introduction à la programmation Python 27 avril 34 / 59

 Héritage
isinstance(), issubclass

1 class Personne :
2 pass
3
4 class Employe ( Personne ) :
5 pass

Pour vérifier si une classe est une sous-classe d’une autre, nous utilisons la
fonction issubclass() :
1 print ( issubclass ( Employe , Personne ) ) # True

+Lorsque vous définissez une classe qui n’hérite d’aucune classe, elle héri-
tera implicitement de la classe objet intégrée.
1 print ( issubclass ( Person , object ) ) # True

Solemane Coulibaly Introduction à la programmation Python 27 avril 34 / 59

 Héritage
isinstance(), issubclass

Pour vérifier si un objet est une instance d’une classe, nous utilisons la
fonction isinstance().
Pour vérifier si une classe est une sous-classe d’une autre, nous utilisons la
fonction issubclass().
1 class DevEmploye ( Employe ) :
2 pass

1 dev = DevEmploye ()
2 print ( isinstance ( dev , Employe ) ) # True
3 print ( isinstance ( dev , Personne ) ) # True
4
5 print ( issubclass ( DevEmploye , Employe ) ) # True
6 print ( issubclass ( DevEmploye , Personne ) ) # True

Solemane Coulibaly Introduction à la programmation Python 27 avril 35 / 59

Encapsulation

L’encapsulation est le regroupement de données et de leurs traitements un

seul objet. Ce faisant, vous pouvez masquer l’état interne de l’objet de
l’extérieur.

+ L’idée du masquage est que, si vous avez un attribut (une méthode) qui
n’est pas visible de l’extérieur alors vous pouvez contrôler l’accès à sa
valeur pour vous assurer que votre objet a toujours un état valide.

Alors, comment empêchez la modification de vos attributs (vps méthodes)

en dehors de la classe :
+ en déclaration ces attributs (méthodes) comme privés.
+ Les attributs privés ne peuvent être accessibles qu’à partir des
méthodes de la classe qui sont public.

Solemane Coulibaly Introduction à la programmation Python 27 avril 36 / 59

Encapsulation
Les membres privés (attributs ou méthodes), qui ne peuvent être accédés
que depuis l’intérieur d’un objet, ne sont pris en charge par Python

Solemane Coulibaly Introduction à la programmation Python 27 avril 37 / 59

 Encapsulation
Les membres privés (attributs ou méthodes), qui ne peuvent être accédés
que depuis l’intérieur d’un objet, ne sont pris en charge par Python +
toutefois, nous pouvons définir un attribut privé en préfixant un seul trait
de soulignement comme ceci :
1 _attribut

1 class Personne :
2 def __init__ ( self , name ) :
3 self . _name = name
4 def get_name ( self ) :
5 return self . _name
6 def set_name ( self , name ) :
7 self . _name = name

1 >>> print ( p . get_name () )

2 Amara
3 >>> p . set_name ( ' Toto ')
4 >>> print ( p . get_name () )
5 Toto
Solemane Coulibaly Introduction à la programmation Python 27 avril 37 / 59
 Encapsulation

Vous pouvez préfixez un nom d’attribut avec des traits de soulignement

doubles (__) comme ceci :
1 __attribut

Python changera automatiquement le nom de l’attribut __attribut en :

1 _class__at tribu te

" nous ne pouvons pas accéder à l’attribut __attribut depuis l’extérieur :

1 moninstance . __attribut # provoque une exception type
AttributeError

Mais plutôt
1 instance . _ N o m D e M a C l a s s e _ _ a t t r i b u t e

Solemane Coulibaly Introduction à la programmation Python 27 avril 38 / 59

 Encapsulation

1 class Personne :
2 def __init__ ( self , name ) :
3 self . __name = name
4 def get_name ( self ) :
5 return self . __name
6 def set_name ( self , name ) :
7 self . __name = name

1 >>> p = Personne ( ' Amara ')

2 >>> print ( p . __name )
3 AttributeError : ' Personne ' object has no attribute ' __name '
4 >>> print ( p . _Personne__name )
5 Amara
6 >>> p . _Personne__name = ' Sali '
7 >>> print ( p . get_name () )
8 Sali

Solemane Coulibaly Introduction à la programmation Python 27 avril 39 / 59

 Encapsulation

1 class Point : 1 a = Point (3 , 7)

2 def __init__ ( self , x , y ) : 2 print ( " a : abscisse =", a.
3 self . __x = x get_x () )
4 self . __y = y 3 print ( " a : ordonnee =", a.
5 get_y () )
6 def get_x ( self ) : 4 a . set_x (6)
7 return self . __x 5 a . set_y (10)
8 6 print ( " a : abscisse =", a.
9 def set_x ( self , x ) : get_x () )
10 self . __x = x 7 print ( " a : ordonnee =", a.
11 get_y () )
12 def get_y ( self ) :
13 return self . __y
14
15 def set_y ( self , y ) :
16 self . __y = y

Solemane Coulibaly Introduction à la programmation Python 27 avril 40 / 59

 Utilisation des propriétés (@property)
Python propose une façon plus élégante de définir des accesseurs et des
mutateurs à l’aide du décorateur @property.

1 class Point : 1 a = Point (3 , 7)

2 def __init__ ( self , x , y ) : 2 print ( " a : abscisse =", a.x)
3 self . __x = x 3 print ( " a : ordonnee =", a.y)
4 self . __y = y 4 a.x = 6
5 @property 5 a . y = 10
6 def x ( self ) : 6 print ( " a : abscisse =", a.x)
7 return self . __x 7 print ( " a : ordonnee =", a.y)
8 @x . setter
9 def x ( self , x ) :
0 self . __x = x
1 @property
2 def y ( self ) :
3 return self . __y
4 @y . setter
5 def y ( self , y ) :
6 self . __y = y

Solemane Coulibaly Introduction à la programmation Python 27 avril 41 / 59

Polymorphisme

Le polymorphisme est un mécanisme important dans la

programmation objet.
Il permet de modifier le comportement d’une classe fille par rapport à
sa classe mère.
Le polymorphisme permet d’utiliser lhéritage comme un mécanisme
d’extension en adaptant le comportement des objets.

Solemane Coulibaly Introduction à la programmation Python 27 avril 42 / 59

 Polymorphisme
1 class Person :
2 # ...
3
4 def hello ( self ) :
5 print ( ' je suis la classe base ')
6
7 class Employee ( Person ) :
8 # ...
9
10 def hello ( self ) :
11 print ( ' je suis la classe fille ')

1 def test ( foo ) :

2 print ( foo . hello () )

1 >>> p1 = Employee (...)

2 >>> p2 = Person (...)
3 >>> test ( p1 )
4 >>> test ( p2 )
5
6 je suis la classe fille
7 je suis la classe base
Solemane Coulibaly Introduction à la programmation Python 27 avril 43 / 59
Classe abstraite

Une classe abstraite est une classe dont certaines méthodes ne sont pas
implémentées. Une classe abstraite ne peut pas être instanciée.

Vous pouvez créer des classes qui héritent d’une classe abstraite. Elle
deviennent abstraites à leur tour sauf si elles implémentent toutes les
méthode abstraites.

(schéma : : : FormaGeometrique : : méthode surface et perimètre)

(schéma : : Triangle(FormeGeo) Rectange(FormeGeo))
(Employe : : : : Employe Plein Temps, Employé Par heure)

Solemane Coulibaly Introduction à la programmation Python 27 avril 44 / 59

 Classe abstraite

Syntaxe :
1 from abc import ABC
2
3 class MaCla sseAbs traite ( ABC ) :
4 pass

Pour définir une méthode abstraite, nous utilisons le décorateur

@abstractmethod :
1 from abc import ABC , abstractmethod
2
3 class MaCla sseAbs traite ( ABC ) :
4 @abstractmethod
5 def ma_m e t ho d _ ab s t raite ( self ) :
6 pass

Solemane Coulibaly Introduction à la programmation Python 27 avril 45 / 59

 Classe abstraite
Une entreprise compte deux groupes d’employés : les employés à temps
plein et les employés à l’heure. Les employés à temps plein reçoivent un
salaire fixe tandis que les employés horaires sont payés à l’heure pour leurs
services.

1
2 class Employee ( ABC ) :
3 ...
4 @abstractmethod
5 def get_salary ( self ) :
6 pass

1 class FulltimeEmploye ( Employee ) :

2 ...
3 def get_salary ( self ) :
4 return self . salary

1 class HourlyEmployee ( Employee ) :

2 def get_salary ( self ) :
3 return self . worked_hours * self . rate
Solemane Coulibaly Introduction à la programmation Python 27 avril 46 / 59
Opérateurs de surcharge

objet1 + objet2
item in objet
objet[key]
[Link]
for i in objet :
if objet :
objet(arg1, arg2) (et non pas classe(arg1, arg2))
etc..

Solemane Coulibaly Introduction à la programmation Python 27 avril 47 / 59

 dataclasses
Le decorateur dataclass permet de définir des classes avec moins de code
et plus de fonctionnalités.
Supposons la classe Personne avec deux attributs, name et age.
1 class Personne :
2 def __init__ ( self , nom , age ) :
3 self . name = name
4 self . age = age

Cette classe Personne a la méthode __init__() qui initialise les

attributs name et age.
Si vous souhaitez avoir une représentation sous forme de chaîne de
l’objet Personne, vous devez implémenter la méthode __str__ ou
__repr__.
De plus, si vous souhaitez comparer deux instances de la classe
Personne par un attribut, vous devez implémenter la méthode
__eq__.

Solemane Coulibaly Introduction à la programmation Python 27 avril 48 / 59

 dataclasses
La raison d’être du décorateur dataclass est de fournir automatiquement
ces méthodes spéciales. Il est introduit dans la version 3.7.
1 from dataclasses import dataclass
2 @dataclass
3 class Personne :
4 nom : str
5 age : int
Le décorateur @dataclass crée implicitement la méthode __init__ comme
ceci :
1 def __init__ ( name : str , age : int ) :
Je peux créer une Personne et l’afficher :
1 p1 = Person ( ' Nana ' , 25)
2 print ( p1 )
Si vous souhaitez comparer deux objets de type Personne :
1 p1 = Person ( ' Nana ' , 25)
2 p2 = Person ( ' Nana ' , 25)
3 print ( p1 == p2 ) # True
Solemane Coulibaly Introduction à la programmation Python 27 avril 49 / 59
 dataclasses
Attribut avec valeur par défaut

Pour définir une valeur par défaut pour un attribut dans la dataclass, vous
l’affectez à l’attribut comme ceci :
1 from dataclasses import dataclass
2
3 @dataclass
4 class Personne :
5 nom : str
6 age : int
7 email : str = " "
8
9 personne = Personne ( nom = ' jean ' , age =12)
10 print ( personne )

Les attributs avec les valeurs par défaut doivent apparaître après ceux sans
valeurs par défaut pour que le code fonctionne.

Solemane Coulibaly Introduction à la programmation Python 27 avril 50 / 59

 dataclasses
Classe d’attribut

1 from typing import ClassVar

2
3 @dataclass
4 class Personne :
5 nom : str
6 age : int
7 email : str = " "
8 c : ClassVar [ ini ]

1 p = Personne ( nom = ' Amara ' , age =12)

2 print ( Personne . __dict__ )

Solemane Coulibaly Introduction à la programmation Python 27 avril 51 / 59

 dataclasses

Call function après init

1 from dataclasses import dataclass
2
3 @dataclass
4 class Personne :
5 nom : str
6 age : int
7
8 def __post_init__ ( self ) :
9 self . full_name = f " { self . nom } a { self . age } "

1 p = Personne (....)
2 print ( p . full_name )

Solemane Coulibaly Introduction à la programmation Python 27 avril 52 / 59

 dataclasses
Instances non mutables

Le décorateur dataclass accepte divers arguments avec des valeurs par

défaut pour choisir le comportement de certains aspects dela classe. :
init=True, repr=True, eq=True, frozen=False
frozen=True et qui illustre la possibilité de créer des instances non
mutables.
1 from dataclasses import dataclass
2 @dataclass ( frozen = True )
3 class Point :
4 x : float
5 y : float

1 p = Point (3 ,4)

p.x = 10 génère une exception de :

1 File " < string > " , line 4 , in __setattr__
2 dataclasses . Fr o z en I n stanceError : cannot assign to field 'x '

Solemane Coulibaly Introduction à la programmation Python 27 avril 53 / 59

 dataclasse
Convertir une instance en un tuple ou un dictionnaire

Le module dataclasses dispose des fonctions astuple() et asdict() qui

convertissent une instance de la dataclass en un tuple et un dictionnaire.
1 p = Person ( ' John Doe ' , 25)
2
3 print ( astuple ( p ) ) # output : ( ' Diara ', 21)
4 print ( asdict ( p ) ) # output : { ' nom ': ' Diara ', ' age ': 21}

Solemane Coulibaly Introduction à la programmation Python 27 avril 54 / 59

 dataclasse
Personnaliser les comportements des attributs

Si vous ne souhaitez pas initialiser un attribut dans la méthode __init__,

vous pouvez utiliser la fonction field() du module dataclasses.
1 from dataclasses import dataclass , field
2 class Person :
3 name : str
4 age : int
5 email : str = " "
6 can_vote : bool = field ( init = False )

Solemane Coulibaly Introduction à la programmation Python 27 avril 55 / 59

 dataclasse
Trier les objets du dataclass

Par défaut, une dataclass autoriser les différents types de comparaisons

comme __lt__, __lte__, __gt__, __gte__. Pour cela, nous allons
définir l’argument order du décorateur @dataclass sur True :
1 @dataclass ( order = True )
2 class Personne :
3 ...
4
5 p1 = Personne ( ' Nana ' , 22)
6 p2 = Personne ( ' Toto ' , 20)
7 print ( p1 < p2 ) # compare les valeur Nana et Toto True

Solemane Coulibaly Introduction à la programmation Python 27 avril 56 / 59

dataclasse
Trier les objets du dataclass
Nous pouvons comparer des objets pas tous les attributs mais sur un
attribut en particulier :
1 passez le paramètre order=True au décorateur @dataclass

1 @dataclass ( order = True )

2 class Personne :
2 définissez l’attribut sort_index et définissez son paramètre init sur
False.
1 @dataclass ( order = True )
2 class Personne :
3 sort_index : int = field ( init = False )
4
5 name : str
6 age : int
3 définissez sort_index sur l’attribut à trier (ici l’âge) dans la méthode
__post_init__.
1 def __post_init__ ( self ) :
2 self . sort_index = self . age
Solemane Coulibaly Introduction à la programmation Python 27 avril 57 / 59
 dataclasse
Trier les objets du dataclass
1 from dataclasses import dataclass , field
2
3 @dataclass ( order = True )
4 class Personne :
5 sort_index : int = field ( init = False )
6 name : str
7 age : int
8
9 def __post_init__ ( self ) :
10 self . sort_index = self . age
11
12 if __name__ == ' __main__ ':
13 membres = [
14 Personne ( ' Nana ' , 22) , Personne ( ' Toto ' , 20) , Personne ( '
Diara ' , 21)
15 ]
16
17 sorted_membres = sorted ( membres )
18 for membre in sorted_membres :
19 print ( f '{ membre . name }( age ={ membre . age }) ')
Solemane Coulibaly Introduction à la programmation Python 27 avril 58 / 59
dataclasse
Résumons

Utilisez le décorateur @dataclass Utilisez frozen=True pour

du module dataclasses définir une classe dont les objets
L’objet dataclass implémente les sont non modifiables.
fonctions comme __eq__ et Utilisez la méthode
__str__ par défaut. __post_init__ pour initialiser
Les fonctions astuple() et les attributs qui dépendent
asdict() convertissent un objet d’autres attributs.
en un tuple et un dictionnaire. Utilisez sort_index pour
spécifier les attributs de tri

Solemane Coulibaly Introduction à la programmation Python 27 avril 59 / 59