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(): >>> def affiche():
print("ceci est une fonction") printttt("ceci est une fonction")
>>> affiche() >>> affiche()
ceci est une fonction Traceback (most recent call last):
File "<stdin>", line 1, in <module>
>>> def salutation(nom): File "<stdin>", line 2, in affiche
print("salut %s" %nom) NameError: global name 'printttt' is not defined
>>> salutation("Sabri")
salut Sabri >>> def produit(a=1,b):
>>> return a*b
File "<stdin>", line 1
>>> def somme(a,b): SyntaxError: non-default argument follows default
return a+b argument
>>> somme(5,4) >>> def produit(a,b=0.5):
9 return a*b
>>> v=somme(5,4)
>>> v >>> produit(8)
9 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 "<stdin>", line 1
SyntaxError: non-keyword arg after keyword arg
Fonctions en python
• Passage par valeur et par référence
def app(l): >>> def app(l): >>> def app(l):
[Link](8) l+=[8] ... l= l + [8]
...
l1=[4, 8, 9] >>> l1=[4, 8, 9] >>> l1=[4, 8, 9]
app(l1) >>> app(l1) >>> app(l1)
print(l1) >>> print(l1) >>> print(l1)
[4, 8, 9, 8] [4, 8, 9, 8] [4, 8, 9]
>>> def increm(a): >>> def increm(a):
... a=a+1 ... a+=1
... ...
>>> a=8 >>> a=8
>>> increm(a) >>> increm(a)
>>> print(a) >>> print(a)
8 8
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 'instance'>
>>> type(MaClasse)
<type 'classobj'>
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 "<stdin>", line 1, in <module>
NameError: name 'maxim' is not defined
>>> nt=Notes()
>>> [Link]()
pas encore implémentée
Attributs
>>> class Notes:
def maxim():
print "pas encore implémentée"
>>> nt=Notes()
>>> [Link]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: Notes instance has no attribute 'ntA'
>>> [Link]={10,18,15.5,20}
>>> [Link]
set([15.5, 18, 20, 10])
>>> max([Link])
20
>>> nt2=Notes()
>>> [Link]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: Notes instance has no attribute 'ntA'
Attributs
>>> class Notes:
def nom(self,nm):
[Link]=nm
def recNom(self):
return [Link]
>>> nt=Notes()
>>> [Link]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: Notes instance has no attribute 'name'
>>> [Link]("sabri")
>>> [Link]
'sabri'
>>> nt2=Notes()
>>> [Link]()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'nte' is not defined
>>> [Link]()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 5, in recNom
AttributeError: Notes instance has no attribute 'name’
Constructeur __init__
>>> class Notes:
def __init__(self):
[Link]="pas encore affecté"
def nom(self,nm):
[Link]=nm
def recNom(self):
return [Link]
>>> nt=Notes()
>>> [Link]
'pas encore affect\x82'
>>> class Notes:
def __init__(self,nme):
[Link]=nme
def nom(self,nm):
[Link]=nm
def recNom(self):
return [Link]
>>> nt=Notes()
Traceback (most recent call last): File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 2 arguments (1 given)
>>> nt=Notes("sabri")
>>> [Link]
'sabri'
Constructeur __init__
>>> class Notes:
def __init__(self,nme="Non affecté"):
[Link]=nme
def nom(self,nm):
[Link]=nm
def recNom(self):
return [Link]
>>> nt=Notes()
>>> [Link]
'Non affect\x82'
>>> nt=Notes("sabri")
>>> [Link]
'sabri’
Éléments partagés: __class__
>>> class Notes:
compt=0
def __init__(self,nme="Non affecté"):
self.__class__.compt +=1
[Link]=nme
>>> nt=Notes()
>>> [Link]
1
>>> bt=Notes("said")
>>> [Link]
2
>>> [Link]
2
>>> [Link]
'Non affect\xe9'
>>> [Link]
'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']
>>> [Link](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):
[Link]=hr
[Link]=mn
[Link]=sec
@staticmethod
def heureActuelle():
print "l heure est " + str([Link]())
>>> [Link]()
l heure est 2016-03-23 16:07:43.835000
>>> dd=duree(0,0,0)
>>> [Link]()
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")
[Link] = nom
[Link] = prenom
def getNomPrenom(self):
return [Link]+ " " +[Link]
class Etudiant(Personne):
def __init__(self, numero, nom,prenom):
print("Initialisation de l'étudiant")
Personne.__init__(self, nom,prenom)
[Link] = numero
>>> e = Etudiant(15,nom='Hafid', prenom='said')
Initialisation de l'étudiant
Initialisation de la personne
>>> [Link]
'Hafid'
>>> [Link]
'said‘
>>> [Link]()
Héritage
class Personne(object):
def __init__(self, nom, prenom=""):
print("Initialisation de la personne")
[Link] = nom
[Link] = prenom
def getNomPrenom(self):
return [Link]+ " " +[Link]
class Etudiant(Personne):
def __init__(self, numero, nom,prenom):
print("Initialisation de l'étudiant")
super(Etudiant, self).__init__( nom,prenom)
[Link] = numero
>>> e = Etudiant(15,nom='Hafid', prenom='said')
Initialisation de l'étudiant
Initialisation de la personne
>>> [Link]
'Hafid'
>>> [Link]
'said‘
>>> [Link]()
Héritage: polymorphisme
class Personne(object):
def __init__(self, nom, prenom=""):
print("Initialisation de la personne")
[Link] = nom
[Link] = prenom
def getNomPrenom(self):
return [Link]+ " " +[Link]
class Etudiant(Personne):
def __init__(self, numero, nom,prenom):
print("Initialisation de l'étudiant")
super(Etudiant, self).__init__(nom,prenom)
[Link] = numero
def getNomPrenom(self):
return "Le nom de l'étudiant: "+[Link](self)
>>> e = Etudiant(15,nom='Hafid', prenom='said')
Initialisation de l'étudiant
Initialisation de la personne
>>> [Link]
'Hafid'
>>> [Link]
'said‘
>>> [Link]()
"Le nom de l'\xe9tudiant: Hafid said"
Héritage: polymorphisme
class Personne(object):
def __init__(self, nom, prenom=""):
print("Initialisation de la personne")
[Link] = nom
[Link] = prenom
def getNomPrenom(self):
return [Link]+ " " +[Link]
class Etudiant(Personne):
def __init__(self, numero, nom,prenom):
print("Initialisation de l'étudiant")
super(Etudiant, self).__init__(nom,prenom)
[Link] = 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
>>> [Link]
'Hafid'
>>> [Link]
'said‘
>>> [Link]()
"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 • Utilisation du module
(module) python [Link] import calc
#Fichier [Link] print [Link](5,6)
def addi(a,b): from calc import addi
return a +b print addi(5,6)
def soust(a,b): soust(7,5) # erreur
return a-b 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
– [Link] contient une fonction OPE()
– Arithmetique
» [Link] contient une fonction ADD()
» [Link] 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 [Link]
def OPE(): #Fichier de test
print "module operateur" from Calcul import *
OPE()
#Fichier __init__.py dans Arithmetique [Link]()
from Add import * [Link]()
from Sous import *
#Fichier [Link] dans Arithmetique
def ADD():
print "Arithmetique --> Add"
#Fichier [Link] dans Arithmetique
def SOUS():
print "Arithmetique --> SOUS"