Cours 5 Fonctions

Institut Préparatoire des Etudes d’Ingénieurs de Tunis Dr.
Afef Ghabri
Classes : Première année MP/PC Année universitaire : 2020-2021
Les fonctions en python
I- Les sous-programmes en Algorithmique :

1. Les procédures :
1.1. Les procédures sans paramètres :
Syntaxe :
Déclaration :
Procédure nom-procédure
<déclaration de variables>
Début
< Instructions>
Fin
Appel dans le Programme principal :
nom-procédure
1.2. Les procédures avec paramètres :
Syntaxe :
Déclaration :
Procédure nom-procédure (liste des paramètres formels)
Début
<Instructions>
Fin
nom-procédure(liste des paramètres effectifs)
Exemple : Ecrire une procédure Permut qui permet de permuter 2 entiers, écrire ensuite l’algorithme
principal.
1.3. Paramètres formels et effectifs :
1
Institut Préparatoire des Etudes d’Ingénieurs de Tunis Dr. Afef Ghabri
Paramètre formel :
La déclaration de l’entête d’une procédure peut comporter après le nom de la procédure des
paramètres appelés des paramètres formels.
Paramètre effectif :
Dans le cas où la déclaration comprend des paramètres formels, chaque appel de la procédure doit
comporter des paramètres effectifs compatibles et ayant le même nombre que les paramètres
formels.
Remarque :
 Le passage des paramètres par valeurs est utilisé pour transmettre une valeur à la procédure.
 Le passage des paramètres par variables est utilisé pour que la procédure puisse modifier la
valeur d’une variable du programme appelant.
Exemple : Ecrire une procédure qui prend 3 entiers en paramètres dont le 3 ème entier contiendra la
somme des 2 premiers.
2. Les fonctions :
Une fonction est un sous-programme qui renvoie une valeur d’un seul type. Ce type sera celui de la
fonction. La valeur retournée par la fonction dépend en générale des paramètres formels et des
variables globales.
Remarque :
 Les variables globales sont des variables qui sont déclarées à l’extérieur du sous-programme.
 Les variables locales sont déclarées à l’intérieur du sous-programme.
Syntaxe :
Déclaration :
Fonction nom-fonction (liste des paramètres formels) : type du résultat retourné
Début
<Instructions>
nom-fonction  valeur
Fin
Var 1  nom-fonction (liste des paramètres effectifs)
2
Exercice : Ecrire une fonction max qui prend en paramètres 2 entiers et retourne le max des deux,
écrire ensuite un algorithme qui permet de saisir 4 entiers et utiliser la fonction max afin de
déterminer et d’afficher le maximum des 4 entiers.
II- Les fonctions sous Python :

1. Principe et généralités :
 En programmation, les fonctions sont très utiles pour réaliser plusieurs fois la même opération
au sein d’un programme. Elles permettent également de rendre le code plus lisible et plus clair
en le fractionnant en blocs logiques.
 Vous connaissez déjà certaines fonctions Python, par exemple math.cos(angle) du module math
renvoie le cosinus de la variable angle exprimé en radian. Vous connaissez aussi des fonctions
internes à Python comme range() ou len().
 En Python, une fonction est un objet qui doit être déclaré.
 À laquelle vous passez une (ou zero ou plusieurs) valeur(s) entre parenthèses. Ces valeurs
sont appelées arguments.
 Qui effectue une action. Par exemple la fonction random.shuffle() permute aléatoirement
une liste.
 Et qui renvoie éventuellement un résultat (plus précisément un objet).
 Par exemple si vous appelez la fonction len() en lui passant l’argument [0, 1, 2] :
>>> len([0, 1, 2])

3
celle-ci vous renvoie un entier indiquant la longueur de la liste passée en argument.
 Autre exemple, si vous appelez la méthode liste.append(5) (n’oubliez pas, une méthode est une
fonction qui agit sur l’objet auquel elle est attachée), append() ajoute l’entier 5 à la variable liste mais
ne renvoie rien.
Au contraire, aux yeux du programmeur une fonction est une portion de code effectuant une suite
d’instructions bien particulière.
 Une fonction effectue une tâche. Pour cela, elle reçoit éventuellement des arguments et
renvoie éventuellement un résultat. L’algorithme utilisé au sein de la fonction n’intéresse pas
directement l’utilisateur. Par exemple, il est inutile de savoir comment la fonction math.cos()
calcule un cosinus, on a juste besoin de savoir qu’il faut lui passer en argument un angle en
radian et qu’elle renvoie le cosinus de cet angle.
3
 Chaque fonction effectue en général une tâche unique et précise. Si cela se complique, il est
plus judicieux d’écrire plusieurs fonctions (qui peuvent éventuellement s’appeler les unes les
autres). Cette modularité améliore la qualité générale et la lisibilité du code. Vous verrez
qu’en Python, les fonctions présentent une grande flexibilité.
2. Pourquoi créer des fonctions ?
1- Meilleure organisation du programme (regrouper les tâches par blocs : lisibilité  maintenance)
2- Eviter la redondance (pas de copier/coller  maintenance, meilleure réutilisation du code)
3- Possibilité de partager les fonctions (via des modules)
4- Le programme principal doit être le plus simple possible
3. Qu’est-ce qu’un module sous Python ?
1- Module = fichier « .py »
2- On peut regrouper dans un module les fonctions traitant des problèmes de même nature ou
manipulant le même type d’objet
3- Pour charger les fonctions d’un module dans un autre module / programme principal, on utilise la
commande import nom_du_module
4- Les fonctions importées sont chargées en mémoire. En cas de collision de noms, les plus récentes
écrasent les anciennes.
4. Définition des fonctions :
• 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)
• Pour définir une fonction, Python utilise le mot-clé def et si on veut que celle-ci renvoie une valeur,
il faut utiliser le mot-clé return.
Syntaxe :
def nom de la fonction (liste de paramètres formels):
<bloc d'instructions>
Retour de résultat :
4
La fonction peut contenir une instruction de la forme : return expression.

Cette instruction permet de fournir le résultat de la fonction au programme appelant.
Exemple de fonction :
def f(x, n) :
xcarre = x*x
return 3*xcarre + 4*x/n + 5*n
Pour calculer le résultat d'une fonction pour certaines valeurs, le programme appelant doit appeler la
fonction en lui transmettant ces valeurs.
La syntaxe est nom de la fonction (liste de paramètres réels):
La liste des paramètres réels est constituée d'une liste d'expressions séparées par des virgules. Il est
important de respecter l'ordre des paramètres formels. La valeur de chaque expression est calculée
et devient ainsi la valeur du paramètre formel correspondant.
Exemple d’appel :
a = f(b, 4)
a = f(14.5, n) + 4*f(b, m + 12)
print( 'La valeur est : ', f(55.12, 42)
5. Passage d’arguments:
 Le nombre d’argument(s) que l’on peut passer à une fonction est variable. Dans les chapitres
précédents, vous avez vu des fonctions internes à Python qui prenaient au moins 2 arguments,
pour rappel souvenez-vous de range(1,10) ou encore range(1,10,2). Le nombre d’argument est
donc laissé libre à l’initiative du programmeur qui est en train de développer une nouvelle
fonction.
 Une particularité des fonctions en Python est que vous n’êtes pas obligé de préciser le type des
arguments que vous lui passez, dès lors que les opérations que vous effectuez avec ces
arguments sont valides. Python est en effet connu comme étant un langage au typage
dynamique, c’est-à-dire qu’il reconnaît pour vous le type des variables au moment de
l’exécution, par exemple :
>>> def fois(x,y):

return x*y
…...
>>> fois(2,3)
6
>>> fois(3.1415,5.23)
16.430045000000003
>>> fois('to',2)
'toto'
5
 Un énorme avantage en Python est que les fonctions sont capables de renvoyer plusieurs valeurs
à la fois, comme dans cette fraction de code :
>>> def carre_cube(x):
return x**2,x**3
.....
>>> carre_cube(2)
(4, 8)
En réalité Python ne renvoie qu’un seul objet, mais celui-ci peut être séquentiel, c’est à dire contenir
lui même plusieurs objets. Dans notre exemple Python renvoie un objet de type tuple.
 Notre fonction pourrait tout autant renvoyer une liste :
>>> def carre_cube2(x):
return [x**2,x**3]
.....
>>> carre_cube2(3)
[9, 27]
 Renvoyer un tuple ou une liste de deux arguments (ou plus) est notamment très pratique en
conjonction avec l’affectation multiple, par exemple :
>>> z1,z2 = carre_cube2(3)

>>> z1
9
>>> z2
27
Cela permet de récupérer plusieurs valeurs retournées par une fonction et les affecter à des variables
différentes à la volée.
 Enfin, il est possible de passer un ou plusieurs argument(s) de manière facultative et de leur

attribuer une valeur par défaut :
>>> def useless_fct(x=1):

return x
...
>>> useless_fct()
1
>>> useless_fct(10)
10
6
Notez que si on passe plusieurs arguments à une fonction, le ou les arguments facultatifs doivent
être situés après les arguments obligatoires. Il faut donc écrire def fct(x, y, z=1) :.
Exemple :
def petit (a, b):

if (a < b):
d=a
else:
d=0
return d
• def pour dire que l’on définit une fonction
• Le nom de la fonction est « petit »
• Les paramètres ne sont pas typés
• Noter le rôle du :
• Attention à l’indentation
• return renvoie la valeur
• return provoque immédiatement la sortie de la fonction
Procédure = Fonction sans return
>>> def hello():

print("bonjour")
.....
>>> hello()
bonjour
Dans ce cas la fonction hello() se contente d’imprimer la chaîne de caractères "Bonjour" à l’écran.
Elle ne prend aucun argument et ne renvoie aucun résultat. Par conséquent, cela n’a pas de sens de
vouloir récupérer dans une variable le résultat renvoyé par une telle fonction. Si on essaie tout de
même, Python affecte la valeur None.
>>> x = hello()
bonjour
>>> print(x)
None
6. Appels des fonctions :
7
6.1. Passage de paramètres par position :
print(petit(10, 12))
Passer les paramètres selon les positions attendues. La fonction renvoie 10
6.2. Passage par nom :
print(petit(a=10,b=12))
Aucune confusion possible  La fonction renvoie 10
print(petit(b=12,a=10))
Aucune confusion possible  10
En revanche, sans instructions spécifiques, le passage par position prévaut
print(petit(12,10))
La fonction renvoie  0
6.3. Un exemple de programme :
Définition de la fonction
Programme principal
Appel de la fonction dans le

programme principal (on peut
faire l’appel d’une fonction
dans une autre fonction)
8
 2 exécutions du programme :
7. Exemples :
7.1. Un ou plusieurs paramètres, pas de retour :
Exemple sans l’instruction return, ce qu’on appelle souvent une procédure (Une fonction vaut
quelque chose, une procédure fait quelque chose). Dans ce cas la fonction renvoie implicitement la
valeur None :
def table(base, debut, fin):
"""Affiche la table de multiplication des <base> de <debut> à <fin>."""
n = debut
while n <= fin:
print(n, 'x', base, '=', n * base)
n += 1
# exemple d'appel :
table(7, 2, 8)
# 2 x 7 = 14 3 x 7 = 21 4 x 7 = 28 5 x 7 = 35 6 x 7 = 42 7 x 7 = 49 8 x 7 = 56
# autre exemple du même appel, mais en nommant les paramètres ;

table(base=7, debut=2, fin=8)
7.2. Un ou plusieurs paramètres, utilisation du retour :
Exemple avec utilisation d’un return unique :

from math import pi
def cube(x):
"""Retourne le cube de l’argument."""
return x**3
def volumeSphere(r):
"""Retourne le volume d'une sphère de rayon <r>;"""
return 4.0 * pi * cube(r) / 3.0
# Saisie du rayon et affichage du volume

rayon = float(input('Rayon : '))
print("Volume de la sphère =", volumeSphere(rayon))
9
Exemple avec utilisation d’un return multiple :
import math
def surfaceVolumeSphere(r):
surf = 4.0 * math.pi * r**2
vol = surf * r/3
return surf, vol
# programme principal
rayon = float(input('Rayon : '))
s, v = surfaceVolumeSphere(rayon)
print("Sphère de surface {:g} et de volume {:g}".format(s, v))
7.3. Passage d’une fonction en paramètre :
Puisque en Python une variable peut référencer une fonction, on peut transmettre une fonction
comme paramètre :
>>> def f(x):

return 2*x+1
...
>>> def g(x):
return x//2
...
>>> def h(fonc, x):
return fonc(x)
...
>>>
>>> h(f, 3)
7
>>> h(g, 4)
2
7.4. Paramètres avec valeur par défaut :
Il est possible de spécifier, lors de la déclaration, des valeurs par défaut à utiliser pour les arguments.
Cela permet, lors de l’appel, de ne pas avoir à spécifier les paramètres correspondants. Il est possible,
en combinant les valeurs par défaut et le nommage des paramètres, de n’indiquer à l’appel que les
paramètres dont on désire modifier la valeur de l’argument. Il est par contre nécessaire de regrouper
tous les paramètres optionnels à la fin de la liste des paramètres.
>>> def accueil(nom, prenom, depart="MP", semestre="S2"):

print(prenom, nom, "Département", depart, "semestre", semestre)
...
>>> accueil("Student", "Joe")
Joe Student Département MP semestre S2
>>> accueil("Student", "Eve", "Info")
Eve Student Département Info semestre S2
>>> accueil("Student", "Steph", semestre="S3")
Steph Student Département MP semestre S3
10
Attention
On utilise de préférence des valeurs par défaut non modifiables (int, float, str, bool, tuple) car la
modification d’un paramètre par un premier appel est visible les fois suivantes. Si on a besoin d’une
valeur par défaut qui soit modifiable (list, dict), on utilise la valeur prédéfinie None et on fait un test
au début de la fonction :
def maFonction(liste=None):
if liste is None:
liste = [1, 3]
7.5. Nombre d’arguments arbitraire : passage d’un tuple de valeurs :
Il est possible d’autoriser le passage d’un nombre arbitraire d’arguments en utilisant la notation d’un
argument final *nom. Les paramètres surnuméraires sont alors transmis sous la forme d’un tuple
affecté à cet argument (que l’on appelle généralement args).
def somme(*args):
"""Renvoie la somme du tuple <args>."""
resultat = 0
for nombre in args:
resultat += nombre
return resultat
# Exemples d'appel :
print(somme(23)) # 23
print(somme(23, 42, 13)) # 78
Attention
Si la fonction possède plusieurs arguments, le tuple est en dernière position.
Réciproquement il est aussi possible de passer un tuple (en fait une séquence) à l’appel qui sera
décompressé en une liste de paramètres d’une fonction « classique » :
def somme(a, b, c):

return a+b+c
# Exemple d'appel :
elements = (2, 4, 6)
print(somme(*elements)) # 12
7.6. Nombre d’arguments arbitraire : passage d’un dictionnaire :
De la même façon, il est possible d’autoriser le passage d’un nombre arbitraire d’arguments nommés
en plus de ceux prévus lors de la définition en utilisant la notation d’un argument final **nom. Les
paramètres surnuméraires nommés sont alors transmis sous la forme d’un dictionnaire affecté à cet
argument (que l’on appelle généralement kwargs pour keyword args).
11
Réciproquement, il est aussi possible de passer un dictionnaire à l’appel d’une fonction, qui sera
décompressé et associé aux paramètres nommés de la fonction.
def unDict(**kwargs):
return kwargs
# Exemples d'appels
## par des paramètres nommés :
print(unDict(a=23, b=42)) # {'a': 23, 'b': 42}
## en fournissant un dictionnaire :
mots = {'d': 85, 'e': 14, 'f':9}
print(unDict(**mots)) # {'e': 14, 'd': 85, 'f': 9}
Attention
Si la fonction possède plusieurs arguments, le dictionnaire est en toute dernière position (après un
éventuel tuple).
8. Portée des objets :

 Portée : les noms des objets sont créés lors de leur première affectation, mais ne sont visibles
que dans certaines régions de la mémoire.
On distingue :
La portée globale : celle du module ou du fichier script en cours. Un dictionnaire gère les objets
globaux : l’instruction globals() fournit les couples variable :valeur.
La portée locale : les objets internes aux fonctions sont locaux. Les objets globaux ne sont pas
modifiables dans les portées locales. L’instruction locals() fournit les couples variable :valeur.
 Exemples de portée :
Par défaut, toute variable utilisée dans le corps d’une fonction est locale à celle-ci. Si une fonction a
besoin de modifier certaines variables globales, la première instruction de cette fonction doit être :
global <identificateurs>
# x et fonc sont affectés dans le module : globaux
def fonc(y): # y et z sont affectés dans fonc : locaux

global x # permet de modifier x ligne suivante
x += 2
z=x+y
return z
x = 99
print(fonc(1)) # 102
print(x) # 101
12
def fonc(y): # y et z sont affectés dans fonc : locaux

# dans fonc : portée locale
z=x+y
return z
x = 99
print(fonc(1)) # 100
print(x) # 99
def fonc(y): # y, x et z sont affectés dans fonc : locaux

x=3 # ce nouvel x est local et masque le x global
z=x+y
return z
x = 99
print(fonc(1)) #4
print(x) # 99
9. Fonction anonyme : lambda

Python permet une syntaxe intéressante qui vous laisse définir des mini-fonctions d’une ligne à la
volée. Vous pouvez utiliser une fonction lambda sans l’assigner à une variable. Ce n’est pas
forcément très utile, mais cela démontre qu’une fonction lambda est simplement une fonction en
ligne.
Plus généralement, une fonction lambda est une fonction qui prend un nombre quelconque
d’arguments (y compris des arguments optionnels) et retourne la valeur d’une expression unique.
Les fonctions lambda ne peuvent pas contenir de commandes et elles ne peuvent contenir plus d’une
expression. N’essayez pas de mettre trop de choses dans une fonction lambda, si vous avez besoin
de quelque chose de complexe, définissez plutôt une fonction normale et faites la aussi longue que
vous voulez.
Syntaxe : lambda var1, var2, ..., varN: une_expression
Appel :
(lambda x: x*2)(3) # définition et appel simultanés
Exemple :
>>> f = lambda x, y: x + y
>>> f(3, 5)
13

Cours 5 Fonctions

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours 5 Fonctions

Transféré par

Droits d'auteur :

Formats disponibles

Institut Préparatoire des Etudes d’Ingénieurs de Tunis Dr.

Les fonctions en python

I- Les sous-programmes en Algorithmique :

Appel dans le Programme principal :

1.2. Les procédures avec paramètres :

Procédure nom-procédure (liste des paramètres formels)

Appel dans le Programme principal :

nom-procédure(liste des paramètres effectifs)

1.3. Paramètres formels et effectifs :

Fonction nom-fonction (liste des paramètres formels) : type du résultat retourné

Appel dans le Programme principal :

Var 1  nom-fonction (liste des paramètres effectifs)

II- Les fonctions sous Python :

>>> len([0, 1, 2])

2- Eviter la redondance (pas de copier/coller  maintenance, meilleure réutilisation du code)

3- Possibilité de partager les fonctions (via des modules)

4- Le programme principal doit être le plus simple possible

3. Qu’est-ce qu’un module sous Python ?

1- Module = fichier « .py »

4. Définition des fonctions :

• Fonction  Bloc d’instructions

• Prend (éventuellement) des paramètres en entrée (non typés)

def nom de la fonction (liste de paramètres formels):

La fonction peut contenir une instruction de la forme : return expression.

La syntaxe est nom de la fonction (liste de paramètres réels):

>>> def fois(x,y):

>>> def carre_cube(x):

 Notre fonction pourrait tout autant renvoyer une liste :

>>> def carre_cube2(x):

>>> z1,z2 = carre_cube2(3)

 Enfin, il est possible de passer un ou plusieurs argument(s) de manière facultative et de leur

>>> def useless_fct(x=1):

def petit (a, b):

• def pour dire que l’on définit une fonction

• Le nom de la fonction est « petit »

• Les paramètres ne sont pas typés

• return renvoie la valeur

• return provoque immédiatement la sortie de la fonction

Procédure = Fonction sans return

>>> def hello():

6. Appels des fonctions :

6.1. Passage de paramètres par position :

Passer les paramètres selon les positions attendues. La fonction renvoie 10

6.2. Passage par nom :

Aucune confusion possible  La fonction renvoie 10

Aucune confusion possible  10

En revanche, sans instructions spécifiques, le passage par position prévaut

6.3. Un exemple de programme :

Appel de la fonction dans le

# autre exemple du même appel, mais en nommant les paramètres ;

7.2. Un ou plusieurs paramètres, utilisation du retour :

Exemple avec utilisation d’un return unique :

# Saisie du rayon et affichage du volume

Exemple avec utilisation d’un return multiple :

7.3. Passage d’une fonction en paramètre :

>>> def f(x):

7.4. Paramètres avec valeur par défaut :

>>> def accueil(nom, prenom, depart="MP", semestre="S2"):

7.5. Nombre d’arguments arbitraire : passage d’un tuple de valeurs :

Si la fonction possède plusieurs arguments, le tuple est en dernière position.

def somme(a, b, c):

7.6. Nombre d’arguments arbitraire : passage d’un dictionnaire :

8. Portée des objets :

# x et fonc sont affectés dans le module : globaux