1 Définition et Appel d`une fonction

Université de Provence
Licence Math-Info
Première Année
V. Phan Luong
Algorithmique et
Programmation en Python
Cours 4 : Fonctions
La construction de fonctions dans un langage de programmation permet aux programmeurs d’enrichir la fonctionnalité du langage et faciliter les réalisations des tâches des
applications. En effet, pour réaliser une application complexe, un programmeur peut successivement la décomposer en plusieurs tâches simples. Une tâche complexe peut faire
appel à un certain nombre de tâches simples. Ces tâches peuvent se structurer en une
hiérarchie dont l’application est au sommet de l’hiérarchie. Chaque tâche est définie par
une fonction. L’appel d’une fonction faire exécuter la tâche correspondante. Une fonction peut définir avec des paramètres et peut retourner une valeur comme une fonction
en mathématiques. En programmation, une fonction peut ne pas avoir de paramètres et
peut ne pas retourner de valeur. Elle peut simplement réaliser un certaine nombre de
tâches comme l’impression de messages ou la saisie des valeurs au clavier et les mettre
en mémmoire centrale. Lors de l’appel d’une fonction (pour faire exécuter la tâche correspondante), si ses paramètres existent, les valeurs effectives de ceux-ci (appelées les
arguments) sont substituées de manière respective les paramètres dans le corps de la
fonction. Et la valeur retournée sont calculée en fonction de ces arguments.
Ce cours explique la construction et l’appel de fonction en Python.
1
Définition et Appel d’une fonction
La syntaxe pour définir une fonction :
def nomdefonction(liste_de_parametres) :
bloc_instructions
Le bloc instructions effectue les calculs pour réaliser les tâches confiées à la fonction
définie. Les calculs peuvent produire de nouvelles valeurs que l’on peut renvoyer dans
une expression (affecter à 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écutée dans le bloc, la valeur est renvoyée et l’exécution
de la fonction s’arrête ; toutes autres instructions après cette instruction return valeur
sont abandonnées. Dans le bloc instructions on peut avoir plusieurs instructions return,
mais une seule return sera exécutée.
Exemple 1 :
# Recherche le premier élément maximal dans une liste ou
#dans une chaine de caractères
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ètre qui peut être une liste, un tuple, ou une
chaine de caractères ; ceci est déduit de la syntaxe L[i]. La fonction retourne un tuple de
deux éléments qui représentent respectivement l’index de la première valeur maximale
de la liste et la valeur elle-même.
Notons qu’un tuple peut être considéré comme une liste sauf que
– l’on ne peut pas modifier ses éléments une fois qu’ils sont définis, et
– qu’il a la syntaxe de représentation entourée par les parenthèses, par exemple (3, ’abc’),
et non pas entourée par les crochets.
Une fois une fonction est définie, pour l’utiliser on l’appelle avec des arguments adéquats :
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 à 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 à la position ’, couple[1]
Appels de max list avec une chaine de caractères comme argument.
print max_list(’totovaaumarche’)
ou par affectation à une variable :
couple = max_list(’totovaaumarche’)
print ’Max de L est ’, couple[0]
print ’et se trouve à la position ’, couple[1]
2
Définir des fonctions dans un programme
Les fonctions définies par un programmeur peuvent être considérées comme les nouveaux
opérateurs qui enrichissent le langage. Le principe est que les fonctions doivent être
définies avant leurs appels (ou avant de les faire exécuter) Autrement le compilateur
(ou l’interpréteur) peut ne pas connaı̂tre la fonction qu’il appel. Une exception : dans
le corps d’une fonction récursive, on peut faire appel à une fonction qui est en cours de
définir.
En général, dans un fichier de programme, si l’on veut définir de nouvelles fonctions, alors
leurs définitions doivent précéder leurs appels. Ce qui suit est un fichier de programme
utilisant l’exemple ci-dessus.
# Fichier max_liste.py
################# Partie de définitions de fonctions #################
# Recherche le premier élément maximal dans une liste ou
#dans une chaine de caractères
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écution: 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 à la position ’, couple[1]
print max_list(’totovaaumarche’)
couple = max_list(’totovaaumarche’)
print ’Max de L est ’, couple[0]
print ’et se trouve à la position ’, couple[1]
##################### Fin du Fichier de Programme ####################
L’exécution directe du programme (fichier max liste.py) en utilisant la commande python max liste.py commence par la création de la fonction dans l’espace du programme.
Ensuite, l’exécution dans cette espace les instructions de la partie d’exécution.
3
Définir des fonctions dans un fichier séparé
Les fonctions peuvent être définies dans un fichier et le programme dans un autre fichier
séparé. Dans ce cas, pour pouvoir être exécuté 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éfinies.
Pour l’exemple ci-dessus, on édite deux fichiers séparés :
4
1) Fichier de fonctions :
# Fichier fonc_max_liste.py
# Recherche le premier élément maximal dans une liste ou
#dans une chaine de caractères
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éfinies 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 à la position ’, couple[1]
print max_list(’totovaaumarche’)
couple = max_list(’totovaaumarche’)
5
print ’Max de L est ’, couple[0]
print ’et se trouve à la position ’, couple[1]
Au lieu d’importer les fonctions, on peut importer le fichier qui définit les fonctions avec
la syntaxe qui suit. Dans ce cas, le fichier de programme sera changé 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 d’acces 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 à 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 à la position ’, couple[1]
L’exécution directe du premier fichier de programme :
python prog max list.py
L’exécution directe du seconde fichier de programme :
python prog2 max list.py
4
Module
Tout fichier qui contient au moins une définition d’une fonction ou d’une variable est
appelé un module (une bibliothèque). Le nom du module est le nom du fichier enlevé le
suffixe .py. Ainsi, un fichier de programme qui contient au moins une définition d’une
fonction ou un fichier qui ne contient que des définition de fonctions sont des modules. On
peut importer un module ou des fonctions ou variables d’un module dans un programme,
comme nous avons vu dans les exemples ci-dessus.
6
Pour faciliter la programmation, Python définit un certain nombre de modules internes.
Nous avons utilisé quelques modules internes, par exemple :
– Lors de l’ouverture d’une session interactive, on est dans un module interne nommé
main . Toutes les variables définies par affectation au niveau de ce module sont valides
globalement dans la session.
– D’autres modules internes que nous avons utilisées sont string, math, random
Dans une session de travail sous l’interpréteur Python, la première importation d’un module qui, à part des fonctions qu’elle définit, contient des instruction de programme fait
exécuter ces instructions. Dans la même session, les importations suivantes ne font pas
exécuter ces instructions. Pour les exécuter, on utilise la fonction reload(nomdumodule)
(sans sufffixe .py).
5
Paramètres, variables locales et globales
Les paramètres d’une fonction sont connues seulement dans le corps de la fonction. Ils
sont donc locaux à la fonction. Lors de l’appel d’une fonction ayant des paramètres,
on peut substituer les variables d’un module à la place des paramètres. Notons que la
substitution se faire en générale par valeur : Les paramètres reçoivent repectivement les
valeurs des variables, et non pas les variables elles-mêmes. Par conséquent, si on tente
à changer les valeurs de ces variables à l’intérieur de la fonction, ces changements ne
seront pas persistés après l’exécution de la fonction. Cependant, cette remarque n’est
pas valide pour les paramètres de type list.
A part des paramètres, une fonction peut utiliser des variables pour effectuer les calculs
dans sa tâche. Rappelons qu’en Python, la déclaration d’une variable se fait par sa
première affectation. Ainsi, dans le corps d’une fonction, la première affection d’une
variable déclare que cette variable est locale à la fonction : à l’extérieur de la fonction, le
même nom de variable ne se réfère pas à la même variable. Pour échapper à cette règle,
si l’on veut que la variable soit connue globalement au niveau du module de la fonction,
alors avant la première affectation dans le corps de la fonction, on déclare global x.
Pour toute autre variable manipulée (sans être liées par une affectation) dans le corps
d’une fonction, Python cherche sa portée dans le module définissant la fonction puis
7
dans les modules internes importés.
8