Les fonctions sont extrêmement importantes. Un programme est fait de beaucoup de fonctions. Il ne faut pas hésiter à en ajouter, même pour de petites choses.

Imaginons que quelque part dans un programme on ait le code suivant :

a = 35
b = 15
while  a % b != 0:
    r = a % b
    a = b
    b = r
x = b

Que fait ce code ? On n'en a aucune idée !

La première idée est de commenter pour expliquer ce que fait le code :

# calcul du PGCD de 35 et 15
a = 35
b = 15
while  a % b != 0:
    r = a % b
    a = b
    b = r
# maintenant b est égal au PGCD de 35 et 15
x = b

Mais c'est une mauvaise façon de faire. Il est bien préférable d'utiliser une fonction bien nommée. On définit d'abord la fonction plus haut dans le code :

def PGCD(a,b):
    """
    a et b entiers positifs non nuls
    renvoie le PGCD de a et b
    """
    while  a % b != 0:
        r = a % b
        a = b
        b = r
    return b

Puis on peut l'utiliser :

x = PGCD(35,17)

• En lisant x = PGCD(35,17) on n'a pas besoin de commentaires, on comprend tout de suite.
• Si on a besoin plusieurs fois du calcul de PGCD, la fonction permet d'éviter de réécrire les mêmes lignes de code.
• Si on a beaucoup de fonctions comme celle-ci, on peut les déplacer dans un autre fichier de façon à alléger le programme principal.

Lors de la création du programme principal, on sait que l'on aura besoin de calculer des PGCD et peut-être d'autres choses. On peut donc confier le travail à quelqu'un d'autre. On fournit une liste détaillée des fonctions nécessaires à un membre de l'équipe qui se charge de les faire.

Lorsque l'on écrit une fonction, on définit clairement

• les informations que l'on doit lui donner en entrée,
• les informations qu'elle fournit en réponse,
• ce qu'elle fait…

Cette spécification permet de créer des tests : on vérifie que la fonction fait bien ce qu'on attend d'elle. Par exemple, je sais que PGCD(35,15) = 5. Je peux donc créer un fichier de test qui vérifie que PGCD(35,15) renvoie bien 5.

Chaque fonction étant bien délimitée, on peut produire des tests pour chaque fonction de sorte que l'on sait exactement quelle fonction est valide et quelle fonction ne l'est pas. La maintenance et la vérification s'en trouvent grandement accélérées.

À force de programmer on découvre que les mêmes fonctions reviennent toujours. On peut alors créer un fichier contenant toute sorte de fonctions à usage général. Ce fichier est comme une boîte à outils. On pourra l'utiliser dans tous les projets que l'on veut.

Beaucoup de fonctions existent déjà. On peut récupérer de tels fichiers sur internet ce qui nous évite de refaire ce qui a été déjà fait mille fois par d'autres. Ce sont de bibliothèques de fonctions.