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)
Y.append(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)
Y.append(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*math.pi
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*m.pi 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 monModule.py

def f2(v):
return cos(v)
def imageVect(f,X):
Y=[]
for i in range(0,len(X)):
Y.append(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 monProg.py
Y2=imageVect(f2,X)
print(Y1)
print(Y2)

41