Les fonctions.
 
Les fonctions sont une possibilité au programmeur d'encapsuler des instructions afin de pouvoir traiter des objets différents et plusieurs fois par exécution d'un programme.
Les fonctions permettent ainsi de spécifier des paramètres qui peuvent être différents à chaque fois que leurs codes sont exécutés.

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).

Ici nous allons voir les expressions utiles pour la création de fonctions personnelles :

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 !