Python
Pr. A. Zahi & Pr, S, NAJAH
Programmation
modulaire
Plan
◼ Définition et appel d’une fonction
◼ L’instruction return
◼ Paramètres d’une fonction
◼ Modules
3
Fonction
◼ Pour quoi les fonctions ?
La réutilisation du code : éviter de répéter les mêmes
séries d’instructions à plusieurs endroits d’un programme
La modularité : découper une tâche complexe en
plusieurs sous-tâches plus simples.
La lisibilité : corriger les erreurs et modifier le code plus
facilement
4
Fonction
◼ C’est quoi une fonction?
Bloc d’instructions
Prend (éventuellement) des paramètres en entrée
(non typés)
Renvoie une valeur en sortie (ou plusieurs valeurs, ou
pas de valeurs du tout : procédure)
5
Fonction
Exécution du code 2
Une fonction est de la fonction
considérée comme
une boite noire
1 Renvoi d’un 3
objet résultat
Appel la fonction et
transmet les arguments
6
Fonction
◼ Exemple 1: la fonction print
>>> R = 2
>>> print(" Valeur = ",R)
Valeur = 2
Se déroule comme suit:
Les arguments sont passés à la fonction print
La fonction affiche à l’écran la valeur des arguments
7
Fonction
◼ Exemple 2: la fonction len
>>> len([1,2,4])
3
Se déroule comme suit:
L’ argument, ici la liste [1,2,4], est passé à la fonction
La fonction calcule le nombre d’éléments
Retourne le résultat
8
Définition d’une fonction- def
◼ Syntaxe
def nomFonct(paramètres): #prototype de la fonction
bloc #corps de la fonction
return valeurs
def: mot clé qui définit la fonction
nomFonct: le nom de la fonction
paramètres: la liste des paramètres
return: mot clé qui retourne l’objet résultat de la fonction.
9
Appel d’une fonction
◼ Syntaxe
def nomFonct(paramètres): #prototype de la fonction
bloc #corps de la fonction
return valeurs
nomFonct(arguments) #appel de la fonction
arguments : constantes, variables ou expressions sur les
quelles la fonction va s’exécuter
10
Définition et appel d’une fonction
◼ Exemple
#argument: une constant
#définition de la fonction fact(4)
def fact(n):
f = 1 #argument: une variable
for i in range(1,n+1): a = 2
f *= i fact(a)
print(f)
#argument: une expression
b = 1
fact(2*a + b)
Appel s de la
fonction fact
11
L’instruction return
◼ Renvoie les résultats de la fonction et la quitte
Si d est un diviseur on quitte la
#définition de la fonction boucle sans tester les autres
def premier(n): entiers (cas n=8)
if n <= 1:
return False
for d in range(2, n//2 + 1):
if n % d == 0:
return False
return True
Arrive ici après avoir tester
#appel de la fonction tous les entiers inférieurs à
print(premier(8)) n/2 (cas de n= 11)
print(premier(11))
12
L’instruction return
◼ Peut renvoyer plusieurs valeurs simultanément.
#Fonction qui calcule le quotient et le reste de la division de n par m
def QuotientReste(n,m):
q = 0
while n>=m:
q=q+1
n=n-m
return q,n
13
L’instruction return
◼ Récupération des résultats lors du renvoi de plusieurs
valeurs Affectation multiple
#Appel de la fonction Affiche des valeurs séparées:
n = 15 res1: 2,3
m = 6
quotient,reste = QuotientReste(n,m)
print(“ res1: ”, quotient,reste )
Une seule affectation
res2 = QuotientReste(n,m)
print(“res2: “,res2) Affiche un tuple:
res2: (2,3)
14
L’instruction return
◼ Une fonction peut ne pas contenir l’instruction return et
peut ne renvoyer aucune valeur.
Python renvoie dans ce cas la valeur None
#définition de la fonction qui affiche les diviseurs d'un nombre
def diV(n):
for x in range(1,n+1):
if n%x == 0: Affiche les valeurs :
print(x) 1
3
#appel de la fonction 9
None
diV(9)
15
Paramètres avec valeurs par défaut
◼ Une valeur par défaut peut être attribuée à un paramètre
lors de la définition de la fonction
◼ Syntaxe
def maFonction(param = val):
bloc
Si l’utilisateur spécifie une valeur, c’est bien cette dernière qui
est utilisée
Si l’utilisateur omet le paramètre lors de l’appel, la valeur par
défaut sera utilisée
16
Paramètres avec valeurs par défaut
◼ Les paramètres classiques peuvent coexister avec les
arguments par défauts.
Attention !! Les paramètres avec des valeurs
par défaut doivent être regroupés en
dernière position
def maFonction(x = 1 ,y): def maFonction(x ,y = 1):
print(x + y) print(x + y)
17
Paramètres avec valeurs par défaut
◼ Paramètres avec valeurs par défaut : Exemple
def afficherInfo( nom, adresse, age = 35 ):
print ("Nom: ", nom)
print ("Age: ", age)
print ("Adresse: ",adresse)
#appels de la fonction
afficherInfo("zaid","5, Avenue Sebou, Rabat",25 )
afficherInfo("amr","8, Avenue ziz, Casa")
Nom: zaid
Nom: amr
Age: 25 #valeur fournie
Age: 35 #valeur par défaut
Adresse: 5, Avenue Sebou, Rabat
Adresse: 8, Avenue ziz, Casa
18
Passage des paramètres
◼ Python adopte un passage par référence; les paramètres
sont toujours passés par référence.
◼ Les paramètres sont modifiables selon
qu’ils sont mutables (dictionnaire*, liste*, etc.)
non mutables (types simples, tuples*, etc.).
19
Passage des paramètres
◼ Exemple
#définition de la fonction
def fonct(x):
print("id de x avant modification", id(x))
x= 10
print("id de x après modification", id(x))
#appel de la fonction
a = 2
fonct(a)
print("valeur de a après appel :" , a)
print("id de a après appel", id(a))
20
Passage des paramètres
◼ Exemple
id de a avant appel 9788640
Transfert de la référence
de a au paramètre x
id de x avant modification
9788640
Run Changement de l’espace
id de x après modification après l’affectation
9788896
Dans la fonction
valeur de a après appel : 2
Retour à l’espace initial
id de a après appel 9788640
21
Passage des paramètres
◼ Deux manières :
Passage par position : Passer les paramètres selon les positions
attendues (ordre défini lors de la définition);
Passage par nom. Passer les arguments selon un ordre
quelconque, mais en spécifiant le nom du paramètre
◼ Le mode de passage par nom est préconisé, d’autant plus
que les paramètres ne sont pas typés.
22
Passage des paramètres
◼ Passage par nom : Exemple
#definition de la fonction
def afficherInfo( nom, adresse, age = 35 ):
print ("Nom: ", nom)
print ("Age: ", age)
print ("Adresse: ",adresse)
#appels de la fonction
afficherInfo(adresse = "5, Avenue Sebou, Rabat",nom="zaid", age = 25 )
Nom: zaid
Run Age: 25
Adresse: 5, Avenue Sebou, Rabat
23
Passage des paramètres
◼ Passage par nom et arguments par défaut
#definition de la fonction Erreur
!!! Ambigüité, tentative d’affecter
deux valeurs à nom
def afficherInfo( nom, adresse, age = 35 ):
print ("Nom: ", nom)
print ("Age: ", age)
print ("Adresse: ",adresse)
#appels de la fonction
afficherInfo(adresse = "5, Avenue Sebou, Rabat",nom="zaid", age = 25 )
afficherInfo("zaid", age=25, adresse = "5, Avenue Sebou, Rabat" )
afficherInfo(25, nom= "zaid", adresse = "5, Avenue Sebou, Rabat" ) 24
Paramètres et arguments
◼ Nombre variable d’arguments: l'emballage de tuple
Un seul argument préfixé par '*'
Syntaxe
def maFonction(arg1,arg2,*args):
bloc
args: liste des arguments fournie sous forme d’un tuple
args est utilisée dans la fonction sans ‘*’
25
Paramètres et arguments
◼ Nombre variable d’arguments: l'emballage de tuple
# définition de la fnction
20
def afficheInfo( arg1,arg2, *listeArg):
10 20
print(arg1)
------------ 10
print(arg2)
('zaid', 25) ------------
print("------------")
zaid ('zaid', 25, 'rabat')
print(listeArg)
25 zaid
for var in listeArg:
print(var) 25
rabat
# Appel de la fnction
afficheInfo( 20,10,"zaid",25 )
afficheInfo( 20,10,"zaid",25,"rabat" )
26
Fonction anonyme
◼ Une fonction très courte déclarée à l’aide du mot clé lambda et
non à l’aide du mot clé def
lambda arg1, arg2, …, argn:expression
Pas d'instructions comme if, for ou while, seulement une expression.
Pas de return, l'expression est automatiquement retournée
N’a pas accès aux variables autres que celles figurant dans ses
paramètres
27
Fonction anonyme
◼ Exemple
#surface d'un cercle
surface = lambda rayon: rayon*rayon*22/7
#appel de la fontion
s1=surface(3)
print(s1)
s2=surface(5)
print(s2)
28.285714285714285
Run
78.57142857142857
28
Fonction comme objet
◼ Une fonction est considérée comme un objet ; elle
possède un type et un identifiant
>>> type(maFonct)
def <class 'function'>
maFonct(v):
return v*v >>> id(maFonct)
914192039360
29
Fonction comme objet
◼ Une fonction peut être un paramètre d’une autre fonction
from math import cos Calcule l’image d’un vecteur par une
def f1(v): fonction donnée en paramètre
return v*v
def f2(v): #Programme principal
return cos(v) X=[1, 5, 7,4]
def imageVect(f,X):
Y1=imageVect(f1,X)
Y=[]
Y2=imageVect(f2,X)
for i in range(0,len(X)): print(Y1)
[Link](f(X[i])) print(Y2)
return Y
30
Fonction comme objet
◼ Une fonction peut retourner une autre fonction
def ConstFonct(a): Construit une fonction à
def f(x): partir d’un paramètre
return a*x
return f
#Programme principal
def imageVect(f,X): X=[1, 5, 7,4]
Y=[] f= ConstFonct(2)
for i in range(0,len(X)): Y=imageVect(f,X)
[Link](f(X[i]))
print(Y)
return Y
31
Porté des variables
◼ Variable locale : définie dans une fonction; elle n’est pas
visible dans les autres fonctions
◼ Variable globale : définie dans la mémoire d’un
programme; elle n’est pas accessible dans les fonctions
◼ Une variable globale peut être accessible à l’aide du mot
clé global
32
Porté des variables
#fonction #fonction #fonction
def maFonct1(v): def maFonct2(v): def maFonct3(v):
x = v x = x + v global x
x = x + v
#appel #appel #appel
x = 10 x = 10 x = 10
maFonct1(5) maFonct2(5) maFonct3(5)
print(x) print(x) print(x)
x est référencée avant La fonction utilise la
x est une variable locale,
d’avoir une valeur variable x du programme
pas de changement
principale
Affiche : 10 Affiche: Erreur
Affiche : 15
33
Module
◼ Objet Python avec des attributs nommés arbitrairement
que vous pouvez lier et référencer
◼ Permet d’organiser logiquement le code Python
◼ Rend le code plus facile à comprendre et à utiliser.
34
Module
◼ Peut définir des fonctions, des classes et des variables et
peut également inclure du code exécutable.
◼ Peut être importé et utilisé dans le programme principal
ou dans d’autres modules.
◼ Modules prédéfinis définis: random, math, os, matplotlib,
etc.
35
Comment importer des modules?
◼ Importation à l’aide de l’instruction import
import nomModule
Accès aux objets du module : nomModule .nomObjet
import math “importation du module math”
def surface(r):
"Surface dun cercle de rayon r”
s=r*r*[Link]
28.285714285714285
return s
s=surface(3)
print(s)
36
Comment importer des modules?
◼ Importation à l’aide de l’instruction import avec un
« alias »
import nomModule as alias
Accès aux objets du module : alias .nomObjet
import math as m “importation du module math”
def surface(r):
"Surface dun cercle de rayon r”
s=r*r*[Link] 28.285714285714285
return s
s=surface(3)
print(s) 37
Comment importer des modules?
◼ Importation d’objets spécifiques à l’aide de l’instruction
from
from nomModule import nomObj
Accès à l’objet avec son nom sans référencer le module
from math import pi “importation de l’objet pi ”
def surface(r):
"Surface dun cercle de rayon r”
s=r*r*pi
return s 28.285714285714285
s=surface(3)
print(s)
38
Comment importer des modules?
◼ Importation de tous les objets à l’aide de l’instruction from
from nomModule import *
Accès à l’objet avec son nom sans référencer le module
from math import * “importation de tous les objets ”
def racineDeux():
“racine carr de 2”
r = 2*sin(pi/4)
return r 1.41421356237309
s= racineDeux()
print(s)
39
Comment créer un module personnalisé?
◼ Créer un fichier .py et y implémenter les objets partagés
from math import cos
def f1(v): Enregistré sous le
return v*v nom [Link]
def f2(v):
return cos(v)
def imageVect(f,X):
Y=[]
for i in range(0,len(X)):
[Link](f(X[i]))
return Y
40
Comment créer un module personnalisé?
◼ Invoquer le module crée dans le programme principale ou
dans d’autres fonctions
#Programme principal
from monModule import *
X=[1, 5, 7,4] Enregistré sous le
Y1=imageVect(f1,X) nom [Link]
Y2=imageVect(f2,X)
print(Y1)
print(Y2)
41