Vidéo 34 : Une fonction typique

\(\newcommand{\ds}{\displaystyle}\) \(\newcommand{\Frac}{\ds\frac}\) \(\renewcommand{\r}{\mathbb{ R}}\) \(\newcommand{\C}{\mathbb{ C}}\) \(\newcommand{\n}{\mathbb{ N}}\) \(\newcommand{\z}{\mathbb{ Z}}\) \(\newcommand{\Q}{\mathbb{ Q}}\) \(\newcommand{\N}{\mathbb{ N}}\) \(\newcommand{\n}{\mathbb{ N}}\) \(\newcommand{\ol}{\overline}\) \(\newcommand{\abs}[1]{\left| \,{#1} \right|}\) \(\newcommand{\pv}{\;;\;}\) \(\newcommand{\ens}[1]{\left\{ {#1} \right\}}\) \(\newcommand{\mens}[1]{\setminus\left\{ {#1} \right\}}\) \(\newcommand{\Par}[1]{\left({#1}\right)}\)

Vidéo 34 : Une fonction typique

Une fonction typique

Examinons un exemple typique de création de fonction, que l’on va appeler \(\mathtt{f}\) et utilisons cet exemple pour illustrer les mécanismes de définition et d”appel de fonction qui sont les deux notions-clé à bien comprendre.

On donne deux notes sur 20, disons \(\mathtt{a}\) et \(\mathtt{b}\), à la fonction \(\mathtt{f}\) et \(\mathtt{f}\) nous renvoie True si la moyenne de ces deux notes est supérieure à 10 et False sinon.

Pour cela, \(\mathtt{f}\) doit calculer la moyenne

\(\mathtt{m=\frac {a+b}2}\)

et d’examiner si, oui ou non, l’assertion \(\mathtt{ m\geq 10 }\) est vraie ou pas.

Voici un code possible en Python d’une telle fonction :

fonction_typique.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
def f(a, b):
    m = (a + b)/2
    ok = (m >= 10)
    return ok

resultat = f(14, 8)
print(resultat)

resultat = f(11, 8)
print(resultat)

11
12
True
False
  • Lignes 1-4 : le code de la fonction f. Ce code est ce qu’on appelle en fait la définition de la fonction f.
  • Ligne 6 : le programme demande à la fonction f de calculer s’il est vrai ou pas que le notes 14 et 8 donnent une moyenne supérieure à 10 ou pas. Ce que renvoie la fonction f (soit True, soit False ici) est placé dans la variable resultat.
  • Ligne 7 : on affiche le booléen resultat.
  • Ligne 4 : la fonction f renvoie un résultat, ici un booléen, à l’aide du mot-clé return qui signifie «  retourner  » ou, mieux, «  renvoyer  ».
  • Ligne 9-10 et 12 : on réutilise la fonction f mais pour des entrées différentes (les notes sont cette fois 11 et 8).

Sémantique d’un appel de fonction

On reprend l’essentiel du code de fonction_typique.py ci-dessus :

1
2
3
4
5
6
7
def f(a, b):
    m = (a + b)/2
    ok = (m >= 10)
    return ok

resultat = f(14, 8)
print(resultat)

8
True

Que se passe-t-il lors de l’appel f(14, 8) à la ligne 6 ? Réponse : les paramètres a et b (ligne 1) sont remplacés, dans cet ordre, par les arguments 14 et 8 dans la définition de la fonction f et le code Python de la définition de f (lignes 2 à 4) est exécuté avec les valeurs remplacées.

Autrement dit, une fois l’appel ligne 6 lancé, c’est comme si le code suivant était exécuté :

equiv_fonction_typique.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
a = 14
b = 8

m = (a + b)/2
ok = (m >= 10)

resultat = ok


print(resultat)

11
True
  • Lignes 1-7 : l’exécution de ce code est équivalente à l’exécution de la fonction f lors de l’appel f(14, 8).

Vocabulaire associé à la notion de fonction

On reprend le code de fonction_typique.py ci-dessus :

1
2
3
4
5
6
7
def f(a, b):
    m = (a + b)/2
    ok = (m >= 10)
    return ok

resultat = f(14, 8)
print(resultat)
  • Ligne 1 : la première ligne de la définition de la fonction est ce qu’on appelle l”en-tête de la fonction. Cet en-tête commence toujours par le mot-clé def.
  • Ligne 1 : l’en-tête se termine par le symbole «  deux-points  ».
  • Lignes 2-4 : la partie qui suit l’en-tête est ce qu’on appelle le corps de la fonction f. Ce corps est un bloc indenté.
  • Ligne 6 : l’expression f(14, 8) est ce qu’on appelle un appel de la fonction f. Cette expression est placée hors de la définition de fonction et est dite expression appelante.

Les valeurs que l’on passe à f lors de cet appel (ici 14 et 8) s’appellent les arguments de l’appel.

  • Ligne 1 : dans la définition de la fonction, ici les variables a et b, s’appellent les paramètres de la fonction f.
  • Ligne 4 : noter que l’objet qui suit le mot-clé return n’est pas entouré de parenthèses. Il est possible d’en placer mais ce n’est pas utile.

Les paramètres n’existent que dans la définition de la fonction. Les paramètres sont juste des noms qui servent à désigner les valeurs que la fonction va recevoir plus tard, lorsque la fonction sera appelée. Les paramètres ont donc un rôle purement formel.

Les arguments ne sont pas des variables, ce sont des valeurs, éventuellement des valeurs de variables. On dit parfois que les arguments sont des paramètres réels (autrement dit, non formels).

Le mécanisme d’appel est ce qu’on désigne parfois sous le terme de passage des arguments ou encore transmission des arguments.

Ordre d’exécution du code

On reprend le code de fonction_typique.py ci-dessus :

1
2
3
4
5
6
7
def f(a, b):
    m = (a + b)/2
    ok = (m >= 10)
    return ok

resultat = f(14, 8)
print(resultat)
  • Ligne 1 : l’interpréteur Python commence à cette ligne la lecture du code. En voyant l’en-tête de la fonction, il prend en compte la déclaration de la fonction f. Autrement dit à partir de ce moment-là, le nom f est reconnu comme celui de la fonction qui est définie à partir de la ligne 1. L’exécution du code continue ligne 6 en ignorant le corps de la fonction.
  • Lignes 2-4 : ces lignes ne sont pas exécutées car il n’y a pas eu, pour l’instant, d’appel à la fonction f.
  • Ligne 6 : l’ordre par défaut d’exécution est modifié puisque l’exécution retourne en arrière dans le code source pour exécuter la fonction f des lignes 1 à 4.
  • Ligne 7 : une fois l’exécution terminée, l’exécution du code passe de la ligne 4 à la ligne 7.