Activités - Les fonctions (1)

2ème année maturité
Cours en classe inversée. Tu regardes d'abord la capsule vidéo (théorie), puis tu t'entraînes en trois temps : un quiz de compréhension, un texte à trous, et enfin la mise en pratique dans Thonny. Sauvegarde tes programmes sur OneDrive.
Objectifs de ce premier cours
  1. Comprendre l'utilité de définir des fonctions (éviter de se répéter, réutiliser, organiser).
  2. Connaître la structure d'une fonction : def, nom, paramètres, :, corps indenté, return.
  3. Savoir écrire et appeler des fonctions simples.
1. Je regarde la vidéo  →  2. Je fais le quiz  →  3. Je complète le texte à trous  →  4. Je programme dans Thonny

Regarde la vidéo en entier (tu peux la mettre en pause et revenir en arrière autant que tu veux). Tu peux avoir Thonny ouvert à côté pour retaper les exemples.

Tu utilises déjà des fonctions ! print(...), int(...), max(...), range(...), forward(...), penup()… sont toutes des fonctions prédéfinies. Dans ce cours, tu vas apprendre à créer tes propres fonctions.
À faire par l'enseignant·e : coller le lien d'intégration de la vidéo dans l'attribut src de la balise <iframe> ci-dessus (par ex. le lien « Intégrer » YouTube : https://www.youtube.com/embed/XXXXXXXXXXX).
Fiche mémo — à garder sous les yeux

Définir une fonction (elle ne s'exécute pas encore !) :

python 
def nom_de_la_fonction(parametre1, parametre2) :
    # corps de la fonction (indenté de 4 espaces)
    return resultat        # facultatif : retourne une valeur

Appeler la fonction (là, elle s'exécute) :

python 
nom_de_la_fonction(argument1, argument2)

Paramètre vs argument : le paramètre est le nom écrit dans la définition (parametre1), l'argument est la valeur donnée au moment de l'appel (argument1).

À retenir : print affiche à l'écran ; return retourne une valeur réutilisable dans la suite du programme.

Coche une réponse par question, puis clique sur Vérifier mes réponses. Si tu hésites, retourne voir le passage correspondant de la vidéo.

1. Pourquoi définit-on des fonctions ?

2. Quel mot-clé sert à définir une fonction ?

3. À la fin de la ligne qui commence par def, on met toujours…

4. Comment appelle-t-on les informations écrites entre les parenthèses, qu'on donne à la fonction ?

5. Que fait l'instruction return ?

6. Qu'est-ce qui délimite le corps (le contenu) d'une fonction ?

7. Quelle est la différence entre print et return ?

8. Comment nomme-t-on l'instruction de la ligne 10 ?

Modules Python

9. Que se passe-t-il si on définit une fonction mais qu'on ne l'appelle jamais ?

10. Dans saluer("Alice"), comment appelle-t-on la valeur "Alice" ?

Complète chaque trou en cliquant dedans, puis clique sur Vérifier. Les guillemets font partie de la réponse quand il y en a. Tu peux Copier le code (avec tes réponses) pour le tester dans Thonny.

Trou 1 — Définir et appeler Facile console

On définit une fonction sans paramètre, puis on l'appelle deux fois. Complète le mot-clé de définition, les deux-points, et l'appel de la fonction.

python 
 dire_bonjour()
    print("Bonjour et bienvenue !")

dire_bonjour
dire_bonjour
Trou 2 — Un paramètre Facile console

La fonction saluer reçoit un prénom en paramètre. Complète le nom du paramètre utilisé dans le print, puis passe le prénom de ton choix comme argument lors de l'appel (n'importe quel prénom entre guillemets, par ex. "Alice").

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

saluer()
Trou 3 — Renvoyer un résultat Moyen console

La fonction carre doit retourner le carré du nombre passé en argument. Complète le mot-clé qui retourne une valeur, puis récupère le résultat de l'appel dans une variable.

python 
def carre(nombre) :
     nombre * nombre
nombre = 
resultat = 
print(f"Le carré de {nombre} est", resultat)
Trou 4 — Deux paramètres Moyen console

Complète la définition de la fonction (mot-clé, nom, paramètres) et le calcul renvoyé : l'aire d'un rectangle est largeur * hauteur.

python 
    
        
        aire_rectangle(largeur, hauteur)
    return 

print("Aire :", aire_rectangle(5, 3))

Ouvre Thonny et crée un nouveau fichier pour chaque exercice (ou un seul fichier avec tout, comme tu préfères). Écris le programme, teste-le, puis compare avec le corrigé. Il y a plus d'exercices que nécessaire : va à ton rythme et monte en difficulté.

Facile Moyen Difficile console Turtle
Exercice 1 — Ma première fonction Facile console à écrire

Écris une fonction dire_bonjour(), sans paramètre, qui affiche « Bonjour, prêt à coder ? ». En dessous de ta fonction, appelle-la trois fois.

python 
def dire_bonjour() :
    print("Bonjour, prêt à coder ?")

dire_bonjour()
dire_bonjour()
dire_bonjour()
Remarque : une seule définition, mais on peut l'appeler autant de fois qu'on veut.
Exercice 2 — Une fonction qui salue Facile console à écrire

Écris une fonction saluer(prenom) qui affiche « Salut » suivi du prénom reçu en paramètre. Appelle-la avec trois prénoms différents de ton choix.

python 
def saluer(prenom) :
    print("Salut", prenom)

saluer("Alice")
saluer("Bob")
saluer("Chloé")
Variante avec f-string : print(f"Salut {prenom}").
Exercice 3 — Le carré d'un nombre Facile console à écrire

Écris une fonction carre(nombre) qui retourne (avec return) le carré du nombre. Ensuite, demande un nombre à l'utilisateur avec input, appelle ta fonction, et affiche le résultat.

python 
def carre(nombre) :
    return nombre * nombre

n = int(input("Donne un nombre entier : "))
print("Son carré est", carre(n))
Comme carre utilise return, on peut réutiliser sa valeur (ici directement dans le print).
Exercice 4 — L'aire d'un rectangle Moyen console à écrire

Écris une fonction aire_rectangle(largeur, hauteur) avec deux paramètres, qui retourne l'aire. Demande la largeur et la hauteur à l'utilisateur, puis affiche l'aire.

python 
def aire_rectangle(largeur, hauteur) :
    return largeur * hauteur

l = float(input("Largeur : "))
h = float(input("Hauteur : "))
print("L'aire du rectangle est", aire_rectangle(l, h))
Exercice 5 — La moyenne de deux notes Moyen console à écrire

Écris une fonction moyenne(a, b) qui retourne la moyenne de deux nombres. Teste-la en affichant, par exemple, la moyenne de 4.5 et 5.5, puis avec deux notes saisies au clavier.

python 
def moyenne(a, b) :
    return (a + b) / 2

print("Moyenne de 4.5 et 5.5 :", moyenne(4.5, 5.5))

note1 = float(input("Première note : "))
note2 = float(input("Deuxième note : "))
print("Ta moyenne est", moyenne(note1, note2))
N'oublie pas les parenthèses autour de a + b : sans elles, Python calculerait a + b/2.
Exercice 6 — Prix après réduction Moyen console à écrire

Écris une fonction prix_reduit(prix, remise) où remise est un pourcentage (par ex. 20 pour 20 %). La fonction retourne le prix à payer après réduction. Affiche par exemple le prix d'un article à 50 francs avec 20 % de remise.

python 
def prix_reduit(prix, remise) :
    return prix - prix * remise / 100

print("À payer :", prix_reduit(50, 20), "francs")
On calcule d'abord le montant de la remise (prix * remise / 100), puis on le soustrait au prix.
Exercice 7 — Réussi ou échoué ? (fonction + condition) Difficile console à écrire

Écris une fonction appreciation(note) qui retourne le texte "Réussi" si la note est supérieure ou égale à 4, et "Échoué" sinon. (Un if / else à l'intérieur de la fonction, avec un return dans chaque branche.) Teste-la avec plusieurs notes.

python 
def appreciation(note) :
    if note >= 4 :
        return "Réussi"
    else :
        return "Échoué"

print("Note 5.5 :", appreciation(5.5))
print("Note 3   :", appreciation(3))

ma_note = float(input("Ta note (1 à 6) : "))
print(appreciation(ma_note))
Dès qu'un return est exécuté, la fonction s'arrête et retourne sa valeur : les deux branches ne peuvent pas s'exécuter en même temps.
Exercice 8 — Réutiliser une fonction (Turtle) Difficile Turtle à écrire

C'est ici qu'on voit toute la puissance des fonctions ! Écris une fonction point_colore(x, y, couleur) qui déplace la tortue au point (x, y) (crayon levé) et y dessine un gros point dot(40) de la couleur donnée. Ensuite, appelle ta fonction plusieurs fois pour dessiner d'un coup plusieurs points de couleurs différentes.

Rappel Turtle : penup(), goto(x, y), color("..."), dot(taille).

python 
from turtle import *

def point_colore(x, y, couleur) :
    penup()
    goto(x, y)
    color(couleur)
    dot(40)

point_colore(-100, 0, "red")
point_colore(0, 0, "green")
point_colore(100, 0, "blue")
point_colore(0, 100, "orange")

hideturtle()
Sans fonction, il aurait fallu réécrire 4 lignes pour chaque point. Avec la fonction : une ligne par point. Voilà pourquoi les fonctions font gagner du temps !
Aller plus loin (bonus). Reprends l'exercice 8 et écris une fonction triangle(cote) qui dessine un triangle équilatéral (trois fois : forward(cote) puis left(120)). Appelle-la avec des tailles différentes. On combinera bientôt les fonctions avec les boucles pour aller encore plus vite.
Damien Cardinaux © 2024 - 2026. Ce site est sous licence CC BY-NC-SA 4.0