Fonction
De manière générale:
def non_fonction(paramètres):
bloc d’instructions
❑ (paramètres) peut être =() (c’est-à-dire vide, pas de paramètres) Exemple:
def f ():
print(‘Bonjour)
# l’appel à f f()
Bonjour
❑ Dans ce bloc d’instruction il peut y avoir l’instruction return (…).
Exemple:
def f(x,y):
return (x+y)
La notion de fonction
Fonction
❑ Si dans ce bloc il n’y pas l’instruction return la fonction retourne None Rappelant que: if (None) est False.
❑ Dans bloc instruction on peut avoir plusieurs fois l’instruction return, la Première rencontrée fait sortir du bloc. Exemple:
def f(a,b,c):
if (a<10):
return b else :
return c
❑ En python tout est objet, y compris les fonctions.
Soit def f(x):
return x*x
Comme f est la variable qui contient la référence l’objet, on peut donc faire g=f. Et donc exécuter g(5) par exemple.
De manière générale:
def non_fonction(arguments):
bloc d’instructions
La notion de fonction
❑ Les arguments sont des références sur les objets en question.
Exemple:
def f(L):
L.append(3) T=[2,8]
f(T)
print(T) affichera la liste [2,8,3]
Que s’est il passé? Pourquoi T a été changée par la fonction f?
La réponse est
La notion de fonction
Une fonction retourne toujours quelque chose:
def f(l):
for x in l:
print (x)
Cette fonction f retourne None.
def g(l):
for x in l :
print (x) return ‘Fin’
La fonction g retourne ‘Fin’
Valeur de retour d’une fonction
1) Programmer la fonction F(x) = x2+4x + 8 def F(x):
return x**2 + 4*x +8
# Appel F(4)F(7.9)
2) Ecrire la fonction fact(n) qui retourne la factorielle de n.
Rappel n! = n*(n-1)*(n-2) *……. *3*2*1 def fact(n):
res=1, i=n while (i ≥ 1):
res=res*i i=i-1
return res fact(3)
6
Exemples de fonctions
Fonction lambda
Une fonction peut être définie par :
❑ par def, déjà vu
❑Ou en utilisant la notion de lambda.
❑Toute fonction lambda peut être définie en utilisant def mais l’inverse n’est pas vrai.
❑ L’intérêt d’utiliser la notion lambda sera vu plus loin, lorsque
on aura vu la notion de définition (liste, ensemble, etc) par compréhension.
f= lambda x:x**2
# l’appel f(3)f(5.9)
Exemple
def f(x):
return x**2
# appel f(3)f(5.9) La même fonction f
Avec def Avec lambda
Les arguments d’une fonction
❑ Une fonction peut avoir autant d’arguments souhaités def f(x,y, z, r):
bloc instruction
❑ Certains arguments peuvent être initialisés par défaut:
def f(x,y, z=0, r=1):
Bloc d’instruction z vaut 0 et r vaut 1.
Attention:
Les arguments initialisés doivent être en derniers dans la liste
❑ Une fonction peut ne pas avoir d’arguments:
def f():
print(‘Bonjour’)
La fonction: zip() La fonction Zip():
Exemple:
villes= [ ‘Casablanca’, ‘Rabat’, ‘Fes’, ‘Agadir’]
populations=[ 5*106, 3*106, 2*105, 2*106], le nombre de populations respectivement des villes Casablanca, Rabat, Fquih Ben Salah et Agadir.
L= zip(villes, populations], donne la liste suivante:
L =[ (‘Casablanca’,5*106 ) , (‘Rabat’, 3*106) , (‘Fes’, 2*105 ), (‘Agadir’, 2*106) ] Tester ce code:
for v, p in zip(villes, populations):
print(v,p) for i,j in zip(range(3), range(10)):
print(i,j)
La Fonction enumerate()
Exemple d’utilisation de enumerate:
villes=[ ‘Casablanca’, ‘Rabat’, ‘Fes’, ‘Agadir’]
for i,x in enumerate(villes):
print(i,v) Affichera:
0 Casablanca
1 Rabat
2 Fes
3 Agadir
Portées des Variables
a=7 b=10
def f(x,y):
z=12 b=13
print(a,b,x,y,z)
# appel f(2,3)
print(a,b)
Que voit-on comme affichage?
Règle appliquée: L.E.G.
Lors de l’évaluation d’une variable (dans le corps d’une fonction), si la variable est Locale, sa valeur est prise, sinon si la variable est dans une fonction Englobant, sa valeur est prise, sinon la valeur Globale est prise.
La règle LEG a=9 def g(a):
z=10
def f (x,y):
return (x+y+b+z) b=7
return (a+f(3,5)) g(5)
La valeur est 30, pourquoi? (La règle L.E.G)
La fonction g
La fonction f
g englobe f
