POO en Python - Master 2 [PDF]

Zitiervorschau

Guide pratique POO

My abdelouahed Sabri

Fonctions en python • Définition def Mafonction([arg1[=val1][,ag2[=val2]]]):

[return]

• Appel Mafonction() # ou bien; cible d’affectation Ret=mafonction()

Fonctions en python >>> def affiche(): print("ceci est une fonction") >>> affiche() ceci est une fonction >>> def salutation(nom): print("salut %s" %nom) >>> salutation("Sabri") salut Sabri >>> >>> def somme(a,b): return a+b >>> somme(5,4) 9 >>> v=somme(5,4) >>> v 9

>>> def affiche(): printttt("ceci est une fonction") >>> affiche() Traceback (most recent call last): File "", line 1, in File "", line 2, in affiche NameError: global name 'printttt' is not defined >>> def produit(a=1,b): return a*b File "", line 1 SyntaxError: non-default argument follows default argument >>> def produit(a,b=0.5): return a*b >>> produit(8) 4.0 >>> produit(8,2) 16

Fonctions en python >>> def soustraction(x=1,y=9): return x-y >>> soustraction() #x=1 et y=9 -8 >>> soustraction(2) #x=2 et y=9 -7 >>> soustraction(3,2) #x=3 et y=2 1 >>> soustraction(y=3,x=2) #x=2 et y=3 -1 >>> soustraction(x=3,y=2) #x=3 et y=2 1 >>> soustraction(x=3,8) File "", line 1 SyntaxError: non-keyword arg after keyword arg

Fonctions en python • Passage par valeur et par référence def app(l): l.append(8)

>>> def app(l): l+=[8]

l1=[4, 8, 9] app(l1) print(l1) [4, 8, 9, 8]

>>> l1=[4, 8, 9] >>> app(l1) >>> print(l1) [4, 8, 9, 8]

>>> def increm(a): ... a=a+1 ... >>> a=8 >>> increm(a) >>> print(a) 8

>>> def increm(a): ... a+=1 ... >>> a=8 >>> increm(a) >>> print(a) 8

>>> def app(l): ... l= l + [8] ... >>> l1=[4, 8, 9] >>> app(l1) >>> print(l1) [4, 8, 9]

Rappel • Classe: ensemble d’attributs et méthodes • Objet: instance de classe • Python utilise presque les mêmes notions de POO que les autres langages orientés objets

Classe en python • Syntaxe de création: utiliser le mot-clés « class » suivi par le nom de la classe et suivi par « : » – Ne pas oublier l’indentation class NomdeClasse:

• Utilisation (instanciation): monObjet= NomdeClasse() >>> class MaClasse: "ma classe" >>> monObj=MaClasse() >>> type(monObj)

>>> type(MaClasse)

Méthodes >>> class Notes: def maxim(self): #self n’est pas obligatoire sauf si la méthode n’a pas d’arguments en entrée print "pas encore implémentée" >>> maxim() Traceback (most recent call last): File "", line 1, in NameError: name 'maxim' is not defined >>> nt=Notes() >>> nt.maxim() pas encore implémentée

Attributs >>> class Notes: def maxim(): print "pas encore implémentée" >>> nt=Notes() >>> nt.ntA Traceback (most recent call last): File "", line 1, in AttributeError: Notes instance has no attribute 'ntA' >>> nt.ntA={10,18,15.5,20} >>> nt.ntA set([15.5, 18, 20, 10]) >>> max(nt.ntA) 20 >>> nt2=Notes() >>> nt2.ntA Traceback (most recent call last): File "", line 1, in AttributeError: Notes instance has no attribute 'ntA'

Attributs >>> class Notes: def nom(self,nm): self.name=nm def recNom(self): return self.name >>> nt=Notes() >>> nt.name Traceback (most recent call last): File "", line 1, in AttributeError: Notes instance has no attribute 'name' >>> nt.nom("sabri") >>> nt.name 'sabri' >>> nt2=Notes() >>> nte.recNom() Traceback (most recent call last): File "", line 1, in NameError: name 'nte' is not defined >>> nt2.recNom() Traceback (most recent call last): File "", line 1, in File "", line 5, in recNom AttributeError: Notes instance has no attribute 'name’

Constructeur __init__ >>> class Notes: def __init__(self): self.name="pas encore affecté" def nom(self,nm): self.name=nm def recNom(self): return self.name >>> nt=Notes() >>> nt.name 'pas encore affect\x82' >>> class Notes: def __init__(self,nme): self.name=nme def nom(self,nm): self.name=nm def recNom(self): return self.name >>> nt=Notes() Traceback (most recent call last): File "", line 1, in TypeError: __init__() takes exactly 2 arguments (1 given) >>> nt=Notes("sabri") >>> nt.name 'sabri'

Constructeur __init__ >>> class Notes: def __init__(self,nme="Non affecté"): self.name=nme def nom(self,nm): self.name=nm def recNom(self): return self.name >>> nt=Notes() >>> nt.name 'Non affect\x82' >>> nt=Notes("sabri") >>> nt.name 'sabri’

Éléments partagés: __class__ >>> class Notes: compt=0 def __init__(self,nme="Non affecté"): self.__class__.compt +=1 self.name=nme >>> nt=Notes() >>> nt.compt 1 >>> bt=Notes("said") >>> nt.compt 2 >>> bt.compt 2 >>> nt.name 'Non affect\xe9' >>> bt.name 'said'

Visibilité: privé • Nom commence par « __ » class Etudiant: def cal(self, note): self.__coef=0.5 self.__affiche(note*self.__coef) def __affiche(self, val): print val>>> et=Etudiant() >>> dir(et) ['_Etudiant__affiche', '__doc__', '__module__', 'cal']

Visibilité: privé • Nom commence par « __ » – Remarque: Ne jamais compter sur cette visibilité class Etudiant: def cal(self, note): self.__coef=0.5 self.__affiche(note*self.__coef) def __affiche(self, val): print val >>> et=Etudiant() >>> dir(et) ['_Etudiant__affiche', '__doc__', '__module__', '_coef', 'cal'] >>> et.cal(8) # passer par la fct cal pour rendre accessible _coef 4.0 >>> et._Etudiant__coef 0.5

Méthodes statiques: décorateur @staticmethod from datetime import datetime class duree(object): def __init__(self, hr,mn, sec): self.hr=hr self.mn=mn self.sec=sec @staticmethod def heureActuelle(): print "l heure est " + str(datetime.now()) >>> duree.heureActuelle() l heure est 2016-03-23 16:07:43.835000 >>> dd=duree(0,0,0) >>> dd.heureActuelle() l heure est 2016-03-23 16:08:17.705000

Héritage • Le même que les autres langages • Syntaxe: class ClasseFille(ClasseMere[,autresclasse]):

• Python propose l’héritage multiple • Pour accéder au constructeur de la classe mère: – ClasseMere.__init__(self) en python 2 – super(ClasseFille, self). __init__() en python 3

Héritage class Personne(object): def __init__(self, nom, prenom=""): print("Initialisation de la personne") self.nom = nom self.prenom = prenom def getNomPrenom(self): return self.nom+ " " +self.prenom class Etudiant(Personne): def __init__(self, numero, nom,prenom): print("Initialisation de l'étudiant") Personne.__init__(self, nom,prenom) self.numero = numero >>> e = Etudiant(15,nom='Hafid', prenom='said') Initialisation de l'étudiant Initialisation de la personne >>> e.nom 'Hafid' >>> e.prenom 'said‘ >>> e.getNomPrenom()

Héritage class Personne(object): def __init__(self, nom, prenom=""): print("Initialisation de la personne") self.nom = nom self.prenom = prenom def getNomPrenom(self): return self.nom+ " " +self.prenom class Etudiant(Personne): def __init__(self, numero, nom,prenom): print("Initialisation de l'étudiant") super(Etudiant, self).__init__( nom,prenom) self.numero = numero >>> e = Etudiant(15,nom='Hafid', prenom='said') Initialisation de l'étudiant Initialisation de la personne >>> e.nom 'Hafid' >>> e.prenom 'said‘ >>> e.getNomPrenom()

Héritage: polymorphisme class Personne(object): def __init__(self, nom, prenom=""): print("Initialisation de la personne") self.nom = nom self.prenom = prenom def getNomPrenom(self): return self.nom+ " " +self.prenom class Etudiant(Personne): def __init__(self, numero, nom,prenom): print("Initialisation de l'étudiant") super(Etudiant, self).__init__(nom,prenom) self.numero = numero def getNomPrenom(self): return "Le nom de l'étudiant: "+Personne.getNomPrenom(self) >>> e = Etudiant(15,nom='Hafid', prenom='said') Initialisation de l'étudiant Initialisation de la personne >>> e.nom 'Hafid' >>> e.prenom 'said‘ >>> e.getNomPrenom() "Le nom de l'\xe9tudiant: Hafid said"

Héritage: polymorphisme class Personne(object): def __init__(self, nom, prenom=""): print("Initialisation de la personne") self.nom = nom self.prenom = prenom def getNomPrenom(self): return self.nom+ " " +self.prenom class Etudiant(Personne): def __init__(self, numero, nom,prenom): print("Initialisation de l'étudiant") super(Etudiant, self).__init__(nom,prenom) self.numero = numero def getNomPrenom(self): return "Le nom de l'étudiant: "+super(Etudiant, self).getNomPrenom() >>> e = Etudiant(15,nom='Hafid', prenom='said') Initialisation de l'étudiant Initialisation de la personne >>> e.nom 'Hafid' >>> e.prenom 'said‘ >>> e.getNomPrenom() "Le nom de l'\xe9tudiant: Hafid said"

Modules et packages • Un module est un moyen (fichier) qui permet d'organiser logiquement le code Python: – Rend le code plus lisible et facile à comprendre et à utiliser. – Un module est un objet Python avec des attributs et méthodes qu’on peut utiliser – C’est un fichier qui contient du code Python. – Un module peut définir des fonctions, des classes et des variables – Un module peut également inclure du code exécutable.

• Pour utiliser un fichier source Python comme un module en exécutant l’instruction import à partir d’un autre fichier source Python. • Lorsque l'interpréteur rencontre une instruction import, il importe le module si le module est présent dans les chemins de dossiers reconnus (paths). Il le cherche dans: – Le dossier courant – Le PYTHONPATH. On peut la modifier « set PYTHONPATH=c:\mondossier\ » – Le dossier par défaut de python

Modules • Créer un fichier (module) python calc.py #Fichier calc.py def addi(a,b): return a +b def soust(a,b): return a-b

• Utilisation du module import calc print calc.addi(5,6) from calc import addi print addi(5,6) soust(7,5) # erreur Traceback (most recent call last): Python Shell, prompt 3, line 1 NameError: name 'sous' is not defined from calc import addi,soust print addi(5,6) print soust(4,3) from calc import * print addi(5,6) print soust(4,3)

Packages • Un paquetage est une structure hiérarchique de dossiers définissant une application python et qui est constitué de plusieurs modules – Créer un dossier nommé « calcul » dont la structure est la suivante • Calcul – Operateur.py contient une fonction OPE() – Arithmetique » Add.py contient une fonction ADD() » Sous.py contient une fonction SOUS() » __init__.py contient les imports vers les modules du dossier – __init__.py contient les imports vers les modules du dossier

Packages #Fichier __init__.py dans Calcul from Operateur import * from Arithmetique import * #Fichier Operateur.py def OPE(): print "module operateur" #Fichier __init__.py dans Arithmetique from Add import * from Sous import * #Fichier Add.py dans Arithmetique def ADD(): print "Arithmetique --> Add" #Fichier Sous.py dans Arithmetique def SOUS(): print "Arithmetique --> SOUS"

#Fichier de test from Calcul import * OPE() Add.ADD() Arithmetique.Sous.SOUS()