Définitions et appels de fonctions

Introduction

Une fonction, c'est un peu comme une recette de cuisine. Vous lui fournissez des ingrédients (les paramètres), elle suit sa procédure, et elle vous rend un plat (la valeur de retour). Une fois la recette écrite, vous pouvez la réutiliser autant de fois que vous le souhaitez, avec des ingrédients différents — sans avoir à réécrire les étapes à chaque fois.

Vous avez sans doute remarqué qu'en programmation, on répète vite les mêmes opérations : « calculer le carré d'un nombre », « afficher un menu », « vérifier si une note est suffisante »… À chaque fois, on aimerait emballer ce morceau de programme une fois pour toutes, et lui donner un nom, pour pouvoir l'utiliser ensuite sans tout réécrire.

C'est exactement ce que fait une fonction : un bout de programme nommé, qu'on peut appeler ailleurs aussi souvent qu'on veut.

Vous connaissez déjà des fonctions

Depuis le début du chapitre, vous utilisez des fonctions sans le savoir :

print("Bonjour")
range(10)

• print est une fonction. On lui donne un texte, elle l'affiche.
• range est une fonction. On lui donne un nombre, elle produit une suite.

Appeler une fonction consiste à écrire son nom suivi de parenthèses, en glissant éventuellement des valeurs entre les parenthèses. Ces valeurs s'appellent les arguments.

Définir sa propre fonction

Pour créer une fonction, on utilise le mot-clé def (pour define, définir) :

def saluer():
    print("Bonjour")
    print("Comment allez-vous ?")

Décodage :

• def saluer(): — on définit une fonction nommée saluer. Les parenthèses vides signifient qu'elle ne prend pas de paramètre.
• Les deux lignes indentées en dessous forment son corps : ce qu'elle fait quand on l'appelle.

Important : écrire def saluer(): ne fait rien — c'est une simple définition. Pour exécuter le bloc, il faut appeler la fonction :

def saluer():
    print("Bonjour")
    print("Comment allez-vous ?")

saluer()
saluer()

Affichage attendu :

Bonjour
Comment allez-vous ?
Bonjour
Comment allez-vous ?

Les paramètres — personnaliser la fonction

Une fonction devient vraiment utile quand on peut lui donner des informations à chaque appel. Cela se fait via les paramètres :

def saluer(prenom):
    print("Bonjour", prenom)

saluer("Léa")
saluer("Mehdi")
saluer("Camille")

Affichage :

Bonjour Léa
Bonjour Mehdi
Bonjour Camille

À chaque appel :

• la valeur entre parenthèses ("Léa", "Mehdi", etc.) est l'argument ;
• elle est rangée dans la variable prenom le temps de l'exécution de la fonction ;
• la ligne print("Bonjour", prenom) utilise cette valeur.

Une fonction peut prendre plusieurs paramètres :

def saluer(prenom, age):
    print("Bonjour", prenom, ", vous avez", age, "ans")

saluer("Léa", 15)
saluer("Mehdi", 16)

L'ordre compte : le premier argument est rangé dans le premier paramètre, et ainsi de suite.

Retourner une valeur — return

Jusqu'ici, nos fonctions ne faisaient qu'afficher. Très souvent, on veut qu'une fonction calcule quelque chose et renvoie le résultat, pour qu'on puisse réutiliser cette valeur :

def carre(n):
    return n * n

Le mot-clé return indique la valeur de retour : celle que la fonction « rend » à l'endroit où elle a été appelée.

def carre(n):
    return n * n

resultat = carre(5)
print(resultat)        # 25
print(carre(7) + 1)    # 49 + 1 = 50

Vous voyez ici toute la puissance de return : la fonction carre(5) est remplacée par la valeur 25 dans l'expression, et on peut réutiliser ce résultat comme n'importe quel autre nombre.

Pourquoi des fonctions ?

Trois bénéfices majeurs :

Exemple complet — combiner ce qu'on a vu

Voici un programme qui réunit fonctions, conditions et boucles :

Sortie attendue :

8 -> Insuffisant
11 -> Passable
14 -> Bien
17 -> Très bien
9 -> Insuffisant

On voit ici les quatre briques de ce chapitre travailler ensemble : une séquence d'instructions, des variables (notes, n), une bouclefor, des conditions dans la fonction, et une fonction qui retourne une valeur.

Pièges courants

Pour aller plus loin

Une fonction peut appeler une autre fonction, voire s'appeler elle-même (récursivité, à découvrir en NSI). C'est la base de la programmation modulaire : on construit de grands programmes en assemblant beaucoup de petites fonctions, chacune ayant un rôle clair et limité.