Programmation Python/Fonctions
Définir une fonction.
Une fonction Python est définie par le spécificateur "def" suivi du nom de la fonction et de ses paramètres :
def nomDeLaFonction(liste de paramètres):
 bloc d'instructions
 return resultat
»> def afficher3fois(arg):
... print arg, arg, arg
»> afficher3fois(5)
5 5 5
»> afficher3fois('zut')
zut zut zut
»> afficher3fois([5, 7])
[5, 7] [5, 7] [5, 7]
»> afficher3fois(6**2)
36 36 36
Fonctionnement.
def factorielle(n):
 f = 1
 i = 1
 while i <= n:
 f = f * i
 i = i + 1
 return f # la valeur retournée
factorielle(7) # 5040
Récursivité.
Une première fonction peut appeler une deuxième fonction, qui elle-même en appelle une troisième, etc. Mais elle peut aussi s'appeler elle-même :
def factorielle(n):
 if n <= 1:
 return 1
 else:
 return n * factorielle(n-1)
factorielle(7) # 5040
Passage d'argument.
Une fonction accepte entre zéro et 255 d'arguments :
»> def addition(x, y):
 return x + y
addition(3, 4) # 7
»> def multiplication(x, y):
 return x * y
multiplication(3, 4) # 12
La signature est ici "x" et "y" en paramètre.
Ces arguments peuvent être des variables, mais aussi des fonctions, appelées alors "" ou "callbacks". Exemple :
»> def operation(x, y, f):
 return f(x, y)
operation(3, 4, addition) # 7
operation(3, 4, multiplication) # 12
Arguments facultatifs.
Il suffit de définir une valeur par défaut à un argument pour le rendre facultatif. Naturellement, cette valeur est écrasée si l'argument est précisé :
»> def f(x = None):
 if x:
 print(x)
print f() # None
print f(1) # 1 None
Arguments nommés.
Pour ne pas être obligé de remplir tous les paramètres facultatifs dans l'ordre, il est possible de n'en n'appeler que quelques-uns s'ils sont nommés :
»> def f(p1 = 0, p2 = 0, p3):
f(p3 = 1) # 1
Fonction lambda.
Une est une fonction anonyme : elle n'est pas définie par "def".
»> def f(x):
 return x*2
»> f(3)
6
»> g = lambda x: x*2 # 1
»> g(3)
6
»> (lambda x: x*2)(3) # 2
6
1 et 2 sont des fonctions lambda.
Récupérer les arguments de la ligne de commande.
La variable codice_4 contient les arguments de la ligne de commande, sous forme d'une liste dont le premier élément est le nom du script invoqué.
Exemple :
Si le script codice_5 contient
 #!/usr/bin/python
 #-*- coding: utf-8 -*-
 import sys
 print("Arguments : ", sys.argv)
alors l'invocation :
 $ python truc.py -a rien -n=nervures
produira la sortie :
 Arguments : ['truc.py', '-a', 'rien', '-n=nervures']
Si on veut récupérer l'argument n° 2 : 
 #!/usr/bin/python
 #-*- coding: utf-8 -*-
 import sys
 print("Argument 2 : ", sys.argv[2])
produira la sortie :
 Argument 2 : 'rien'
Déclarer les arguments.
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-argument_nommé', '-a', help="description", type=str, default='valeur par défaut')
parser.add_argument('arguments non nommés', nargs='*')
print parser.parse_args()
Variables locales, variables globales.
Lorsque nous définissons des variables à l'intérieur du corps d'une fonction, ces variables ne sont accessibles qu'à la fonction elle-même. On dit que ces variables sont des "variables locales" à la fonction.
En effet, chaque fois que la fonction est appelée, Python réserve pour elle (dans la mémoire de l'ordinateur) "un nouvel espace de noms". Les contenus des variables locales sont stockés dans cet espace de noms qui est inaccessible depuis l'extérieur de la fonction. De plus, cet espace de noms est automatiquement détruit dès que la fonction a terminé son travail, donc si on l'appelle deux fois de suite elle recommence à zéro.
Les variables définies "à l'extérieur" d'une fonction sont des variables globales. Leur contenu est « visible » de l'intérieur d'une fonction, mais la fonction ne peut pas le modifier. Exemple : 
»> def mask():
... p = 20
... print p, q
»> p, q = 15, 38
»> mask()
20 38
»> print p, q
15 38 
Nous commençons par définir une fonction très simple (qui n'utilise d'ailleurs aucun paramètre).
À l'intérieur de cette fonction, une variable p est définie, avec 20 comme valeur initiale. Cette variable p qui est définie à l'intérieur d'une fonction sera donc une "variable locale".
Une fois terminée la définition de la fonction, nous revenons au niveau principal pour y définir les deux variables codice_6 et codice_7 auxquelles nous attribuons les contenus codice_8 et codice_9. Ces deux variables définies au niveau principal seront donc des "variables globales".
Ainsi le même nom de variable p a été utilisé ici à deux reprises, "pour définir deux variables différentes" : l'une est globale et l'autre est locale. On peut constater dans la suite de l'exercice que ces deux variables sont bel et bien des variables distinctes, indépendantes, obéissant à une règle de priorité qui veut qu'à l'intérieur d'une fonction (où elles pourraient entrer en compétition), ce sont les variables définies localement qui ont la priorité.
On constate en effet que lorsque la fonction codice_10 est lancée, la variable globale codice_7 y est accessible, puisqu'elle est imprimée correctement. Pour codice_6, par contre, c'est la valeur attribuée localement qui est affichée.
On pourrait croire d'abord que la fonction codice_10 a simplement modifié le contenu de la variable globale codice_6 (puisqu'elle est accessible). Les lignes suivantes démontrent qu'il n'en est rien : en dehors de la fonction codice_10, la variable globale codice_6 conserve sa valeur initiale.
Cet état de choses peut toutefois être modifié si vous le souhaitez. Il peut se faire par exemple que vous ayez à définir une fonction qui soit capable de modifier une variable globale. Pour atteindre ce résultat, il vous suffira d'utiliser l'instruction "codice_17". Cette instruction permet d'indiquer - à l'intérieur de la définition d'une fonction - quelles sont les variables à traiter globalement.
Dans l'exemple ci-dessous, la variable à utiliser à l'intérieur de la fonction "codice_18" est non seulement accessible, mais également modifiable, parce qu'elle est signalée explicitement comme étant une variable qu'il faut traiter globalement. Par comparaison, essayez le même exercice en supprimant l'instruction "codice_17" : la variable "a" n'est plus incrémentée à chaque appel de la fonction.
»> def monter():
... global a
... a = a+1
... print a
»> a = 15
»> monter()
16
»> monter()
17
Utilisation des fonctions dans un script.
Pour cette première approche des fonctions, nous n'avons utilisé jusqu'ici que le mode interactif de l'interpréteur Python.
Il est bien évident que les fonctions peuvent aussi s'utiliser dans des scripts. Veuillez donc essayer vous-même le petit programme ci-dessous, lequel calcule le volume d'une sphère à l'aide de la formule que vous connaissez certainement : formula_1
def cube(n):
 return n**3
def volumeSphere(r):
 return 4 * 3.1416 * cube(r) / 3
r = input('Entrez la valeur du rayon : ')
print 'Le volume de cette sphère vaut', volumeSphere(r)
À bien y regarder, ce programme comporte trois parties : les deux fonctions codice_20 et codice_21, et ensuite le corps principal du programme.
Dans le corps principal du programme, il y a un appel de la fonction codice_21.
À l'intérieur de la fonction codice_21, il y a un appel de la fonction codice_20.
Notez bien que les trois parties du programme ont été disposées dans un certain ordre : d'abord la définition des fonctions, et ensuite le corps principal du programme. Cette disposition est nécessaire, parce que l'interpréteur exécute les lignes d'instructions du programme l'une après l'autre, dans l'ordre où elles apparaissent dans le code source. Dans le script, la définition des fonctions doit donc précéder leur utilisation.
Pour vous en convaincre, intervertissez cet ordre (en plaçant par exemple le corps principal du programme au début), et prenez note du type de message d'erreur qui est affiché lorsque vous essayez d'exécuter le script ainsi modifié.
En fait, le corps principal d'un programme Python constitue lui-même une entité un peu particulière, qui est toujours reconnue dans le fonctionnement interne de l'interpréteur sous le nom réservé codice_25 (le mot "main" signifie « principal », en anglais. Il est encadré par des caractères « souligné » en double, pour éviter toute confusion avec d'autres symboles). L'exécution d'un script commence toujours avec la première instruction de cette entité codice_25, où qu'elle puisse se trouver dans le listing. Les instructions qui suivent sont alors exécutées l'une après l'autre, dans l'ordre, jusqu'au premier appel de fonction. Un appel de fonction est comme un détour dans le flux de l'exécution : au lieu de passer à l'instruction suivante, l'interpréteur exécute la fonction appelée, puis revient au programme appelant pour continuer le travail interrompu. Pour que ce mécanisme puisse fonctionner, il faut que l'interpréteur ait pu lire la définition de la fonction "avant" l'entité codice_25, et celle-ci sera donc placée en général à la fin du script.
Dans notre exemple, l'entité codice_25 appelle une première fonction qui elle-même en appelle une deuxième. Cette situation est très fréquente en programmation. Si vous voulez comprendre correctement ce qui se passe dans un programme, vous devez donc apprendre à lire un script, non pas de la première à la dernière ligne, mais plutôt en suivant un cheminement analogue à ce qui se passe lors de l'exécution de ce script. Cela signifie concrètement que vous devrez souvent analyser un script en commençant par ses dernières lignes !
Modules de fonctions.
Afin que vous puissiez mieux comprendre encore la distinction entre la définition d'une fonction et son utilisation au sein d'un programme, nous vous suggérons de placer fréquemment vos définitions de fonctions dans un module Python, et le programme qui les utilise dans un autre.
On souhaite réaliser la série de dessins ci-dessous, à l'aide du module "turtle" :
Écrivez les lignes de code suivantes, et sauvegardez-les dans un fichier auquel vous donnerez le nom "dessins_tortue.py" :
from turtle import *
def carre(taille, couleur):
 "fonction qui dessine un carré de taille et de couleur déterminées"
 color(couleur)
 c =0
 while c <4:
 forward(taille)
 right(90)
 c = c +1
Vous pouvez remarquer que la définition de la fonction codice_29 commence par une chaîne de caractères. Cette chaîne ne joue aucun rôle fonctionnel dans le script : elle est traitée par Python comme un simple commentaire, mais qui est mémorisé à part dans un système de documentation interne automatique, lequel pourra ensuite être exploité par certains utilitaires et éditeurs « intelligents ».
Si vous programmez dans l'environnement IDLE, par exemple, vous verrez apparaître cette chaîne documentaire dans une « bulle d'aide », chaque fois que vous ferez appel aux fonctions ainsi documentées.
En fait, Python place cette chaîne dans une variable spéciale dont le nom est codice_30 (le mot « doc » entouré de deux paires de caractères « souligné »), et qui est associée à l'objet fonction comme étant l'un de ses attributs (vous en apprendrez davantage au sujet de ces attributs lorsque nous aborderons les classes d'objets).
Ainsi, vous pouvez vous-même retrouver la chaîne de documentation d'une fonction quelconque en affichant le contenu de cette variable. Exemple :
»> def essai():
... "Cette fonction est bien documentée mais ne fait presque rien."
... print "rien à signaler"
»> essai()
rien à signaler
»> print essai.__doc__
Cette fonction est bien documentée mais ne fait presque rien.
Prenez donc la peine d'incorporer une telle chaîne explicative dans toutes vos définitions de fonctions futures : il s'agit là d'une pratique hautement recommandable.
Le fichier que vous aurez créé ainsi est dorénavant un véritable "module" de fonctions Python, au même titre que les modules "turtle" ou "math" que vous connaissez déjà. Vous pouvez donc l'utiliser dans n'importe quel autre script, comme celui-ci, par exemple, qui effectuera le travail demandé :
from dessins_tortue import *
up() # relever le crayon
goto(-150, 50) # reculer en haut à gauche 
i = 0
while i < 10:
 down() # abaisser le crayon
 carre(25, 'red') # tracer un carré
 up() # relever le crayon
 forward(30) # avancer + loin
 i = i +1
a = input() # attendre