Rappel : pour ouvrir une fenêtre de l'éditeur de programme, vous pouvez consulter la page [Environnement de travail] → [Interface].
Utiliser une fonction
Rappel : pour ouvrir une fenêtre de l'éditeur de programme, vous pouvez consulter la page [Environnement de travail] → [Interface].
A ce stade, on a seulement défini la fonction dans un éditeur de programmes :
Si on fait appel à cette fonction dans la console, pour calculer le carré du nombre
5
par exemple, une erreur est signalée :
Le message :
NameError : name 'carre' is not defined
signifie que la console d'interprétation n'a jamais entendu parler de la fonction
carre()
. Pour calculer effectivement le carré d'un nombre, on commence
par sauvegarder et exécuter le code de la fonction carre()
, généralement
en appuyant sur la touche [F5]
.
La console redémarre :
L'intégralité du programme, enregistré sous le nom fct_carre.py
est pris
en compte par la console (RESTART .../fct_carre.py
),
dont la fonction carre()
.
On peut alors demander la valeur du carré de 5
ou bien celle du carré
de 14
:
print()
versus return
Les valeurs saisies au clavier par l'utilisateur et les résultats affichés à l'écran sont très utiles en informatique pour tester diverses entrées et/ou visualiser la valeur produite lors de l'exécution d'un algorithme. Toutefois, le document ressources 2017 et le programme de Seconde 2019 insistent sur la non-équivalence « entrée d'algorithme - saisie clavier » et « valeur renvoyée par l'algorithme - affichage écran » :
On notera que les notions d’entrées-sorties input()
et
print()
ne sont pas développées dans ce document : elles ne
relèvent pas de la pensée algorithmique et l’accent mis par le programme
sur la notion de fonction permet de s’en libérer complètement.
A titre informatif, nous développerons davantage les spécifications et l'utilisation
des fonctions print()
et input()
dans la page
[Définir une Fonction] →
[Saisie clavier, affichage écran] mais nous
rappelons à nouveau que leur utilisation n'est pas recommandée par les
programmes officiels.
return
?Il faut faire comprendre au plus tôt la différence entre print()
et return
.
En effet, return
permet par exemple de réutiliser la valeur de la sortie
comme paramètre (d'entrée) d'une autre fonction, ce que ne permet pas le simple
affichage obtenu avec print()
.
Par exemple, supposons que l'on ait besoin, dans la suite de l'exercice, de calculer la somme des aires de deux carrés. Une écriture de fonction telle que ci-dessous serait inutilisable (car on ne peut faire des calculs avec un message !) :
def aire_du_carre(c):
print(c*c)
>>> RESTART : .../aire_carre.py >>> aire_du_carre(3)+aire_du_carre(5) 9 25 Traceback (most recent call last): File "", line 1, in TypeError: unsupported operand type(s) for +: 'NoneType' and 'NoneType'
C'est bien return
que l'on doit utiliser :
def aire_du_carre(c):
return c*c
>>> RESTART : .../aire_carre.py >>> aire_du_carre(3)+aire_du_carre(5) 34
On peut d'ailleurs constater que, dans ce cas, les valeurs des résultats
intermédiaires (le carré de 3
et le carré de 5
)
ne sont pas affichées, ce qui est un avantage puisque l'utilisateur n'a pas
besoin de connaître leur valeur.
Le site que vous êtes en train de consulter permet de simuler un éditeur de
programme en langage Python. Ci-dessous,
vous pouvez saisir et modifier du code dans la zone de texte.
Toutefois, cette interface ne permet pas de simuler la console.
Aussi, pour visualiser en-dessous le résultat obtenu, il faudra utiliser
la fonction print()
.
Nous vous conseillons, comme dans l'exemple suivant, de séparer les définitions de fonction de la partie interaction qui permet l'affichage sur ce site. Vous pouvez bien sûr continuer à utiliser l'éditeur de texte si vous le préférez (et c'est quand même recommandé pour pouvoir sauvegarder votre travail...).
Utilisons à nouveau la fonction carre()
. Exécutez le programme
afin d'obtenir la valeur du carré de 5
. N'hésitez pas à modifier
ce programme et à l'exécuter à nouveau pour tester votre code.
Notez qu'utiliser un dièse « #
»
permet d'ajouter des commentaires à son programme.
Un code bien écrit est un code documenté, commenté. Pour illustrer cette notion, considérons l'exemple de spécification suivant (déjà vu et revu) :
Paramètre | un nombre réel c |
---|---|
Valeur renvoyée | l'aire du carré de côté c |
Documenter cette fonction signfie
« expliciter sa spécification (son cahier des
charges) dans une partie placée entre les triples
guillemets """
et """
juste après
l'en-tête de la fonction et avant le corps (les
instructions) de la fonction.
En Python, on désigne cette
documentation par l'appellation docstring
(en français : chaîne de documentation).
Avec l'exemple précédent, cela donnerait :
def aire_du_carre(c):
"""
paramètre : c (flottant ou entier)
contrainte : c positif (c représente la longueur du côté d'un carré)
valeur calculée : carré de c
"""
return c*c
En mathématiques au lycée, les programmes en jeu sont très courts et en général déjà très « documentés » dans l'énoncé de l'exercice. Les chaînes de documentation seront donc rarement renseignées.
Il est par contre préférable de respecter une autre habitude d'auto-documentation en donnant des noms explicites aux fonctions comme aux variables et aux paramètres.
Ainsi, nous n'avons pas appelé f()
la fonction calculant l'aire du carré mais
aire_du_carre()
. Le nom donné à une fonction doit permettre de comprendre, par
ce seul nom, le but de la fonction.