Python en mathématiques - Niveau 1

Utiliser une fonction

Faire appel à une fonction

A ce stade, on a seulement défini la fonction dans un éditeur de programmes :

Fonction carré en Python 00

Si on fait appel à cette fonction dans la console, pour calculer le carré du nombre 5 par exemple, une erreur est signalée :

Fonction carré en Python 01

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 :

Fonction carré en Python 02

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 :

Fonction carré en Python 03

print() versus return

Préambule

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.

Pourquoi utiliser 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.

Exemples interactifs

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.

Dorénavant, nous considèrerons que tous les programmes seront écrits dans l'éditeur de programmes puis qu'ils seront éventuellement exécutés dans la console.

Documenter une fonction Plus tard !

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.

Remarque importante

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.