f2 × x + 137argumentvaleur renvoyée

Programmation · Prog 5 · Organiser

Les fonctions

É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 quiz

Dans la vraie vie

Une machine à café, on l’installe une fois. Ensuite, on appuie sur un bouton.

eau grains prêt café

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.

ingrédientsmachineboisson arguments fonction valeur renvoyée f(3) rend 7 : l’argument 3 entre, la valeur 7 sort

Sans fonction, on recopie le même calcul pour chaque élève :

Sans fonctionrecopié
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.

alicesum / len ! bobsum / len ! …sum / len ! une faute, à corriger dans chaque copie

Avec une fonction, on l’écrit une seule fois, puis on l’appelle :

Avec une fonctionécrit une fois
def moyenne(notes):
    return sum(notes) / len(notes)

print(moyenne([4.5, 5, 5.5]))
print(moyenne([4, 3.5, 5]))
5.0 4.166666666666667

Si la formule change, on la corrige à un seul endroit.

écrite une fois moyenne [4.5, 5, 5.5] 5.0 [4, 3.5, 5] 4.1666… appelée deux fois

Écris une fois. Appelle mille fois.

Au programme

  • 01une machine à valeurs
  • 02définir, puis appeler
  • 03rendre un résultat
  • 04la pile d’appels
  • 05les valeurs par défaut
  • 06où vivent les variables
  • 07les fonctions express
  • 08la récursivité
  • 09tout assembler

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.

La machine f

Suis la valeur qui entre, puis celle qui ressort, à chaque appel.

La machinedéfinir
Python

    Où l’image s’arrête

    Une machine à café garde de l’eau et du marc d’une tasse à l’autre. Une fonction, non.

    appel f(3) x = 3 vide rend 7 appel f(5) x = 5 rend 11 chaque appel repart de zéro

    À la fin de l’appel, ses variables locales disparaissent : l’appel suivant repart de zéro.

    Et si on définit une fonction sans jamais l’appeler ?

    Elle s’exécute quand même une fois ?

    Non : son code ne s’exécute jamais. Définir, c’est ranger la recette ; seul un appel la lance.

    Une fonction, une tâche

    Elle est plus facile à nommer, à tester et à réutiliser.

    Un nom qui dit ce qu’elle fait

    Souvent un verbe : calculer_moyenne, afficher_menu.

    Pas d’accents dans les noms

    carre, pas carré1.

    Fonction ou méthode ?

    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.

    def saluer (nom) : mot-clé nom paramètre deux-points return f"Bonjour {nom} !" 4 espaces corps, décalé à droite

    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.

    def saluer(nom): return f"Bonjour {nom} !" nom = "Alice" message = saluer("Alice") appel rend "Bonjour Alice !"

    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, ______ ! »

    Joyeux anniversaire,!prénomAlice Joyeux anniversaire,!prénomLéo un seul modèle, autant de cartes qu’on veut

    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".

    def saluer(nom): saluer("Alice") paramètredans la définition argumentdans l’appel nom reçoit "Alice"

    Pendant l’appel, le paramètre est une variable locale qui contient l’argument1.

    La même fonction, six langages

    Python, JavaScript, Java, C#, C++ et R : les mots changent, les morceaux restent.

    Même fonctionPython
    saluer.pydéfinir, appeler

    Exercice 1

    Paramètre ou argument ?

    Voici def aire(longueur, largeur): et l'appel aire(4, 6), puis def saluer(nom): et saluer("Léa"). Range chaque élément.

    paramètredans la définition
    argumentdans l'appel

    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.

    def f(x): r = 2 * x + 1 return r print("fin") y = f(3) 7 y reçoit 7 jamais exécutée

    Suis-le ligne par ligne : une fonction signe, appelée avec −3, puis avec 4.

    signe.pyPython
    def signe(n):    if n < 0:        return "négatif"    return "positif ou nul" print(signe(-3))print(signe(4))
    aucun appelen cours cadre de signe n = −3 renvoie

    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.

    Café prêt ! affiché :tu le lis rendu :tu le prends

    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.

    print(7) 7 affiché, c’est tout return 7 prix 7 prix × 2 = 14

    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.

    Et une fonction sans return ? Elle rend quand même quelque chose : None en Python2, 3, undefined en JavaScript.

    resultat = double(5) doubleprint(n * 2) 10 None resultat vaut None affiché, pas rendu

    En Java ou en C#, une méthode déclarée void ne renvoie rien du tout.

    Exercice 2

    Affiché ou renvoyé ?

    Qu'affiche ce programme ?

    Python
    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 ?

    calculer_total multiplier appelle revient ? reprendre où ?

    Dans la vraie vie

    Une pile d’assiettes : chaque nouvelle assiette se pose en haut, et on reprend toujours celle du haut.

    posée en premier posée en dernier reprise en premier

    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.

    principalattend calculer_total attend reprend multipliera=10 b=3calcule rend 30

    Où l’image s’arrête : une assiette n’attend rien. Un cadre, si : il attend la réponse de celui du dessus.

    La pile, pas à pas

    Trois programmes : un appel simple, des appels en chaîne, puis un paramètre par défaut.

    La pilepas 1
    Python

      Dans le programme en chaîne, qui a fini en premier ?

      multiplier, la dernière appelée.

      Oui : le dernier appelé est le premier terminé. Comme pour les assiettes.

      Si tu ne précises rien…

      Dans la vraie vie

      Sur un formulaire en ligne, le champ « Pays » est souvent déjà rempli : Suisse.

      Inscription Prénom Léa Pays Suisse Langue français par défaut par défaut tapé un champ tapé, deux valeurs par défaut

      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.

      pizza.py
      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))
      12 16 14

      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.

      appeltailleextraprix pizza()MFalse12 pizza("L")LFalse16 pizza(extra=True)MTrue14 donné à l’appel par défaut

      En JavaScript aussi : function multiplier(a, b = 1). Sans valeur par défaut, un paramètre oublié vaut undefined4.

      appel :multiplier(5) function multiplier(a, b = 1) par défaut a = 5 b = 1 function multiplier(a, b) oublié a = 5 b = undefined

      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.

      aire(double c)carré : c × c aire(double l, double h)rectangle : l × h aire(5) rend 25.0 aire(4, 6) rend 24.0

      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 :

      Python 3.12 et plus
      def f(a=1, b):
          pass
      SyntaxError: parameter without a default follows parameter with a default
      def f(b, a=1): def f(a=1, b):SyntaxError sans valeur par défautavec valeur par défaut

      Piè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.

      def ajouter(x, liste=[]): une seule liste créée une fois, à la définition 1 2 ajouter(1) rend [1] ajouter(2) rend [1, 2] !

      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.

      Exercice 3

      La pizza par défaut

      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.

      hall x = 100 tout le monde la voit salle de cours x = 5 effacé à la sonnerie

      L’affiche du hall, elle, reste : tout le monde la voit, de partout.

      Une variable créée dans une fonction est locale : elle vit dans le cadre de l’appel et disparaît avec lui1, 4. Une variable du programme principal est globale.

      programme : globalx = 100 dans test() : local x = 5 print(x) trouvé ici d’abord : 5

      Comme dans la salle : si le tableau dit x = 5, c’est ce x-là qu’on lit, même si l’affiche du hall dit x = 100.

      Deux x

      Une variable globale x et une variable locale x : laquelle s’affiche, et quand ?

      Deux xpas 1
      Python

        Pour trouver un nom, Python cherche dans l’ordre : le local, les fonctions englobantes, le global, puis les fonctions intégrées comme print3.

        intégrées : print, len, sum… global fonction englobante local print ? trouvé

        Hors de sa fonction, une variable locale n’existe pas :

        Python
        def f():
            y = 3
        
        f()
        print(y)
        NameError: name 'y' is not defined

        En JavaScript, la même erreur s’appelle ReferenceError: y is not defined.

        f() y = 3 fin de l’appel hors de f print(y) NameError

        Modifier une globale depuis une fonction ? Python exige le mot global3.

        À éviter
        compteur = 0
        def incrementer():
            global compteur
            compteur += 1

        À éviter : n’importe quelle fonction peut alors la changer en cachette.

        compteur globale def … def … def … ?

        Mieux : un paramètre et un return.

        Mieux
        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.

        incrementer paramètre n return n + 1 rien d’affiché rien de modifié ailleurs

        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.

        if (true) { … } let a = 1 var b = 2 var traverse le mur console.log(b)2 console.log(a)ReferenceError

        Python n’a pas de portée de bloc : une variable créée dans un if reste visible dans toute la fonction.

        Exercice 4

        Quel x ?

        Qu'affiche ce programme ?

        Python
        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.

        map × 2 1234 2468 la même consigne, pour chaque nombre

        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.

        Python
        nombres = [1, 2, 3, 4]
        doubles = map(lambda x: x * 2, nombres)
        print(list(doubles))
        [2, 4, 6, 8]

        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 :

        JavaScript
        const nombres = [1, 2, 3, 4];
        console.log(nombres.map(x => x * 2));
        [ 2, 4, 6, 8 ]
        x => x * 2 paramètre valeur rendue 1 2 2 4 3 6 4 8

        « Doubler x » dans six langages

        Python

        lambda x: x * 2

        le mot lambda, le paramètre, deux-points, une seule expression

        JavaScript

        x => x * 2

        une fonction fléchée : le paramètre, la flèche, la valeur

        Java

        x -> x * 2

        une flèche simple, faite d’un tiret et d’un chevron

        C#

        x => x * 2

        la même flèche qu’en JavaScript

        C++

        [](int x) { return x * 2; }

        les crochets ouvrent la lambda ; le type et le return sont écrits

        R

        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…

        caisse toi ??? 1234

        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.

        factorielle.py
        def factorielle(n):
            if n <= 1:    # cas de base
                return 1
            # cas récursif
            return n * factorielle(n - 1)
        
        print(factorielle(4))
        24

        Descendre, puis remonter

        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.

        Récursionpas 1
        Python

          Dans la vraie vie

          Deux miroirs face à face : chaque reflet contient un reflet plus petit, encore et encore.

          chaque reflet en contient un autre

          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.

          limite de la pile principalcompte(3)compte(2)compte(1)compte(0)compte(-1) … des centaines RecursionError un cadre par appel

          Où l’image s’arrête : le reflet s’efface peu à peu ; la pile, elle, déborde d’un coup.

          Et pourquoi pas une boucle, tout simplement ?

          Pour factorielle, on peut multiplier en boucle, non ?

          Bien vu : ici, une boucle suffit. La récursivité brille quand un problème contient des versions plus petites de lui-même.

          Comme des dossiers dans des dossiers : pour tout parcourir, on ouvre un dossier, puis on fait pareil avec chacun de ses sous-dossiers.

          Cours MathsChimie AlgèbreGéométrieTP

          Autres exemples : un arbre généalogique, certains tris.

          Exercice 5

          Descendre, remonter

          Que renvoie somme(3) ?

          Python
          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 ?

          1. def compte(n):
          2. if n == 0:
          3. return
          4. print(n)
          5. compte(n + 1)

          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.

          chef grillsaucesdesserts commandes assiettes prêtes

          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.

          calculer passe le travail +additionner /diviser ou
          calculatrice.pyPython
          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))
          pile d’appels console

          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.

          Exercice 6

          À toi d'écrire

          Remets les lignes dans l'ordre pour afficher la moyenne de 4, 5 et 6.

          1. def moyenne(notes):
          2. total = sum(notes)
          3. return total / len(notes)
          4. print(moyenne([4, 5, 6]))
          Le secret d’un programme facile à réparer ?

          Des fonctions courtes ?

          Des fonctions qui font chacune une seule chose. Le programme devient plus court, plus clair, et bien plus facile à réparer.

          La fiche en six cartes

          Définir, appeler

          Une fonction est un bloc de code avec un nom : on la définit une fois, on l’appelle autant qu’on veut.

          Paramètre, argument

          Le paramètre est dans la définition, l’argument dans l’appel ; le paramètre est une variable locale.

          return

          return renvoie une valeur et arrête la fonction ; sans return, Python renvoie None.

          La pile d’appels

          Chaque appel pose un cadre sur la pile ; le dernier appelé se termine le premier.

          Défauts et portée

          Un paramètre par défaut sert quand l’argument manque (Java : la surcharge). Une variable locale n’existe que dans sa fonction.

          Récursivité

          Une fonction récursive s’appelle elle-même ; sans cas de base, la pile déborde.

          Dix questions, zéro faute

          Mode survie

          Dix questions sur les fonctions (quatre faciles, trois moyennes, trois difficiles), zéro erreur autorisée.

          Attention aux questions sur return et print : elles piègent beaucoup de monde.

          10 questions · zéro faute · chronomètre

          Sources

          1. Modulo (Canton de Vaud, EPFL, UNIL, HEP Vaud), Programmation I : Définir, def et Paramétrer (définir et appeler, noms sans accents, paramètres et arguments, variables locales, valeurs par défaut), manuel d'informatique pour le gymnase, mis à jour en octobre 2025. définir · paramétrer
          2. Modulo (Canton de Vaud, EPFL, UNIL, HEP Vaud), Programmation I : Renvoyer, return (return arrête la fonction, une fonction qui ne renvoie rien renvoie None), mis à jour en octobre 2025. apprendre.modulo-info.ch
          3. Python Software Foundation, Tutoriel Python : définir des fonctions (espace de nommage local, global, None, valeurs par défaut évaluées une seule fois, arguments nommés, lambda), version 3.14, en français. docs.python.org
          4. MDN Web Docs (Mozilla), Fonctions (définir, portée, récursivité et pile, paramètres par défaut, fonctions fléchées), guide JavaScript en français. developer.mozilla.org
          5. MDN Web Docs (Mozilla), Pile d'exécution (call stack) (appel ajouté à la pile, retiré à la fin, dépassement de pile), glossaire en français. developer.mozilla.org
          6. Oracle, The Java Tutorials : Defining Methods (déclaration d'une méthode, surcharge selon le nombre et le type des arguments), consulté en septembre 2026. docs.oracle.com
          7. Python Software Foundation, Guide pratique : programmation fonctionnelle (fonctions sans effet de bord, dites purement fonctionnelles ; afficher un message est un effet de bord), version 3.14, en français. docs.python.org
          8. Python Software Foundation, Floating-Point Arithmetic: Issues and Limitations (les nombres à virgule sont stockés en fractions binaires, l'affichage arrondit la valeur stockée), tutoriel Python, version 3.14, en français. docs.python.org

          Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026.

          Glisser pour continuer vers Prog 6 : Tableaux & Listes
          Gymnase 1