Activité 4 - Les fonctions

Les programme que vous avez écrits jusqu’à présent étaient à chaque fois très courts, car leur objectif était seulement de vous faire assimiler les premiers éléments du langage. Lorsque vous commencerez à développer de véritables projets, vous serez confrontés à des problèmes souvent fort complexes, et les lignes de programme vont commencer à s’accumuler...

L’approche efficace d’un problème complexe consiste souvent à le décomposer en plusieurs sous-problèmes plus simples qui seront étudiés séparément.

D’autre part, il arrivera souvent qu’une même séquence d’instructions doive être utilisée à plusieurs reprises dans un programme, et on souhaitera bien évidemment ne pas avoir à la reproduire systématiquement. Les fonctions vont nous permettre de résoudre les difficultés évoquées ci-dessus. Nous allons commencer par décrire ici la définition de fonctions sous Python. Nous avons déjà rencontré diverses fonctions pré-programmées. Voyons à présent comment en définir nous-mêmes de nouvelles. La syntaxe Python pour la définition d’une fonction est la suivante :

In [ ]:
def nomDeLaFonction(liste des paramètres):
    instruction 1
    instruction 2
    .....

Une fonction s’utilise pratiquement comme une instruction quelconque. Dans le corps d’un programme, un appel de fonction est constitué du nom de la fonction suivi de parenthèses. Si c’est nécessaire, on place dans ces parenthèses le ou les arguments que l’on souhaite transmettre à la fonction. Il faudra fournir un argument pour chacun des paramètres spécifiés dans la définition.

Un premier exemple

À faire vous-même n°1

Tapez le code suivant dans la console. Celui-ci définit une fonction sans paramètre qui affiche la table de multiplication par 7.

In [ ]:
def table7():
    n = 1
    while n < 11 :
        print(7*n)
        n=n+1

Pour tester la fonction, il suffit simplement de l’appeler par son nom après l'avoir définie :

In [ ]:
table7()

Fonction avec paramètres

Nous avons défini et utilisé une fonction qui affiche les termes de la table de multiplication par 7. Supposons à présent que nous voulions faire de même avec la table par 9. Nous pouvons bien entendu réécrire entièrement une nouvelle fonction pour cela. Mais si nous nous intéressons plus tard à la table par 13, il nous faudra encore recommencer. Ne serait-il donc pas plus intéressant de définir une fonction qui soit capable d’afficher n’importe quelle table, à la demande ? Lorsque nous appellerons cette fonction, nous devrons bien évidemment pouvoir lui indiquer quelle table nous souhaitons afficher. Cette information que nous voulons transmettre à la fonction au moment même où nous l’appelons s’appelle un argument. Nous avons déjà rencontré à plusieurs reprises des fonctions intégrées qui utilisent des arguments.

Voici ce que cela donne dans le cas qui nous intéresse :

In [ ]:
def table(base):
    n = 1
    while n < 11:
        print(base * n, end = ' ')
        n = n + 1

La fonction table() telle que définie ci-dessus utilise un paramètre nommé base.

Pour tester cette nouvelle fonction, il nous suffit de l’appeler avec un argument. Exemples :

In [ ]:
table(13)
In [ ]:
table(9)

Sachez qu'une fonction peut posséder plusieurs paramètres. Ils seront dans ce cas séparés par une virgule. Par exemple :

In [ ]:
def produit(a, b):
    return a*b
print(produit(2,3))

À faire vous-même n°2

Dans un fichier nommé script2.py, créez une nouvelle fonction tablebis() qui prend elle aussi un argument et qui affiche la table de multiplication correspondante de façon plus lisible. Par exemple en tapant tablebis(9) on obtiendrait :

1 x 9 = 9
2 x 9 = 18 .....

Vraies fonctions

Pour les puristes, les fonctions que nous avons décrites jusqu’à présent ne sont pas tout à fait des fonctions au sens strict, mais plus exactement des procédures. Une « vraie » fonction (au sens strict) doit en effet renvoyer une valeur lorsqu’elle se termine comme c'est le cas d'une fonction en mathématiques.

fonction mathématique

Commençons par un exemple extrêmement simple :

In [ ]:
def cube(w):
    return w*w*w

L’instruction return définit ce que doit être la valeur renvoyée par la fonction. En l’occurrence, il s’agit du cube de l’argument qui a été transmis lors de l’appel de la fonction. Exemple :

In [ ]:
var = cube(9)
print(var)     # affiche 729

La seconde ligne du code précédent se termine par un commentaire. Un commentaire Python commence toujours par le caractère spécial #. Tout ce qui est inclus entre ce caractère et le saut à la ligne suivant est complètement ignoré par le compilateur.

À titre d’exemple un peu plus élaboré, nous allons maintenant modifier quelque peu la fonction table() sur laquelle nous avons déjà travaillé, afin qu’elle renvoie elle aussi une valeur. Cette valeur sera en l’occurrence une liste (la liste des dix premiers termes de la table de multiplication choisie). Voilà donc une occasion de reparler des listes. Dans la foulée, nous en profiterons pour apprendre encore un nouveau concept :

À faire vous-même n°3

Ecrivez un programme script3.py contenant le code suivant et testez le :

In [ ]:
######       Définition de la fonction   #########
def tableter(base):
    resultat = []        # la variable résultat est d'abord une liste vide
    n = 1
    while n < 11:
        b = n * base
        resultat.append(b)   # ajout d'un terme à la liste
        n = n + 1            # on incrémente la variable n
    return resultat

######        Tests de la fonction    ##############

tab9 = tableter(9)
print(tab9)    # renvoie la table de 9 sous forme de liste
print(tab9[1])   # renvoie 18. Attention au indice dans les listes !! 
print(tab9[9])   # renvoie 90

Notion de variable locale

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.

Testez le code suivant dans la console :

In [ ]:
def essai():
    variable = 10
    return "Bonjour !"

print(variable)

À faire vous-même n°4

Dans un fichier script4.py, Ecrivez une fonction nommée bonjour() qui prend en argument un nom et qui affiche "Bonjour" suivi du nom.

À faire vous-même n°5

Dans un fichier script5.py, Ecrivez une fonction minimum() qui prend en argument qui prend en argument deux nombres et qui renvoie le plus petit des deux.

À faire vous-même n°6

Dans un fichier script6.py, Ecrivez une fonction minimum3() qui prend en argument trois nombres et qui affiche le plus petit des trois.

indication : on pourra utiliser la fonction définie précédemment.

À faire vous-même n°7

Dans un fichier fibonacci.py, Ecrivez une fonction fibo() qui prend en argument un nombre entier positif n et qui affiche les n premiers termes de la suite de fibonacci.