Universite de Provence

Licence Math-Info
Premi`ere Annee
V. Phan Luong

Algorithmique et
Programmation en Python

Cours 4 : Fonctions
La construction de fonctions dans un langage de programmation permet aux programmeurs denrichir la fonctionnalite du langage et faciliter les realisations des taches des
applications. En effet, pour realiser une application complexe, un programmeur peut successivement la decomposer en plusieurs taches simples. Une tache complexe peut faire
appel a` un certain nombre de taches simples. Ces taches peuvent se structurer en une
hierarchie dont lapplication est au sommet de lhierarchie. Chaque tache est definie par
une fonction. Lappel dune fonction faire executer la tache correspondante. Une fonction peut definir avec des param`etres et peut retourner une valeur comme une fonction
en mathematiques. En programmation, une fonction peut ne pas avoir de param`etres et
peut ne pas retourner de valeur. Elle peut simplement realiser un certaine nombre de
taches comme limpression de messages ou la saisie des valeurs au clavier et les mettre
en memmoire centrale. Lors de lappel dune fonction (pour faire executer la tache correspondante), si ses param`etres existent, les valeurs effectives de ceux-ci (appelees les
arguments) sont substituees de mani`ere respective les param`etres dans le corps de la
fonction. Et la valeur retournee sont calculee en fonction de ces arguments.
Ce cours explique la construction et lappel de fonction en Python.

D
efinition et Appel dune fonction

La syntaxe pour definir une fonction :

def nomdefonction(liste_de_parametres) :
bloc_instructions
Le bloc instructions effectue les calculs pour realiser les taches confiees a` la fonction
definie. Les calculs peuvent produire de nouvelles valeurs que lon peut renvoyer dans
une expression (affecter a` variable, utiliser comme arguments dune autre fonction).
1

Pour cela, on utilise linstruction return valeur (ou return tuple de valeurs). Lors quune
instruction return valeur est executee dans le bloc, la valeur est renvoyee et lexecution
de la fonction sarrete ; toutes autres instructions apr`es cette instruction return valeur
sont abandonnees. Dans le bloc instructions on peut avoir plusieurs instructions return,
mais une seule return sera executee.
Exemple 1 :
# Recherche le premier e
l
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 deduit de la syntaxe L[i]. La fonction retourne un tuple de
deux elements qui representent respectivement lindex de la premi`ere valeur maximale
de la liste et la valeur elle-meme.
Notons quun tuple peut etre considere comme une liste sauf que
lon ne peut pas modifier ses elements une fois quils sont definis, et
quil a la syntaxe de representation entouree par les parenth`eses, par exemple (3, abc),
et non pas entouree par les crochets.
Une fois une fonction est definie, pour lutiliser on lappelle avec des arguments adequats :
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])

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]

D
efinir des fonctions dans un programme

Les fonctions definies par un programmeur peuvent etre considerees comme les nouveaux
operateurs qui enrichissent le langage. Le principe est que les fonctions doivent etre
definies avant leurs appels (ou avant de les faire executer) Autrement le compilateur
(ou linterpreteur) peut ne pas connatre la fonction quil appel. Une exception : dans
le corps dune fonction recursive, on peut faire appel a` une fonction qui est en cours de
definir.
En general, dans un fichier de programme, si lon veut definir de nouvelles fonctions, alors
leurs definitions doivent preceder leurs appels. Ce qui suit est un fichier de programme
utilisant lexemple ci-dessus.
# Fichier max_liste.py
################# Partie de d
efinitions de fonctions #################
# Recherche le premier e
l
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 dex
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 ####################
Lexecution directe du programme (fichier max liste.py) en utilisant la commande python max liste.py commence par la creation de la fonction dans lespace du programme.
Ensuite, lexecution dans cette espace les instructions de la partie dexecution.

D
efinir des fonctions dans un fichier s
epar
e

Les fonctions peuvent etre definies dans un fichier et le programme dans un autre fichier
separe. Dans ce cas, pour pouvoir etre execute directement avec la commande python
nomfichierprogramme.py, le fichier du programme doit importer dabord les fonctions du
fichier dans lequel les fonctions sont definies.
Pour lexemple ci-dessus, on edite deux fichiers separes :

1) Fichier de fonctions :
# Fichier fonc_max_liste.py
# Recherche le premier e
l
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 definies dans dautres 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

print Max de L est , couple[0]

print et se trouve a
` la position , couple[1]
Au lieu dimporter les fonctions, on peut importer le fichier qui definit les fonctions avec
la syntaxe qui suit. Dans ce cas, le fichier de programme sera change comme suit :
# Fichier prog2_max_list
import fonc_max_list
print fonc_max_list.max_list([4,5,6,9,12,5,10,3,18,5,6,7])
# la syntaxe indiquant le chemin dacces a la fonction max_list utiliser .
couple = fonc_max_list.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 fonc_max_list.max_list(totovaaumarche)
couple = fonc_max_list.max_list(totovaaumarche)
print Max de L est , couple[0]
print et se trouve a
` la position , couple[1]
Lexecution directe du premier fichier de programme :
python prog max list.py
Lexecution directe du seconde fichier de programme :
python prog2 max list.py

Module

Tout fichier qui contient au moins une definition dune fonction ou dune variable est
appele un module (une biblioth`eque). Le nom du module est le nom du fichier enleve le
suffixe .py. Ainsi, un fichier de programme qui contient au moins une definition dune
fonction ou un fichier qui ne contient que des definition de fonctions sont des modules. On
peut importer un module ou des fonctions ou variables dun module dans un programme,
comme nous avons vu dans les exemples ci-dessus.
6

Pour faciliter la programmation, Python definit un certain nombre de modules internes.

Nous avons utilise quelques modules internes, par exemple :
Lors de louverture dune session interactive, on est dans un module interne nomme
main . Toutes les variables definies par affectation au niveau de ce module sont valides
globalement dans la session.
Dautres modules internes que nous avons utilisees sont string, math, random
Dans une session de travail sous linterpreteur Python, la premi`ere importation dun module qui, a` part des fonctions quelle definit, contient des instruction de programme fait
executer ces instructions. Dans la meme session, les importations suivantes ne font pas
executer ces instructions. Pour les executer, on utilise la fonction reload(nomdumodule)
(sans sufffixe .py).

Param`
etres, variables locales et globales

Les param`etres dune fonction sont connues seulement dans le corps de la fonction. Ils
sont donc locaux a` la fonction. Lors de lappel dune fonction ayant des param`etres,
on peut substituer les variables dun module a` la place des param`etres. Notons que la
substitution se faire en generale par valeur : Les param`etres recoivent repectivement les
valeurs des variables, et non pas les variables elles-memes. Par consequent, si on tente
a` changer les valeurs de ces variables a` linterieur de la fonction, ces changements ne
seront pas persistes apr`es lexecution de la fonction. Cependant, cette remarque nest
pas valide pour les param`etres de type list.
A part des param`etres, une fonction peut utiliser des variables pour effectuer les calculs
dans sa tache. Rappelons quen Python, la declaration dune variable se fait par sa
premi`ere affectation. Ainsi, dans le corps dune fonction, la premi`ere affection dune
variable declare que cette variable est locale a` la fonction : a` lexterieur de la fonction, le
meme nom de variable ne se ref`ere pas a` la meme variable. Pour echapper a` cette r`egle,
si lon veut que la variable soit connue globalement au niveau du module de la fonction,
alors avant la premi`ere affectation dans le corps de la fonction, on declare global x.
Pour toute autre variable manipulee (sans etre liees par une affectation) dans le corps
dune fonction, Python cherche sa portee dans le module definissant la fonction puis
7

dans les modules internes importes.