Pourquoi
les fonctions ?
Les fonctions permettent une réutilisation d'un bout de code. Une fonction permet aussi de grouper du code qui peut être exécuté ultérieurement, alors qu'avant le code était exécuté immédiatement.
Les fonctions ont aussi le grand avantage
de découper le programme en blocs aux spécifications bien
précises. De plus cela rend le code bien plus lisible ce qui n'est
pas négligeable lors de grosses applications !
Bases
des fonctions.
Nous avons déjà utilisé des fonctions précédemment, en effet les fonction len(), open(), font parties d'un groupe de fonctions de base (__builtin__, voir chapitre 1 et 10).
def.
L'instruction "def" définis une nouvelle fonction, elle est suivie du nom de la fonction et se termine par ":". Le code se trouvant sous une instruction "def" devra être indenté d'une fois au moins ! En bref "def" est une instruction exécutable, elle génère un nouvel objet portant le nom fourni.
>>> def ma_fonc():
...
<instruction>
return.
"return" quitte la fonction et retourne la valeur <valeur>, en affectant ainsi la variable appelante. "return" peut retourner un tuple.
... <instruction>
...
return <valeur>
Arguments
d'une fonction :
Il est possible de passer des arguments sous plusieurs formes, la méthode la plus simple consiste à envoyer les valeurs voulues par la fonction en respectant leurs nombres et leurs types. La forme générale pour passer des arguments est "fonction(arg_un, arg_deux, ..., argn)", et la réception est "def fonction(arg_un, arg_deux,..., narg):". Le nom envoyé et celui de réception peuvent être totalement différents !
Par cette méthode il est aussi possible
de définir des valeurs par défaut, par exemple au cas ou
l'utilisateur ne donnerait pas une information à une question traitée
ensuite. La mise par défaut se fait dans la définition de
la fonction :
>>> def fonction(arg_un=0, arg_deux=2,
..., narg='Hello World'):
Ici les valeurs par défaut sont de
type différent, cela n'a aucune importance. Si il y a une valeur
envoyée, alors la valeur par défaut est ignorée !
Lorsque le nombre d'arguments est arbitraire il est possible d'envoyer ceux-ci sous deux formes différentes. En effet en plaçant "*arg" dans la définition de la fonction les arguments seront reçus sous forme d'un tuple.
Par contre avec la forme "**arg" ils seront
sous la forme d'un dictionnaire. Pour passer des arguments sous la forme
d'un dictionnaire il faut leurs attribuer un nom, car les dictionnaires
ne sont pas classés par indice (comme les tuples), mais par clés.
Ceci se fait lors de l'appel de la fonction :
par
dictionnaire :
>>> def ma_fonction(**arg):
>>> ... pass
>>> ma_fonction(arg_un=un_arg, arg_deux=deux_arg)
par
tuple:
>>> def ma_fonction(*arg):
>>> ... pass
>>> ma_fonction(arg_un, arg_deux)
Les
variables global.
Lors de la création d'une variable
dans une fonction celle-ci n'est pas forcément visible depuis le
module de base. Que veut dire global en Python ? global est une sorte de
"visible au plus haut niveau du module", une "déclaration" global
doit se faire dans une fonction pour que la variable puisse être
utilisée depuis un autre bloc !
>>>def ma_fonc():
. . . global x #Valeur global
. . .
y = 12 #Valeur local
L'expression
"Lambda".
Outre l'instruction "def", Python offre une autre forme pour créer des objets fonctions, il s'agit de l'expression "lambda" (similaire à sa forme sous LISP). La forme générale est le mot-clé lambda suivi d'un ou plusieurs arguments puis d'une expression placée après deux-points.
Lambda est un expression, et non une fonction. Par conséquent elle peut apparaître là ou "def" ne peut pas prendre place (à l'intérieur d'une constante de liste, par exemple !).
Le corps de lambda est similaire à
ce
que l'on place dans l'instruction return du bloc def.
>>> def fonc(x,y,z): return x+y+z
. . .
>>> f(2,3,4)
9
>>> f=lambda x,y,z: x+y+z
>>> f(2,3,4)
9
Il est à noter que les valeurs par
défaut fonctionnent aussi avec l'expression lambda !