2eme Chapitre2-POO v1.0 Imprimable

Plan
1. Introduction
2. Partie1: Première approche des Classes
a. Le Constructeurs
Module : Informatique
b. Attributs et méthodes de la classe
Classes: 2ème Années MP – PC –T
c. Le paramètre « self »
Chapitre 2 - Approche d. Méthodes de classe et Méthodes statiques
3. Partie2: Encapsulation et Héritage simple
Orientée Objet et a. Encapsulation: property
Programmation avec Python b. Héritage simple

c. La classe « Object »
Enseignant : Dr. Khemaies GHALI (ghali.khemaies@gmail.com) d. Deux fonctions très pratiques
Page Facebook: https://www.facebook.com/groups/ipein.info/
Année universitaire 2021/2022
IPEIN 2021/2022 2ème Année - Informatique - Chapitre 2 1/65 IPEIN 2021/2022 2ème Année - Informatique - Chapitre 2 2/65
Introduction (1/2) Introduction (2/2)

q La programmation orientée objet surgit dans les années 80, q La Programmation Orientée Objet « POO » est une discipline
q Logiciels de plus en plus complexes, donc travail en équipe, dans laquelle le programmeur établit:
Ø Contrôler la complexité des logiciels, Ø Non seulement les structures de données,
q Code réutilisable pour contenir les coûts du développement, Ø Mais aussi les opérations qui peuvent leurs être appliquées.
q Contenir les coûts de la maintenance : q Ainsi,
Ø Ajout de nouvelles fonctionnalités, Ø La structure de données devient un objet qui inclut:
Ø Modification de fonctionnalités existantes, vDonnées, appelées attributs,
Ø portage sur d'autres plateformes ou environnements. vOpérations, appelées méthodes.
q Coordonner et répartir le travail de développement, Ø Le programmeur peut définir des relations entre les objets.
q Modularité du code.
Pourquoi utiliser des objets ?
q Le langage C (inventé au début des années 1970) est parmi les
premiers langages de programmation n'incluaient pas l'orienté objet.
Ø Il aura fallu attendre le C++ (début 80) pour utiliser la puissance de
Partie 1: l'orienté objet dans une syntaxe proche de celle du C.
Première approche des q Java, un langage apparu à peu près en même temps que Python
(début des années 90), définit une philosophie assez différente de
classes celle du C++ :

Ø Le Java exige que tout soit rangé dans des classes!
q En Python, la liberté est plus grande. Après tout, vous avez pu
programmer en Python sans connaître sa façade objet!!!
Ø Et pourtant, le langage Python est totalement orienté objet : en
Python, tout est objet, une simple variable, un module, une
fonction. . ., ce sont des objets qui se cachent derrière!
Choix du modèle Déclaration d’une classe

q Une classe est un modèle suivant lequel on va créer des objets. q Pour définir une nouvelle classe, on utilise le mot-clé class.
q C'est dans la classe que nous allons définir nos méthodes et Ø Syntaxe : class NomDeLaClasse:
attributs,
Attributs et méthodes de Classe
Ø Les attributs étant des variables contenues dans notre objet.
Les attributs d’une classe:
q L'orienté objet est utile pour modéliser, représenter des données un
q Par exemple, que va-t-on trouver dans les caractéristiques d'une
peu plus complexes qu'un simple nombre, ou qu'une chaîne de
personne ?
caractères.
Ø Beaucoup de choses. On ne va en retenir que quelques unes:
q Bien sûr, en Python il existe des classes prédéfinit :
vle nom, le prénom, l'âge, le lieu de résidence. . .
Ø Les nombres (int, float, complex), les chaînes et les listes ...
q Cela nous fait donc quatre attributs. Ce sont les variables internes
Ø Mais on serait bien limité si on ne pouvait faire nos propres
à notre objet, qui vont le caractériser:
classes!
Ø Son nom, son prénom, son âge et son lieu de résidence.
Le constructeur (1/7) Le constructeur (2/7)
Exemple 1:
q Pour définir les attributs de notre objet, il faut définir une
1. class Personne : #Définition de notre classe Personne
méthode spéciale appelée « un constructeur » dans notre
2. """Classe définissant une personne caractérisée
classe.
3. par :
q Ce constructeur est appelé invariablement quand on souhaite 4. - son nom
créer un objet depuis notre classe. 5. - son prénom
q Concrètement, un constructeur est une méthode de notre objet 6. - son âge
se chargeant de créer nos attributs. 7. - son lieu de résidence"""
q En vérité, c'est même la méthode qui sera appelée quand on

8. def __init__ (self): #Notre méthode constructeur
voudra créer notre objet.
9. """Pour l'instant, on ne va définir que deux
10. attributs"""
11. self.nom = "Mohamed"
12. self.residence = "Nabeul"

1. >>> P1 = Personne () Quand on crée notre objet?
2. >>> P1 q Quand on tape P1 = Personne(), on appelle le constructeur de
3. <__main__.Personne object at 0 x00B42570 > notre classe Personne,
4. >>> P1.nom
q Celui-ci prend en paramètre une variable un peu mystérieuse : self.
5. ‘Mohamed‘
Ø En fait, il s'agit de notre objet « P1 » en train de se créer.
6. >>> P1.nom = ‘Ahmed’; P1.nom
7. ‘Ahmed‘ Ø On écrit dans cet objet l'attribut nom : self.nom = "Mohamed".
8. >>> P1.age q À la fin de l'appel au constructeur, Python renvoie notre objet self
9. Traceback (most recent call last): modifié, avec notre attribut.
10. File "<pyshell#20>", line 1, in <module> Ø On va réceptionner le tout dans notre variable « P1 ».
11. P1.age => Pour modifier un attribut d'un objet:
12.AttributeError: 'Personne' object has no objet.attribut = nouvelle_valeur
attribute 'age'
13.>>>
1. >>> P2 = Personne ("Tounsi", "Mohamed")
Exemple 2:
1. class Personne : #Définition de notre classe Personne
2. >>> P2.nom
2. """Classe définissant une personne caractérisée 3. ‘Tounsi'
3. par : 4. >>> P2.prenom
4. - son nom 5. ‘Mohamed'
5. - son prénom 6. >>> P2.age
6. - son âge 7. 23
7. - son lieu de résidence""" 8. >>> dir(P2)
8. 9. ['__class__', '__delattr__', '__dict__',
9. #Un constructeur plus intelligent
'__doc__', '__eq__', '__format__', '__ge__',
10. def __init__ (self, nom, prenom):
11. """Constructeur de notre classe"""
'__getattribute__', '__gt__', '__hash__',
12. self.nom = nom '__init__', '__le__', '__lt__', '__module__',
13. self.prenom = prenom '__ne__', '__new__', '__reduce__',
14. self.age = 23 '__reduce_ex__', '__repr__', '__setattr__',
15. self.residence = "Nabeul" '__sizeof__', '__str__', '__subclasshook__',
'__weakref__', 'nom‘, ‘prenom']
Le constructeur (7/7) Attributs de classe (1/2)

q Dans les exemples que nous avons vus jusqu'à présent:
q Dans un constructeur, le premier paramètre doit être « self ».
Ø Les attributs sont contenus dans l’objet.
q En dehors de cela, un constructeur est une fonction plutôt
Ø Ils sont propres à l'objet :
classique :
q Mais on peut aussi définir des attributs dans la classe.
Ø On peut définir des paramètres, par défaut ou non, nommés 1. class Compteur :
ou non. 2. """ Cette classe possède un attribut de
q Quand on veut créer un objet, on appel le nom de la classe en 3. classe qui s'incrémente à chaque fois
passant entre parenthèses les paramètres à utiliser. 4. que l'on crée un objet de ce type """
q La commande « dir(P2)» montre que notre objet intègre 5. objets_crees = 0 #Le compteur = 0 au départ
plusieurs autres attributs et méthodes! 6. def __init__ (self):
7. """ À chaque fois qu'on crée un objet,
8. on incrémente le compteur """
9. Compteur.objets_crees += 1
Attributs de classe (2/2) Les méthodes de la classe (1/3)
q Les attributs sont des variables propres à l’objet, qui servent à le
1. >>> Compteur.objets_crees
2. 0 caractériser.
3. >>> a = Compteur() #On crée un premier objet q Les méthodes sont plutôt des actions agissant sur l'objet.
4. >>> a.objets_crees #accès à travers l’objet
5. 1 Ø Par exemple, la méthode « append » de la « classe list »
6. >>> Compteur.objets_crees #à travers la classe permet d'ajouter un élément dans « l'objet list » manipulé.
7. 1 Exemple:
8. >>> b = Compteur() #On crée un 2eme objet
9. >>> Compteur.objets_crees q C’est un exemple de modélisation d’un tableau d’affichage,
10.2 q Notre tableau va posséder une surface (un attribut) sur laquelle
11.>>> a.objets_crees, b.objets_crees on pourra écrire, que l'on pourra lire et effacer.
12.(2,2)
13.>>> id(a) == id(b) q Le constructeur est en effet une méthode, elle en garde la
14.False syntaxe.
q Nous allons donc écrire la méthode « ecrire ».
Les méthodes de la classe (2/3) Les méthodes de la classe (3/3)

1. class TableauAffiche :
2. """Classe définissant une surface sur
1. tab = TableauAffiche()
3. laquelle on peut écrire, que l'on peut 2. >>> tab.surface
4. lire et effacer, par jeu de méthodes. 3. ''
5. L’attribut à modifier est 'surface'"""
6. 4. >>> tab.ecrire("Bonne Année universitaire!")
7. def __init__ (self): 5. >>> tab.surface
8. """Par défaut, la surface est vide"""
6. 'Bonne Année universitaire!'
9. self.surface = ""
10. 7. >>> tab.ecrire("2019/2020 :)")
11. def ecrire (self, message_a_ecrire): 8. >>> tab.surface
12. """Méthode permettant d'écrire sur la
13. surface du tableau. Si la surface n'est 9. 'Bonne Année universitaire!\n2019/2020 :)'
14. pas vide, on saute une ligne avant de 10.>>> print(tab.surface)
15. rajouter le message à écrire"""
11.Bonne Année universitaire!
16. if self.surface != "":
17. self.surface += "\n" 12.2019/2020 :)
18. self.surface += message_a_ecrire
Le paramètre « self » (1/2) Le paramètre « self » (2/2)
q Dans les méthodes d'instance, qu'on appelle également des méthodes 1. >>> tab.ecrire
d'objet, on trouve dans la définition ce paramètre « self », 2. <bound method TableauAffiche.ecrire of
Ø « self » c’est l’équivalent de l’objet courant « this » en Java et C++. <__main__. TableauAffiche object at 0 x00B3F3F0
>>
q Une chose qui a son importance :
3. >>> TableauAffiche.ecrire
Ø Quand on a créé un nouvel objet, les attributs sont propres à l'objet 4. <function ecrire at 0 x00BA5810 >
créé. 5. >>> help (TableauAffiche.ecrire)
Ø Si on a créé plusieurs tableaux d’affichage, ils ne vont pas tous avoir 6. Help on function ecrire in module __main__ :
la même surface. 7. ecrire (self, message_a_ecrire )
Ø Donc les attributs sont contenus dans l'objet. 8. Méthode permettant d'écrire sur la
9. surface du tableau. Si la surface n'est
q En revanche, les méthodes sont contenues dans la classe qui définit
10.pas vide, on saute une ligne avant de
notre objet.
11.rajouter le message à écrire
Ø C'est très important. Quand on tape « tab.ecrire(...) », 12.>>> TableauAffiche.ecrire(tab, "essai")
vPython va chercher la méthode « ecrire » non pas dans l'objet 13. #même que tab.ecrire("essai")
tab, 14.>>> tab.surface
vmais dans la classe TableauAffiche. 15.'essai’
Exemple: TableauAffiche (1/2) Exemple: TableauAffiche (2/2)

1. class TableauAffiche : 1. >>> tab = TableauAffiche ()
2. def __init__ (self): #constructeur de la classe
2. >>> tab.lire ()
4. def ecrire (self, message_a_ecrire):
5. """Méthode ... """
6. if self.surface != "": 3. >>> tab.ecrire ("Salut tout le monde .")
7. self.surface += "\n" 4. >>> tab.ecrire ("La forme ?")
8. self.surface += message_a_ecrire
9. 5. >>> tab.lire ()
10. def lire (self):
11. """Cette méthode se charge d'afficher, 6. Salut tout le monde .
12. grâce à print, la surface du tableau """ 7. La forme ?
13. print (self.surface)
14. def effacer (self): 8. >>> tab.effacer ()
15. """Cette méthode permet d'effacer la
9. >>> tab.lire ()
16. surface du tableau"""
10.>>>
Méthodes de classe Exemple: Méthodes de classe (1/2)
q Comme on trouve des attributs propres à la classe, on trouve 1. class Compteur :
aussi des méthodes de classe, 2. """Cette classe possède un attribut de classe qui
Ø qui ne travaillent pas sur l'instance « self » mais sur la classe 3. s'incrémente à chaque fois que l'on crée un objet
même. 4. de ce type"""
5. objets_crees = 0 #Le compteur vaut 0 au départ
Ø C'est un peu plus rare mais cela peut être utile parfois. 6. def __init__ (self):
q La méthode de classe se définit exactement comme une méthode 7. """À chaque fois qu'on crée un objet , on
d'instance, 8. incrémente le compteur"""
9. Compteur.objets_crees += 1
Ø à la différence qu'elle ne prend pas en premier paramètre «
10. def combien (cls):
self » (l'instance de l'objet) mais « cls » (la classe de l'objet). 11. """Méthode de classe affichant combien d'objets
q Enfin, pour que Python reconnaisse une méthode de classe, il 12. ont été créés """
faut appeler la fonction « classmethod » , 13. print("Jusqu'à présent,{} objets ont été créés".
14. format (cls.objets_crees ))
Ø qui prend en paramètre la méthode que l'on veut convertir
15. combien = classmethod (combien)
Ø et renvoie la méthode convertie.
Exemple: Méthodes de classe (2/2) Méthodes statiques

1. >>> Compteur.combien () q Les méthodes statiques sont assez proches des méthodes de
classe,
2. Jusqu'à présent, 0 objets ont été créés
Ø Sauf qu'elles ne prennent aucun premier paramètre, ni « self »
3. >>> a = Compteur ()
ni « cls ».
4. >>> Compteur.combien ()
Ø Elles travaillent donc indépendamment de toute donnée, aussi
5. Jusqu'à présent, 1 objets ont été créés bien contenue dans l'instance de l'objet que dans la classe.
6. >>> b = Compteur () Exemple:
1. class Test :
7. >>> Compteur.combien () 2. """Une classe de test tout simplement"""
8. Jusqu'à présent, 2 objets ont été créés 3. def afficher ():
4. """Fonction chargée d'afficher quelque chose"""
9. >>> b.combien () 5. print ("On affiche la même chose.")
6. print ("peu importe les données de l'objet ou
10.Jusqu'à présent, 2 objets ont été créés 7. de la classe.")
11.>>> 8. afficher = staticmethod (afficher)
Remarques La fonction « dir » (1/3)
q La fonction « dir() », elle prend en paramètre un objet et
q Retenez surtout que les attributs et les méthodes d'instance, renvoie la liste de ses attributs et méthodes.
c'est eux qu’on les retrouve la plupart du temps. 1. class Test :
2. """Une classe de test tout simplement"""
q Les noms de méthodes encadrés par deux soulignés de part et
3. def __init__ (self):
d'autre sont des méthodes spéciales.
4. """On définit dans le constructeur
Ø Ne nommez pas vos méthodes ainsi. 5. un unique attribut"""
6. self.mon_attribut = "ok"
Ø Nous découvrirons plus tard ces méthodes particulières.
7. def afficher_attribut (self):
Ø Exemple de nom de méthode à éviter : __MaMethode__. 8. """Méthode affichant l'attribut
9. 'mon_attribut '"""
10. print ("Mon attribut est {0}.".
11. format (self.mon_attribut))
La fonction « dir » (2/3) La fonction « dir » (3/3)

q La fonction « dir()» renvoie une liste comprenant le nom des
1. >>> #Créons un objet de la classe Test
attributs et méthodes de l'objet passé en paramètre.
2. ... un_test = Test ()
3. >>> un_test.afficher_attribut () q On remarque que tout est mélangé, c'est normal :
4. Mon attribut est ok. Ø Pour Python, les méthodes, les fonctions, les classes, les
5. >>> dir(un_test) modules sont des objets.
6. [' __class__ ', '__delattr__ ', '__dict__ ', q Ce qui différencie en premier lieu une variable d'une fonction,
7. '__doc__ ', '__eq__ ', ‘__format__ ', '__ge__ ',
Ø c'est qu'une fonction est exécutable (callable).
8. '__getattribute__ ', '__gt__ ', '__hash__ ',
9. '__init__ ', ‘__le__ ', '__lt__ ‘,'__module__ ', Ø La fonction « dir » se contente de renvoyer tout ce qu'il y a dans
10.'__ne__ ', '__new__ ', '__reduce__ ', l'objet, sans distinction.
11.'__reduce_ex__', '__repr__ ', ‘__setattr__ ', q Mais c'est quoi tout cela ?
12. '__sizeof__ ', '__str__ ', '__subclasshook__ ', Ø On n'a jamais défini toutes ces méthodes ou attributs !
13.‘__weakref__ ', 'afficher_attribut ',
Ø Nous verrons qu'il s'agit des méthodes spéciales utiles à Python.
14.'mon_attribut ']
L'attribut spécial __dict__ (1/2) L'attribut spécial __dict__ (2/2)
q Par défaut, quand on développe une classe, tous les objets q Toutes modifications de ce dictionnaire entraine la modification
construits depuis cette classe posséderont un attribut spécial des attributs de l’objet aussi !
__dict__. 1. >>> un_test.__dict__ ["mon_attribut"] = "plus ok"
q Cet attribut est un dictionnaire qui contient comme clés les 2. >>> un_test.mon_attribut
noms des attributs et, en tant que valeurs, les valeurs des 3. ‘plus ok’
attributs. 4. >>> un_test.afficher_attribut ()
1. >>> un_test = Test () 5. Mon attribut est plus ok.
2. >>> un_test.mon_attribut q De manière générale, on évite ce genre de syntaxe!
3. 'ok' Ø Il est plus propre d'écrire:
4. >>> un_test.__dict__ vobjet.attribut = valeur que
5. {'mon_attribut': 'ok'} vobjet.__dict__[nom_attribut] = valeur.
Copie d’instances (1/2) Copie d’instances (2/2)

q Les instances de classes sont des objets mutables (modifiables), q Il faut donc copier explicitement l’instance pour obtenir le
comme pour les listes, résultat souhaité.
Ø une simple affectation ne signifie pas une copie mais un 1. a = Point (1,2)
second nom pour désigner le même objet!
1. class Point : 2. import copy
2. def __init__(self,a,b): 3. b = copy.copy (a)
3. self.x = a
4. b.x = -1
4. self.y = b
5. print (a.x) # affiche 1
5. >>> a = Point(1,2) 6. print (b.x) # affiche -1
6. >>> b = a
7. >>> b.x = -1 7. print(a is b) # affiche False
8. >>> (a.x, a is b) q Lorsque une classe inclut une variable de type classe, il faut
9. (-1, True)
utiliser la fonction deepcopy et non copy.
Encapsulation (1/2)
q Nous allons découvrir dans cette partie les propriétés,
Ø C’est un concept propre à Python et à quelques autres
Partie 2: langages, comme le Ruby.

Ø C'est une fonctionnalité qui, à elle seule, change l'approche
Encapsulation et objet et le principe d'encapsulation.
q Qu'est-ce que l'encapsulation ?
Héritage simple Ø L'encapsulation est un principe qui consiste à cacher ou
protéger certaines données de l’objet.
Ø Autrement dit, on n'a pas le droit de manipuler l’attribut depuis
l'extérieur de la classe:
mon_objet.mon_attribut
Encapsulation (2/2) Encapsulation : Avantage

q Pour accéder aux attributs on doit définir des méthodes un peu q L’encapsulation est très pratique pour sécuriser certaines
particulières, appelées des accesseurs et mutateurs. données de l’objet,
Ø Les accesseurs donnent accès à l'attribut. Ø par exemple faire en sorte qu'un attribut de notre objet ne
Ø Les mutateurs permettent de le modifier. soit pas modifiable,
q Concrètement, au lieu d'écrire mon_objet.mon_attribut, Ø ou alors mettre à jour un attribut dès qu'un autre attribut est
modifié.
Ø on écrit: mon_objet._get_mon_attribut()
q Les cas sont multiples et c'est très utile de pouvoir contrôler
q De la même manière, pour modifier l'attribut on écrit:
l'accès en lecture ou en écriture sur certains attributs de notre
Ø mon_objet._set_mon_attribut(valeur)
objet.
et non pas
Ø mon_objet.mon_attribut = valeur
Encapsulation: Inconvénient Encapsulation: Les propriétés (1/2)
q L'inconvénient de devoir écrire des accesseurs et mutateurs, q En C++ ou en Java par exemple, dans la définition de classe, on
met en place des principes d'accès qui indiquent si l'attribut (ou le
Ø Il faut créer deux méthodes pour chaque attribut de la
groupe d'attributs) est privé ou public.
classe.
Ø D'abord, c'est assez lourd. Ø Si l'attribut est public, on peut y accéder depuis l'extérieur de
la classe et le modifier.
Ø Ensuite, nos méthodes se ressemblent plutôt.
Ø S'il est privé, on ne peut pas. On doit passer par des
q Certains environnements de développement proposent,
accesseurs ou mutateurs.
Ø De créer ces accesseurs et mutateurs pour nous,
q En Python, il n'y a pas d'attribut privé. Tout est public!
automatiquement.
Ø Mais cela ne résout pas vraiment le problème! q Les propriétés sont un moyen transparent de manipuler des
attributs d'objet.
Encapsulation: Les propriétés (2/2) Encapsulation: property (1/7)

q De cette façon, on peut rendre certains attributs tout à fait q Il s'agissait d'une classe, son nom est « property ». Elle attend
inaccessibles depuis l'extérieur de la classe, quatre paramètres, tous optionnels :
Ø Ou dire qu'un attribut ne sera visible qu'en lecture et non Ø la méthode donnant accès à l'attribut ;
modifiable. Ø la méthode modifiant l'attribut ;
q Pour l'utilisateur, c'est absolument transparent : il croit avoir un Ø la méthode appelée quand on souhaite supprimer l'attribut ;
accès direct à l'attribut. Ø la méthode appelée quand on demande de l'aide sur l'attribut.
Ø C'est dans la définition de la classe que on précise que tel ou q En pratique, on utilise surtout les deux premiers paramètres :
tel attribut doit être accessible ou modifiable grâce à certaines
Ø Ceux définissant les méthodes d'accès et de modification,
propriétés.
autrement dit l’accesseur et le mutateur d'objet.
q Les propriétés sont des objets un peu particuliers de Python. Ø Pour plus d’information taper dans le « Shell » la commande:
Ø Elles prennent la place d'un attribut et agissent différemment 1. >>> help(property)
en fonction du contexte de l’appel.
Encapsulation: property (2/7) Encapsulation: property (3/7)
>>> help (property) 1. class Personne :
2. def __init__(self,nom,prenom):
Help on class property in module builtins: 3. self.nom = nom; self.prenom = prenom; self.age = 23
class property(object) 4. self._lieu_residence = "Nabeul"
| property(fget=None, fset=None, fdel=None, doc=None) -> 5. def _get_lieu_residence(self):
property attribute 6. """Méthode qui sera appelée quand on souhaitera
7. accéder en lecture à l'attribut «lieu_residence»"""
| fget is a function to be used for getting an attribute
8. print("On accède à l'attribut lieu_residence!")
value, and likewise
9. return self._lieu_residence
| fset is a function for setting, and fdel a function for 10. def _set_lieu_residence(self, nouvelle_residence):
del'ing, an attribute. Typical use is to define a 11. """Méthode appelée quand on souhaite modifier le
managed attribute x: 12. lieu de résidence """
| class C(object): 13. print("Attention, {} déménage à {}.".format( \
| def getx(self): return self._x 14. self.prenom, nouvelle_residence))
15. self._lieu_residence = nouvelle_residence
| def setx(self, value): self._x = value 16. #On va dire à Python que notre attribut
| def delx(self): del self._x 17. # «lieu_residence» pointe vers une propriété
| x = property(getx,setx,delx,"I'm the 'x' property.") 18. lieu_residence = property(_get_lieu_residence,\
19. _set_lieu_residence)
...

q La convention veut qu'on n'accède pas, depuis l'extérieur de la 1. >>> p1 = Personne ("Tounsi", "Mohamed")
classe, 2. >>> p1.nom; p1.prenom; p1.age
3. ‘Tounsi‘
Ø à un attribut commençant par un souligné « _ ».
4. ‘Mohamed‘
Ø à une méthode commençant par un souligné « _ ». 5. 23
Ø c'est une convention, rien ne nous l'interdit. . . , sauf le bon 6. >>> p1.lieu_residence
sens! 7. On accède à l'attribut lieu_residence!
8. ‘Nabeul‘
q La dernière ligne de la classe, il s'agit de la définition d'une
9. >>> p1.lieu_residence = "Gabès"
propriété.
10. Attention, Mohamed déménage à Gabès.
Ø On lui dit que l'attribut lieu_residence doit être une 11.>>> p1.lieu_residence
propriété. 12. On accède à l'attribut lieu_residence!
Ø On définit dans notre propriété, dans l'ordre, la méthode 13. ‘Gabès‘
d'accès (l'accesseur) et celle de modification (le mutateur). 14.>>>
q Attribut accessible en lecture seulement: Accesseur q Attribut accessible en écriture seulement: Mutateur
lieu_residence = property(_get_lieu_residence) lieu_residence = property(None,_set_lieu_residence)
1. >>> p = Personne("Tounsi", "Mohamed")

2. >>> p.lieu_residence 1. >>> p = Personne("Tounsi", "Mohamed")
3. On accède à l'attribut lieu_residence ! 2. >>> p.lieu_residence

4. 'Nabeul' 3. Traceback (most recent call last):
5. >>> p.lieu_residence = "Gabès" 4. File "<pyshell#4>", line 1, in <module>

6. Traceback (most recent call last): 5. p.lieu_residence
7. File "<pyshell#2>", line 1, in <module> 6. AttributeError: unreadable attribute

8. p.lieu_residence = "Gabès" 7. >>> p.lieu_residence = "Gabès"
9. AttributeError: can't set attribute 8. attention, Mohamed déménage à Gabès.

9. >>>
Héritage simple: Introduction (1/2) Héritage simple: Introduction (2/2)

q L'héritage est une fonctionnalité objet qui permet de déclarer : q Par exemple: on a une classe Animal permettant de définir des
animaux.
Ø que telle classe sera elle-même modelée sur une autre classe,
q Les animaux tels que nous les modélisons ont :
Ø qu'on appelle la classe parente, ou la classe mère. Ø certains attributs (le régime : carnivore ou herbivore)
q Concrètement, si une classe « B » hérite de la classe mère « A », Ø et certaines méthodes (manger, boire, crier. . .).
Ø les objets créés sur le modèle de la classe « B » auront accès aux q On peut maintenant définir une classe Chien qui hérite de « Animal »,
méthodes et attributs de la classe « A ». c'est-à-dire qu'elle reprend ses méthodes.
q Le test suivant, montre dans quel cas on fait hériter une classe d'une
q La classe « B » ne se contente pas de reprendre les méthodes et
autre:
attributs de la classe « A » :
Ø on fait hériter la classe « Chien » de « Animal » parce qu'un chien
Ø Elle va pouvoir en définir d'autres, est un animal ;
Ø D'autres méthodes et d'autres attributs qui lui seront propres, en Ø on ne fait pas hériter « Animal » de « Chien » parce qu'Animal
plus celles de la classe mère « A », n'est pas un Chien!
q Une voiture est un véhicule. La classe « Voiture » pourrait donc
Ø Et elle va pouvoir également redéfinir les méthodes de la classe «A»
hériter de la classe « Vehicule ».
Héritage simple (1/7) Héritage simple (2/7)
q Syntaxe: q Quand une classe « B » hérite d'une classe « A »,
class MaClasse(MaClasseMere): Ø Les objets de type « B » reprennent les méthodes de la classe « A
Attributs et méthodes de MaClasse » et celles de la classe « B ».
q Exemple:
Ø Mais ce sont celles de la classe « B » qui sont appelées d'abord.
1. class A:
2. """Classe mère A, pour illustrer l'héritage""" q Si on a la commande : objet_de_type_b.ma_methode()
3. pass #On laisse la définition vide Ø Python va d'abord chercher ma_methode() dans la classe « B ».
4. class B(A): Ø S'il ne trouve pas, il va chercher récursivement dans les classes
5. """Classe fille B, qui hérite de A""" dont hérite « B », c'est-à-dire « A » dans notre exemple.
6. pass
q Ce mécanisme est très important :
q Toutes les méthodes de la classe A se retrouveront dans la
Ø On peut ainsi redéfinir une certaine méthode dans une classe
classe B.
Ø et laisser d'autres directement hériter de la classe mère.
Ø Par contre, n’est pas vrai pour les attributs!

1. class Etudiant(Personne):
1. class Personne :
2. """ Classe définissant un étudiant,
2. """Classe représentant une personne"""
3. Elle hérite de la classe Personne """
3. def __init__ (self,nom):
4. def __init__ (self, nom, matricule):
4. """Constructeur de notre classe"""
5. """Etudiant se définit par son nom et son
5. self.nom = nom
6. matricule"""
6. self.prenom = "Mohamed"
7. self.nom = nom
7. def __str__ (self):
8. self.matricule = matricule
8. """Méthode appelée lors d'une conversion
9. def __str__ (self):
9. de l'objet en chaîne"""
10. """Méthode appelée lors d'une conversion
10. return "{0} {1}”\
11. de l'objet en chaîne"""
11. .format(self.prenom, self.nom)
12. return “Etudiant {0}, matricule {1}”\
13. .format(self.nom, self.matricule)
1. >>> p = Personne("Tounsi") q On remarque que le constructeur de la classe « Personne » n'est
2. >>> print(p) pas appelé à la création d’un objet de type « Etudiant »
3. Mohamed Tounsi Ø mon_objet.ma_methode() est la même que :
4. >>> p.prenom MaClasse.ma_methode(mon_objet)
5. 'Mohamed' Ø Donc, on peut se servir de cette notation pour appeler une
6. >>> e = Etudiant("Nabli","ST5") méthode précise d'une classe précise
1. class Etudiant(Personne):
7. >>> print(e)
2. def __init__ (self, nom, matricule):
8. Etudiant Nabli, matricule ST5 3. #on appel explicitement le constructeur
9. >>> e.prenom 4. #de Personne
10. Traceback (most recent call last): 5. Personne.__init__(self, nom)
11. File "<pyshell#15>", line 1, in <module> 6. self.matricule = matricule
12. e.prenom 7. def __str__ (self):
13. AttributeError: 'Etudiant' object has no attribute
8. return “Etudiant {0}, matricule {1}”\
'prenom' 9. .format(self.nom, self.matricule)
Héritage simple (7/7) La classe « object » (1/3)

q En Python, toutes les classes crée héritent de la classe « object ».
1. >>> e = Etudiant("Nabli","ST5")
Ø C'est elle, notamment, qui définit toutes les méthodes spéciales,
2. >>> print(e)
Ø Et qui connaît, bien mieux que nous, le mécanisme interne de
3. Etudiant Nabli, matricule ST5
l'objet.
4. >>> e.prenom
1. # On redéfinit cette méthode dans la classe Etudiant
5. ‘Mohamed’
2. def __setattr__(self, nom_attribut, valeur_attribut):
q Notre attribut « prenom » se trouve bien dans notre objet « e » 3. """ Méthode spéciale appelée quand on fait
q Dans le constructeur d‘Etudiant, on n'instancie pas l'attribut « 4. objet.attribut = valeur """
nom ». 5. print("Attention, on modifie l'attribut {0} de\
Ø Celui-ci est en effet écrit par le constructeur de la classe « 6. l'objet !".format(nom_attribut))
Personne » que nous appelons en lui passant en paramètre le 7. object.__setattr__(self,nom_attribut,valeur_attribut)
« nom » de notre « Etudiant ». 8. """ Par contre la ligne suivante provoque

9. des appels sans fin! """
10. #self.nom_attribut = valeur_attribut
La classe « object » (2/3) La classe « object » (3/3)
1. >>> e = Etudiant("Tounsi", "ST4")
2. Attention, on modifie l'attribut nom de l'objet ! q En redéfinissant la méthode __setattr__, on ne peut, dans
3. Attention, on modifie l'attribut prenom de l'objet ! le corps de cette méthode, modifier les valeurs de nos attributs
4. Attention, on modifie l'attribut matricule de l'objet ! comme on le fait habituellement (self.attribut = valeur)
5. >>> e.prenom car la méthode s'appellerait elle-même!
6. 'Mohamed' q On fait appel à la méthode __setattr__ de la classe
7. >>> e.nom = "Nabli" object, cette classe dont héritent implicitement toutes nos
8. Attention, on modifie l'attribut nom de l'objet ! classes.
9. >>> dir(object) q On est sûr que la méthode de cette classe sait écrire une valeur
10.['__class__', '__delattr__', '__dir__', '__doc__', dans un attribut,
'__eq__', '__format__', '__ge__', '__getattribute__',
'__gt__', '__hash__', '__init__', '__le__', '__lt__', Ø alors que nous ignorons le mécanisme et que nous n'avons
'__ne__', '__new__', '__reduce__', '__reduce_ex__', pas besoin de le connaître !
'__repr__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__']
11.>>>
Deux fonctions très pratiques (1/2) Deux fonctions très pratiques (2/2)
q Python définit deux fonctions qui peuvent se révéler utiles dans
q isinstance : permet de savoir si un objet est issu d'une classe
bien des cas : issubclass() et isinstance().
ou de ses classes filles :
q issubclass : Comme son nom l'indique, elle vérifie si une 1. >>> e = Etudiant("Tounsi", "ST4")
classe est une sous-classe d'une autre classe. 2. >>> isinstance(e, Etudiant)
Ø Elle renvoie True si c'est le cas, False sinon : 3. True
4. >>> isinstance(e, Personne)
1. >>> issubclass (Etudiant, Personne) 5. True
2. True 6. >>> isinstance(e, object)
3. >>> issubclass (Etudiant, object) 7. True
4. True
5. >>> issubclass (Personne, object) 8. >>> p = Personne("Tounsi")
6. True 9. >>> isinstance(p, Etudiant)
7. >>> issubclass (Personne, Etudiant) 10.False
8. False
Remarques
q « 5 » : objet de la classe « int »:
1. >>> type(5); isinstance(5,int)
2. <class 'int'>
3. True
q « int » : est un type de l’objet « 5 » et au même temps un
objet de la classe « type »:
1. >>> type(int); isinstance(int,type)
2. <class 'type‘>
3. True
q « type » : est le type de toutes les classes et au même temps
un objet de la classe « object »:
1. >>> isinstance(type,object)
2. True
IPEIN 2021/2022 2ème Année - Informatique - Chapitre 2 65/65

2eme Chapitre2-POO v1.0 Imprimable

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

2eme Chapitre2-POO v1.0 Imprimable

Transféré par

Droits d'auteur :

Formats disponibles

Plan

Programmation avec Python b. Héritage simple

Année universitaire 2021/2022

Introduction (1/2) Introduction (2/2)

Ø Contrôler la complexité des logiciels, Ø Non seulement les structures de données,

q Contenir les coûts de la maintenance : q Ainsi,

Ø Ajout de nouvelles fonctionnalités, Ø La structure de données devient un objet qui inclut:

Ø Modification de fonctionnalités existantes, vDonnées, appelées attributs,

Ø portage sur d'autres plateformes ou environnements. vOpérations, appelées méthodes.

classes celle du C++ :

Choix du modèle Déclaration d’une classe

q En vérité, c'est même la méthode qui sera appelée quand on

Le constructeur (3/7) Le constructeur (4/7)

Le constructeur (7/7) Attributs de classe (1/2)

Les méthodes de la classe (2/3) Les méthodes de la classe (3/3)

Exemple: TableauAffiche (1/2) Exemple: TableauAffiche (2/2)

Exemple: Méthodes de classe (2/2) Méthodes statiques

La fonction « dir » (2/3) La fonction « dir » (3/3)

Copie d’instances (1/2) Copie d’instances (2/2)

Partie 2: langages, comme le Ruby.

Encapsulation (2/2) Encapsulation : Avantage

Encapsulation: Les propriétés (2/2) Encapsulation: property (1/7)

Encapsulation: property (4/7) Encapsulation: property (5/7)

1. >>> p = Personne("Tounsi", "Mohamed")

3. On accède à l'attribut lieu_residence ! 2. >>> p.lieu_residence

5. >>> p.lieu_residence = "Gabès" 4. File "<pyshell#4>", line 1, in <module>

7. File "<pyshell#2>", line 1, in <module> 6. AttributeError: unreadable attribute

9. AttributeError: can't set attribute 8. attention, Mohamed déménage à Gabès.

Héritage simple: Introduction (1/2) Héritage simple: Introduction (2/2)

Héritage simple (3/7) Héritage simple (4/7)

Héritage simple (7/7) La classe « object » (1/3)

« nom » de notre « Etudiant ». 8. """ Par contre la ligne suivante provoque

IPEIN 2021/2022 2ème Année - Informatique - Chapitre 2 65/65

Vous aimerez peut-être aussi