Fonctions : paramètres, résultats et portée des variables

Définir n’est pas exécuter

L’instruction def définit une fonction ; son corps s’exécute lorsqu’un appel est effectué. Dans def double(x), x est un paramètre, c’est-à-dire un nom utilisé à l’intérieur pour recevoir une donnée. Dans double(7), 7 est l’argument fourni. Pour expliquer un appel, commencez par associer les arguments aux paramètres dans leur ordre, puis suivez le corps avec ces valeurs. Une fonction peut être appelée plusieurs fois avec des arguments différents sans recopier son algorithme. Le nom choisi devrait annoncer le service rendu, par exemple distance ou nombre_occurrences.

Pour deux paramètres, l’ordre des arguments compte : une fonction de soustraction appelée avec trois puis huit ne reçoit pas les mêmes données qu’avec huit puis trois. Écrivez une petite table « paramètre / argument reçu » avant de tracer un appel comportant plusieurs données.

Renvoyer permet de poursuivre le calcul

return fournit un résultat à l’endroit de l’appel et termine immédiatement l’exécution de la fonction. print affiche une représentation et sert à communiquer avec l’utilisateur ; il ne remplace pas un résultat utilisable dans une expression. Une fonction qui atteint sa fin sans return renvoie None. On peut donc afficher 14 dans une fonction et pourtant ne pas pouvoir additionner son résultat à 1. Pour construire des programmes composables, les fonctions de calcul renvoient généralement leurs résultats, et l’affichage est organisé par le programme qui les appelle.

Une instruction située après un retour sur le même chemin n’est jamais exécutée. Inversement, un affichage ne termine pas la fonction : les instructions suivantes se poursuivent. Le résultat retourné peut être stocké, comparé ou transmis directement à un nouvel appel.

Chaque appel possède ses noms locaux

Les paramètres et les variables créées dans une fonction sont locaux à son exécution. Dans une fonction qui reçoit x puis exécute x = x + 2, l’affectation change le nom local x. Pour un argument entier, elle ne remplace pas la variable utilisée par l’appelant. Cette distinction évite de compter sur une modification qui n’aura pas lieu. Nous limitons ici les exemples aux nombres ; les objets modifiables demandent ensuite de distinguer réaffectation d’un nom et modification d’un objet partagé.

def augmente(x):
    x = x + 2
    return x

score = 5
nouveau = augmente(score)
print(score, nouveau)

Deux appels successifs ne partagent pas leurs variables locales ordinaires. Le deuxième appel recommence avec ses nouveaux arguments. Pour conserver un résultat entre les appels, le programme extérieur doit le récupérer explicitement puis le retransmettre, au lieu de supposer une mémoire cachée dans le paramètre.

Composer et traiter tous les chemins

Une fonction peut utiliser le résultat d’une autre : double(augmente(5)) appelle d’abord augmente(5), puis transmet son résultat à double. Les parenthèses organisent cette composition. Dans une fonction conditionnelle, il faut vérifier tous les chemins pour respecter le résultat annoncé. Si un return existe seulement dans le cas x > 0, le cas x = 0 peut renvoyer involontairement None. Une spécification simple, quelques cas limites et une trace des appels permettent de repérer cette omission avant qu’elle se manifeste loin de la fonction responsable.

La composition n’est généralement pas commutative. Sur une seule entrée, deux ordres peuvent cependant coïncider : avec zéro, les deux expressions de l’atelier donnent un. Ce cas particulier ne prouve pas leur équivalence pour les autres entiers.

Décomposer un prix en services simples

Une fonction prix_ligne(quantite, prix_unitaire) peut renvoyer leur produit. Une autre total_commande(prix_a, prix_b, livraison) peut additionner trois montants. Pour deux articles à sept euros, trois articles à quatre euros et une livraison de cinq euros, les prix de lignes sont quatorze et douze ; le total est trente et un. Chaque appel a un contrat court et un résultat vérifiable.

La livraison n’est pas ajoutée dans chaque prix de ligne, sinon elle serait facturée deux fois. La décomposition doit suivre le sens des données. Le programme principal peut afficher le total une fois le calcul terminé, ce qui permet aussi de réutiliser les fonctions dans une autre interface.

Tous les chemins doivent tenir la même promesse

Une fonction qui indique le plus grand de deux nombres peut renvoyer le premier si celui-ci est supérieur ou égal au second, puis renvoyer le second dans l’autre cas. L’égalité est ainsi traitée explicitement. Si l’on utilise deux comparaisons strictes et aucun retour supplémentaire, les arguments égaux provoquent un retour implicite de None.

Pour vérifier une fonction conditionnelle, dessinez ses branches puis associez une entrée à chaque chemin : premier plus grand, second plus grand, égalité. Vérifiez aussi le type du résultat. Une branche renvoyant un nombre et une autre un message textuel compliquent les calculs suivants, sauf si cette diversité fait explicitement partie du contrat.

De la compréhension à l’autonomie

À vous de résoudre

Cherchez d’abord par vous-même. Vérifiez les résultats demandés, utilisez les indices si nécessaire, puis comparez votre méthode à la correction.

Les erreurs qui méritent un détour

Penser que def exécute immédiatement le corps

Repérez les appels effectifs : une fonction définie mais jamais appelée ne réalise pas son traitement.

Utiliser une variable locale après l’appel

Transmettez explicitement l’information utile avec return plutôt que de dépendre d’un nom interne.

Le prochain pas

• Spécifier une fonction : préconditions, postconditions et assertions

Retrouver le catalogue de Première

Ce chapitre s’appuie sur le programme officiel de Première (PDF, nouvel onglet). Les explications et exercices sont proposés pour l’apprentissage.