Une fonction, une tâche
Elle est plus facile à nommer, à tester et à réutiliser.
Programmation · Prog 5 · Organiser
Écrire un calcul une seule fois, lui donner un nom, puis l’appeler autant de fois qu’on veut.
Déjà à l'aise ? Aller directement au quizDans la vraie vie
Une machine à café, on l’installe une fois. Ensuite, on appuie sur un bouton.
De l’eau et des grains entrent, un café sort. Personne ne recâble la machine pour chaque tasse.
Une fonction, c’est cette machine.
On lui donne des valeurs, les arguments. Elle calcule et rend un résultat, la valeur renvoyée.
Sans fonction, on recopie le même calcul pour chaque élève :
alice = [4.5, 5, 5.5]
print(sum(alice) / len(alice))
bob = [4, 3.5, 5]
print(sum(bob) / len(bob))Une faute dans la formule ? Il faut la corriger partout.
Avec une fonction, on l’écrit une seule fois, puis on l’appelle :
def moyenne(notes):
return sum(notes) / len(notes)
print(moyenne([4.5, 5, 5.5]))
print(moyenne([4, 3.5, 5]))Si la formule change, on la corrige à un seul endroit.
Écris une fois. Appelle mille fois.
Une valeur entre, une autre sort
La machine, en vrai code.
On définit f : elle reçoit un nombre x et rend 2 × x + 1. Puis on l’appelle deux fois : avec 3, puis avec 5.
Suis la valeur qui entre, puis celle qui ressort, à chaque appel.
Où l’image s’arrête
Une machine à café garde de l’eau et du marc d’une tasse à l’autre. Une fonction, non.
À la fin de l’appel, ses variables locales disparaissent : l’appel suivant repart de zéro.
Elle s’exécute quand même une fois ?
Elle est plus facile à nommer, à tester et à réutiliser.
Souvent un verbe : calculer_moyenne, afficher_menu.
carre, pas carré1.
Une méthode est une fonction rangée dans une classe, ou attachée à un objet : texte.upper(), liste.append(4). Tu en écriras en Prog 7.
Définir n’est pas exécuter
Une définition se lit en quatre morceaux, puis un corps.
Le mot-clé def, le nom, les paramètres entre parenthèses, deux-points, puis le corps, décalé de quatre espaces par convention1, 3.
Pour l’exécuter, on l’appelle : son nom, puis des valeurs entre parenthèses.
Python saute dans le corps, puis revient au point d’appel avec le résultat.
Dans la vraie vie
Une carte toute prête : « Joyeux anniversaire, ______ ! »
Sous le blanc, un mot : prénom. Ce qu’on y écrit change à chaque carte.
Le paramètre, c’est le nom du blanc, écrit dans la définition : nom. L’argument, c’est la valeur qu’on y met à l’appel : "Alice".
Pendant l’appel, le paramètre est une variable locale qui contient l’argument1.
Python, JavaScript, Java, C#, C++ et R : les mots changent, les morceaux restent.
Voici def aire(longueur, largeur): et l'appel aire(4, 6), puis def saluer(nom): et saluer("Léa"). Range chaque élément.
Un programme contient seulement def dire_bonjour(): print("Bonjour"), sans aucun appel. Combien de fois « Bonjour » s'affiche-t-il ?
return : rendre, puis s’arrêter
return rend une valeur, puis arrête la fonction.
La valeur revient à l’endroit de l’appel. Les lignes suivantes ne sont plus exécutées2.
Suis-le ligne par ligne : une fonction signe, appelée avec −3, puis avec 4.
def signe(n): if n < 0: return "négatif" return "positif ou nul" print(signe(-3))print(signe(4))
Une définition, deux appels. Python lit d’abord les lignes 1 à 4 : il range la fonction signe, sans l’exécuter.
Appel signe(-3). Python saute dans la fonction : un cadre s’ouvre, le paramètre n reçoit −3.
Le test. −3 est plus petit que 0 : la condition est vraie, Python entre dans le if.
return. La fonction renvoie « négatif » et s’arrête net : la ligne 4 n’est jamais exécutée. print l’affiche.
Appel signe(4). Nouveau cadre, n vaut 4. Le test est faux : Python saute la ligne 3 et renvoie « positif ou nul ».
Dans la vraie vie
L’écran de la machine affiche « Café prêt ». La tasse, elle, arrive sous le bec.
Le message, tu le lis. La tasse, tu la prends, tu la sucres, tu la poses.
print, c’est l’écran : la valeur s’affiche, mais le programme ne peut rien en faire. return, c’est la tasse : la valeur revient au programme, qui la range et calcule avec.
Besoin du résultat après l’appel ? Il faut un return : prix = calculer_prix(3). Sinon, afficher_menu() fait son action, et c’est tout.
Qu'affiche ce programme ?
def double(n):
print(n * 2)
resultat = double(5)
print(resultat)Avec la fonction signe ci-dessus, que renvoie signe(0) ?
Qui se souvient où reprendre ?
Une fonction peut en appeler une autre.
calculer_total appelle multiplier, puis reprend son calcul. Mais comment l’ordinateur sait-il où reprendre ?
Dans la vraie vie
Une pile d’assiettes : chaque nouvelle assiette se pose en haut, et on reprend toujours celle du haut.
La dernière posée est la première reprise.
Chaque appel pose un cadre sur la pile d’appels : ses paramètres, ses variables locales, et l’endroit où reprendre. Quand la fonction se termine, son cadre est retiré5.
Où l’image s’arrête : une assiette n’attend rien. Un cadre, si : il attend la réponse de celui du dessus.
Trois programmes : un appel simple, des appels en chaîne, puis un paramètre par défaut.
multiplier, la dernière appelée.
Si tu ne précises rien…
Dans la vraie vie
Sur un formulaire en ligne, le champ « Pays » est souvent déjà rempli : Suisse.
Tu ne le changes que si tu habites ailleurs.
Un paramètre peut avoir une valeur par défaut, utilisée quand l’argument n’est pas donné1.
def pizza(taille="M", extra=False):
tarifs = {"S": 8, "M": 12, "L": 16}
total = tarifs[taille]
if extra:
total += 2
return total
print(pizza())
print(pizza("L"))
print(pizza(extra=True))Trois appels, trois commandes. Ce qui n’est pas donné vient de la valeur par défaut. On peut aussi nommer un argument : extra=True3.
En JavaScript aussi : function multiplier(a, b = 1). Sans valeur par défaut, un paramètre oublié vaut undefined4.
Java, lui, n’a pas de valeurs par défaut.
Java écrit plusieurs méthodes du même nom, avec des paramètres différents : c’est la surcharge. Le compilateur choisit d’après le nombre et le type des arguments6.
Un argument : la version carré. Deux arguments : la version rectangle.
Piège : l’ordre des paramètres.
Ceux qui n’ont pas de valeur par défaut viennent d’abord. Sinon, Python refuse le fichier :
def f(a=1, b):
passPiège : la liste par défaut.
La valeur par défaut est calculée une seule fois, à la définition3. Avec def ajouter(x, liste=[]), tous les appels partagent la même liste.
La fonction semble se souvenir des appels précédents. On écrit plutôt liste=None, puis on crée la liste dans la fonction.
Que renvoie pizza("S", True) ?
Et pizza(taille="L") ?
Ce qui naît dans une fonction y reste
Dans la vraie vie
Pendant le cours, le prof écrit au tableau de sa salle. À la sonnerie, il efface tout.
L’affiche du hall, elle, reste : tout le monde la voit, de partout.
Une variable globale x et une variable locale x : laquelle s’affiche, et quand ?
Pour trouver un nom, Python cherche dans l’ordre : le local, les fonctions englobantes, le global, puis les fonctions intégrées comme print3.
Hors de sa fonction, une variable locale n’existe pas :
def f():
y = 3
f()
print(y)En JavaScript, la même erreur s’appelle ReferenceError: y is not defined.
Modifier une globale depuis une fonction ? Python exige le mot global3.
compteur = 0
def incrementer():
global compteur
compteur += 1À éviter : n’importe quelle fonction peut alors la changer en cachette.
Mieux : un paramètre et un return.
def incrementer(n):
return n + 1
compteur = incrementer(compteur)Une fonction qui ne dépend que de ses paramètres et se contente de rendre un résultat, sans rien afficher ni modifier ailleurs, est dite pure : elle n’a pas d’effet de bord7.
En Java, en C# ou en JavaScript avec let, une variable déclarée dans un bloc { } n’existe que dans ce bloc. L’ancien var, lui, l’ignore.
Python n’a pas de portée de bloc : une variable créée dans un if reste visible dans toute la fonction.
Qu'affiche ce programme ?
x = 1
def jeu():
x = 7
print(x)
jeu()
print(x)En JavaScript, que donne console.log(b) après if (true) { var b = 2; } ?
Une fonction sans nom
Dans la vraie vie
Pour qu’un ami double chaque nombre d’une liste, pas besoin d’un classeur de recettes : un post-it suffit.
Une consigne courte, sans titre, pour une seule tâche.
Une lambda en Python, ou une fonction fléchée en JavaScript, est une petite fonction sans nom, souvent passée à une autre fonction3, 4.
nombres = [1, 2, 3, 4]
doubles = map(lambda x: x * 2, nombres)
print(list(doubles))Une lambda Python ne contient qu’une seule expression : dès qu’il faut plusieurs lignes, on écrit un def.
En JavaScript, la flèche => sépare le paramètre de la valeur rendue :
const nombres = [1, 2, 3, 4];
console.log(nombres.map(x => x * 2));lambda x: x * 2
le mot lambda, le paramètre, deux-points, une seule expression
x => x * 2
une fonction fléchée : le paramètre, la flèche, la valeur
x -> x * 2
une flèche simple, faite d’un tiret et d’un chevron
x => x * 2
la même flèche qu’en JavaScript
[](int x) { return x * 2; }
les crochets ouvrent la lambda ; le type et le return sont écrits
function(x) x * 2
une fonction sans nom, écrite sur une ligne
Une fonction qui s’appelle elle-même
Dans la vraie vie
Une longue file au cinéma. Tu veux connaître ta place : tu demandes à la personne devant toi, qui demande à la sienne…
La première répond « 1 ». Puis chacun ajoute 1 et renvoie la réponse vers l’arrière.
Une fonction récursive s’appelle elle-même, sur un problème plus petit4. Il lui faut un cas de base, qui s’arrête (la première de la file), et un cas récursif.
def factorielle(n):
if n <= 1: # cas de base
return 1
# cas récursif
return n * factorielle(n - 1)
print(factorielle(4))factorielle(4) : les cadres s’empilent jusqu’au cas de base, puis les résultats remontent. Ensuite, la même idée sans cas de base.
Dans la vraie vie
Deux miroirs face à face : chaque reflet contient un reflet plus petit, encore et encore.
Une fonction sans cas de base fait pareil, jusqu’à ce que la pile déborde.
Python s’arrête vers 1000 appels avec RecursionError. Java lève une StackOverflowError, JavaScript une RangeError: Maximum call stack size exceeded5.
Où l’image s’arrête : le reflet s’efface peu à peu ; la pile, elle, déborde d’un coup.
Pour factorielle, on peut multiplier en boucle, non ?
Comme des dossiers dans des dossiers : pour tout parcourir, on ouvre un dossier, puis on fait pareil avec chacun de ses sous-dossiers.
Autres exemples : un arbre généalogique, certains tris.
Que renvoie somme(3) ?
def somme(n):
if n == 0:
return 0
return n + somme(n - 1)Pour factorielle(5), combien de cadres de factorielle y a-t-il sur la pile au plus fort ?
Ce compte à rebours ne s'arrête jamais (compte(3)). Quelle ligne est fausse ?
Une calculatrice en petites fonctions
Dans la vraie vie
Dans la cuisine d’un restaurant, le chef ne fait pas tout. Il passe chaque commande au bon poste : grill, sauces, desserts.
Chaque poste fait une seule chose, et la fait bien.
Ton programme peut s’organiser pareil.
Une fonction calculer qui ne calcule rien elle-même : elle passe le travail à additionner ou à diviser.
def additionner(a, b): return a + b def diviser(a, b): if b == 0: return None return a / b def calculer(a, op, b): if op == "+": return additionner(a, b) if op == "/": return diviser(a, b) print(calculer(10, "+", 5))print(calculer(10, "/", 3))print(calculer(1, "/", 0))
Trois petites fonctions. calculer choisit entre additionner et diviser. Python les range, puis lance les trois print.
calculer(10, "+", 5). op vaut "+" : calculer passe le travail à additionner(10, 5). Un cadre de plus sur la pile.
Retour en chaîne. additionner rend 15 à calculer, qui le rend au print. Les deux cadres partent, la console affiche 15.
calculer(10, "/", 3). diviser rend 10 / 3. Le 5 final vient de l’arrondi binaire des nombres à virgule8.
calculer(1, "/", 0). b vaut 0 : diviser rend None, sans lever ZeroDivisionError ni mêler un texte d’erreur aux nombres.
Remets les lignes dans l'ordre pour afficher la moyenne de 4, 5 et 6.
Des fonctions courtes ?
La fiche en six cartes
Une fonction est un bloc de code avec un nom : on la définit une fois, on l’appelle autant qu’on veut.
Le paramètre est dans la définition, l’argument dans l’appel ; le paramètre est une variable locale.
return renvoie une valeur et arrête la fonction ; sans return, Python renvoie None.
Chaque appel pose un cadre sur la pile ; le dernier appelé se termine le premier.
Un paramètre par défaut sert quand l’argument manque (Java : la surcharge). Une variable locale n’existe que dans sa fonction.
Une fonction récursive s’appelle elle-même ; sans cas de base, la pile déborde.
Dix questions, zéro faute
Dix questions sur les fonctions (quatre faciles, trois moyennes, trois difficiles), zéro erreur autorisée.
10 questions · zéro faute · chronomètre
Comment as-tu trouvé ce quiz ?
Les vidéos de Graven, en français, sur YouTube.
Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026.