1 Définition et Appel d`une fonction

Universit´e de Provence Algorithmique et
Licence Math-Info Programmation en Python
Premi`ere Ann´ee
V. Phan Luong
Cours 4 : Fonctions
La construction de fonctions dans un langage de programmation permet aux program-
meurs d’enrichir la fonctionnalit´e du langage et faciliter les r´ealisations des tˆaches des
applications. En effet, pour r´ealiser une application complexe, un programmeur peut suc-
cessivement la d´ecomposer en plusieurs tˆaches simples. Une tˆache complexe peut faire
appel `a un certain nombre de tˆaches simples. Ces tˆaches peuvent se structurer en une
hi´erarchie dont l’application est au sommet de l’hi´erarchie. Chaque tˆache est d´efinie par
une fonction. L’appel d’une fonction faire ex´ecuter la tˆache correspondante. Une fonc-
tion peut d´efinir avec des param`etres et peut retourner une valeur comme une fonction
en math´ematiques. En programmation, une fonction peut ne pas avoir de param`etres et
peut ne pas retourner de valeur. Elle peut simplement r´ealiser un certaine nombre de
tˆaches comme l’impression de messages ou la saisie des valeurs au clavier et les mettre
en m´emmoire centrale. Lors de l’appel d’une fonction (pour faire ex´ecuter la tˆache cor-
respondante), si ses param`etres existent, les valeurs effectives de ceux-ci (appel´ees les
arguments) sont substitu´ees de mani`ere respective les param`etres dans le corps de la
fonction. Et la valeur retourn´ee sont calcul´ee en fonction de ces arguments.
Ce cours explique la construction et l’appel de fonction en Python.
1 D´efinition et Appel d’une fonction
La syntaxe pour d´efinir une fonction :
def nomdefonction(liste_de_parametres) :
bloc_instructions
Le bloc instructions effectue les calculs pour r´ealiser les tˆaches confi´ees `a la fonction
d´efinie. Les calculs peuvent produire de nouvelles valeurs que l’on peut renvoyer dans
une expression (affecter `a variable, utiliser comme arguments d’une autre fonction).
1

Pour cela, on utilise l’instruction return valeur (ou return tuple de valeurs). Lors qu’une
instruction return valeur est ex´ecut´ee dans le bloc, la valeur est renvoy´ee et l’ex´ecution
de la fonction s’arrˆete ; toutes autres instructions apr`es cette instruction return valeur
sont abandonn´ees. Dans le bloc instructions on peut avoir plusieurs instructions return,
mais une seule return sera ex´ecut´ee.
Exemple 1 :
# Recherche le premier ´el´ement maximal dans une liste ou
#dans une chaine de caract`eres
def max_list(L) :
k = len(L)
max, x = L[0], 0
i=1
while i < k :
if max < L[i]:
max = L[i]
x=i
i=i+1
return max, x
La fonction max list() a un seul param`etre qui peut ˆetre une liste, un tuple, ou une
chaine de caract`eres ; ceci est d´eduit de la syntaxe L[i]. La fonction retourne un tuple de
deux ´el´ements qui repr´esentent respectivement l’index de la premi`ere valeur maximale
de la liste et la valeur elle-mˆeme.
Notons qu’un tuple peut ˆetre consid´er´e comme une liste sauf que
– l’on ne peut pas modifier ses ´el´ements une fois qu’ils sont d´efinis, et
– qu’il a la syntaxe de repr´esentation entour´ee par les parenth`eses, par exemple (3, ’abc’),
et non pas entour´ee par les crochets.
Une fois une fonction est d´efinie, pour l’utiliser on l’appelle avec des arguments ad´equats :
Appels de max list avec une liste de nombres comme argument.
print max_list([4,5,6,9,12,5,10,3,18,5,6,7])
2

ou par affectation `a une variable :
couple = max_list([4,5,6,9,12,5,10,3,18,5,6,7])
print ’Max de L est ’, couple[0]
print ’et se trouve `a la position ’, couple[1]
Appels de max list avec une chaine de caract`eres comme argument.
print max_list(’totovaaumarche’)
ou par affectation `a une variable :
couple = max_list(’totovaaumarche’)
print ’Max de L est ’, couple[0]
print ’et se trouve `a la position ’, couple[1]
2 D´efinir des fonctions dans un programme
Les fonctions d´efinies par un programmeur peuvent ˆetre consid´er´ees comme les nouveaux
op´erateurs qui enrichissent le langage. Le principe est que les fonctions doivent ˆetre
d´efinies avant leurs appels (ou avant de les faire ex´ecuter) Autrement le compilateur
(ou l’interpr´eteur) peut ne pas connaˆıtre la fonction qu’il appel. Une exception : dans
le corps d’une fonction r´ecursive, on peut faire appel `a une fonction qui est en cours de
d´efinir.
En g´en´eral, dans un fichier de programme, si l’on veut d´efinir de nouvelles fonctions, alors
leurs d´efinitions doivent pr´ec´eder leurs appels. Ce qui suit est un fichier de programme
utilisant l’exemple ci-dessus.
# Fichier max_liste.py
################# Partie de d´efinitions de fonctions #################
# Recherche le premier ´el´ement maximal dans une liste ou
#dans une chaine de caract`eres
def max_list(L) :
k = len(L)
3

max, x = L[0], 0
i=1
while i < k :
if max < L[i]:
max = L[i]
x=i
i=i+1
return max, x
################# Partie d’ex´ecution: instructions et appels de fonctions
print max_list([4,5,6,9,12,5,10,3,18,5,6,7])
couple = max_list([4,5,6,9,12,5,10,3,18,5,6,7])
print ’Max de L est ’, couple[0]
print ’et se trouve `a la position ’, couple[1]
print max_list(’totovaaumarche’)
couple = max_list(’totovaaumarche’)
print ’Max de L est ’, couple[0]
print ’et se trouve `a la position ’, couple[1]
##################### Fin du Fichier de Programme ####################
L’ex´ecution directe du programme (fichier max liste.py) en utilisant la commande py-
thon max liste.py commence par la cr´eation de la fonction dans l’espace du programme.
Ensuite, l’ex´ecution dans cette espace les instructions de la partie d’ex´ecution.
3 D´efinir des fonctions dans un fichier s´epar´e
Les fonctions peuvent ˆetre d´efinies dans un fichier et le programme dans un autre fichier
s´epar´e. Dans ce cas, pour pouvoir ˆetre ex´ecut´e directement avec la commande python
nomfichierprogramme.py, le fichier du programme doit importer d’abord les fonctions du
fichier dans lequel les fonctions sont d´efinies.
Pour l’exemple ci-dessus, on ´edite deux fichiers s´epar´es :
4

1) Fichier de fonctions :
# Fichier fonc_max_liste.py
# Recherche le premier ´el´ement maximal dans une liste ou
#dans une chaine de caract`eres
def max_list(L) :
k = len(L)
max, x = L[0], 0
i=1
while i < k :
if max < L[i]:
max = L[i]
x=i
i=i+1
return max, x
2) Fichier de programme : Pour utilser les fonctions d´efinies dans d’autres fichiers,
le fichier de programme doit commencer par les instructions qui importent ces fichiers
de fonctions ou directement les fonctions de ces fichiers. Dans la syntaxe ci-dessous, on
importe une ou toutes les fonctions du fichier fonc max list.
# Fichier prog_max_list.py
from fonc_max_list import max_list
# ou plus simple:
# from fonc_max_list import *
print max_list([4,5,6,9,12,5,10,3,18,5,6,7])
couple = max_list([4,5,6,9,12,5,10,3,18,5,6,7])
print ’Max de L est ’, couple[0]
print ’et se trouve `a la position ’, couple[1]
print max_list(’totovaaumarche’)
couple = max_list(’totovaaumarche’)
5