Les fonctions

Les fonctions intégrées, des boîtes noires

Size, Len, Char et ToFixed sont des fonctions intégrées. Pour s'en servir, inutile de savoir comment elles calculent : il suffit de savoir ce qu'elles reçoivent, les arguments entre parenthèses, et ce qu'elles rendent. La valeur rendue prend la place de l'appel dans l'expression.

Random sert à simuler une mesure. Random(101) rend un entier de 0 à 100, comme un niveau en pourcentage :

Exécuter ce programme plusieurs fois : la valeur change à chaque exécution. C'est précisément ce qui le rend impossible à tester. Pour vérifier le cas 90, qui doit afficher « Niveau acceptable », il faudrait attendre que le hasard le tire, et un résultat que l'on ne peut pas reproduire ne se vérifie pas. Pour tester, remplacer l'affectation par lire: niveau : la valeur est alors choisie, et chaque cas se rejoue à volonté. Random ne revient qu'une fois le programme vérifié.

Écrire ses propres fonctions

Size, Len et ToFixed arrivent avec l'interpréteur. Les étapes propres à un programme, elles, n'existent nulle part : elles se rédigent. Flowgorithm permet d'ajouter ses propres fonctions dans le même fichier, chacune dans son diagramme, et le programme principal les appelle ensuite comme les autres.

Une fonction définie par l'utilisateur répond à trois besoins. Nommer une étape : CalculerTaux(volume, capacite) se lit mieux qu'une formule au milieu du programme. Réutiliser : la formule écrite une fois sert à chaque appel, et une correction s'applique partout. Tester à part : la fonction se vérifie seule, sur des valeurs choisies, avant d'être branchée dans le programme.

Cette définition écarte deux idées reçues. Une fonction n'est pas un raccourci d'écriture recopié à l'endroit de l'appel : c'est un diagramme distinct, où l'exécution entre, puis d'où elle ressort. Et la valeur rendue ne se range nulle part d'elle-même : le programme qui appelle doit la récupérer, sans quoi elle est perdue.

Dérouler en pas à pas avec une puissance de 7,5 kW pendant 6 h : à l'affectation, l'exécution entre dans CalculerEnergie, la fenêtre des variables montre puissanceKw, dureeH et resultat, puis revient au programme principal, où energie reçoit la valeur rendue. L'appel suivant entre dans AfficherBilan, qui affiche Presse 2 : 45.0 kWh. L'argument puissance est reçu par le paramètre puissanceKw, et l'argument duree par le paramètre dureeH : les noms n'ont pas à correspondre, et un argument peut aussi être une valeur écrite directement, comme "Presse 2".

Un appel se déroule toujours dans le même ordre, et le pas à pas le montre forme par forme.

1. Les arguments sont évalués dans le programme principal : puissance vaut 7.5, duree vaut 6.
2. L'exécution entre dans le diagramme de la fonction, et les paramètres reçoivent ces valeurs, dans l'ordre de l'en-tête : puissanceKw prend 7.5, dureeH prend 6. Le programme principal attend.
3. La fonction exécute ses propres formes, avec ses propres variables.
4. À sa pilule de fin, l'exécution revient au point d'appel, et le contenu de la variable de retour remplace l'appel dans l'expression : l'affectation devient energie ← 45.

La transmission se fait donc par position, et non par nom : le premier argument va au premier paramètre, le deuxième au deuxième. Leur nombre doit correspondre à celui des paramètres, sinon l'appel est refusé. Un argument n'est pas forcément une variable : une expression convient aussi, comme CalculerTaux(volumes[heurePic], capacite) plus loin dans ce chapitre, car c'est sa valeur qui part dans la fonction.

La variable de retour se remplit comme n'importe quelle variable, par une affectation ordinaire. Rien ne la distingue au moment où elle est écrite : elle est spéciale par son nom, celui qui figure dans l'en-tête de la fonction. C'est sa valeur au moment où la fonction se termine qui est rendue.

Exécuter cette version : le produit est bien calculé, mais dans produit, alors que l'en-tête annonce resultat. L'exécution s'arrête sur CalculerEnergie se termine sans avoir rangé de valeur dans resultat. Aucune forme Return n'aurait signalé l'oubli, puisqu'il n'en existe pas : le seul lien entre le calcul et la valeur rendue est le nom de la variable. Avant de lancer une fonction, vérifier que ce nom reçoit bien une valeur.

Une fonction est ainsi fermée des deux côtés : rien n'en sort que la valeur rendue, et rien n'y entre que par les paramètres. La version suivante l'oublie.

Chacun ses variables : celles d'une fonction ne se voient pas depuis le programme principal, et inversement. Exécuter cette version : l'exécution entre dans CalculerEnergie et s'arrête sur l'affectation, car duree n'y est pas déclarée. Elle n'existe que dans le programme principal. Tout ce dont une fonction a besoin doit lui arriver par un paramètre. Deux variables de même nom, l'une dans la fonction et l'autre dans le programme principal, restent d'ailleurs deux variables distinctes : le nom ne les relie pas.

Un paramètre peut être un tableau. La fonction ci-dessous compte les relevés qui dépassent un seuil ; elle lit les cases du tableau reçu sans les modifier, et sert deux fois avec deux seuils différents.

Le programme affiche Relevés au-dessus de 50 : 3 puis Au-dessus de 60 : 1. Le second appel figure directement dans la sortie : la valeur rendue s'insère dans le texte, sans passer par une variable. En Python, une fonction se définit avec def, et l'instruction return rend la valeur, là où Flowgorithm rend le contenu de la variable de retour.

Une fonction se vérifie enfin seule, dans un petit programme qui lit ses arguments et affiche ce qu'elle rend : les cas limites s'y essaient un par un, sans dérouler tout le programme autour.

Fil rouge : la cuve de traitement

Étape 6. Le programme de l'étape précédente est repris tel quel, à une chose près : la formule du taux, qui y figurait deux fois, est isolée dans la fonction CalculerTaux. Le reste ne bouge pas, et le résultat non plus. C'est le propre d'une mise en fonction réussie : elle change la structure du programme, jamais ce qu'il affiche.

Avec les 24 relevés proposés, le programme affiche Volume moyen : 20187.5 L, soit 71.4 % puis Pic : 26100 L à 12 h, soit 92.3 %. À 12 h, le taux dépasse le seuil haut de 90 %. En pas à pas, observer les cases volumes[0] à volumes[23] se remplir, puis heurePic changer 7 fois pendant la seconde boucle, chaque fois qu'un relevé dépasse le pic retenu. L'exécution entre ensuite deux fois dans CalculerTaux : son paramètre capacite porte le même nom que la variable du programme principal, mais c'en est une autre, qui reçoit sa valeur à l'appel.

Exercices type

Vérification

La méthode

1. Repérer ce qui se répète : une même formule écrite deux fois, ou une étape qu'on aimerait nommer. C'est le signal qu'une fonction est utile.
2. Lister ce qu'elle reçoit et ce qu'elle rend, en français, avant de dessiner : « elle reçoit un volume et une capacité, elle rend un pourcentage ».
3. Écrire l'en-tête : un nom qui dit l'action, un paramètre par valeur reçue avec son type, et le nom et le type de la variable de retour s'il y en a une.
4. Déclarer la variable de retour dans la fonction, puis la remplir par une affectation. Il n'existe pas de forme Return : relire l'en-tête et vérifier que le nom qui y figure reçoit bien une valeur.
5. Appeler dans une expression si la fonction rend une valeur, par la forme Call sinon. Une valeur rendue qu'on ne range nulle part est perdue sans message.
6. Ne compter sur aucune variable extérieure : tout ce dont la fonction a besoin passe par ses paramètres, dans l'ordre de l'en-tête.
7. Vérifier la fonction seule, sur deux ou trois valeurs choisies, avant de la brancher dans le programme.

Synthèse

• Une fonction intégrée est fournie par le logiciel : elle reçoit des arguments et rend une valeur, sans qu'on sache comment. Random(n) rend un entier de 0 à n - 1, et se remplace par une saisie dès qu'il faut vérifier un cas.
• Une fonction écrite par le lecteur a son propre diagramme, avec sa pilule de début portant l'en-tête et sa pilule de fin.
• Un paramètre est une variable de la fonction, déclarée dans l'en-tête ; un argument est la valeur transmise à l'appel. La transmission se fait par position, et le nombre doit correspondre.
• Un appel se déroule en quatre temps : les arguments sont évalués, les paramètres les reçoivent, la fonction s'exécute, et la valeur rendue remplace l'appel dans l'expression.
• Il n'existe pas de forme Return : la fonction rend le contenu de sa variable de retour, celle que l'en-tête nomme, et qu'une affectation doit avoir remplie.
• Une fonction qui rend une valeur s'appelle dans une expression ; une fonction qui ne rend rien s'appelle par la forme Call. Se tromper de forme perd la valeur, sans message.
• Les variables sont locales à leur diagramme : deux variables de même nom de part et d'autre restent distinctes, et rien ne traverse en dehors des paramètres et de la valeur rendue.