Activités - Les fonctions - partie n°2

2ème année maturité
Décomposer pour régner. Après la présentation en classe, tu t'entraînes en trois temps : un quiz de compréhension, un texte à trous, et enfin la mise en pratique dans Thonny avec un projet à décomposer. Sauvegarde tes programmes sur OneDrive.
Objectifs de ce deuxième cours
  1. Décomposer un problème en plusieurs petites fonctions qui coopèrent.
  2. Comprendre la portée des variables (locale / globale) et le bon réflexe : entrées par les paramètres, sortie par le return.
  3. Éviter le piège None : distinguer print (afficher) et return (retourner).
  4. Appliquer les bonnes pratiques (fichier structuré, noms clairs) et retourner plusieurs valeurs.
1. J'écoute le prof  →  2. Je fais le quiz  →  3. Je programme dans Thonny

Décomposer

Un gros problème → plusieurs petites fonctions qui font chacune une seule tâche et portent un nom clair (un verbe). Le programme principal ne fait qu'appeler ces fonctions, dans l'ordre.

Portée des variables

Une variable créée dans une fonction n'existe que là (elle est locale). Le bon réflexe : les données entrent par les paramètres et sortent par le return. On évite les variables globales.

Le piège None

print affiche à l'écran ; return retourne une valeur. Si une fonction ne fait qu'un print, alors x = ma_fonction() met None dans x. Pour réutiliser un résultat, il faut return.

Retourner plusieurs valeurs

Une fonction peut retourner plusieurs valeurs séparées par des virgules : return a, b. On les récupère d'un coup : x, y = ma_fonction().

Structure recommandée d'un fichier (bonne pratique) :

python 
### Imports
from random import *

### Fonctions

# Retourne la moyenne d'une liste de notes
def moyenne(notes):
    return sum(notes) / len(notes)

### Programme principal
notes = [4, 5, 6]
print("Moyenne :", moyenne(notes))

Coche une réponse par question, puis clique sur Vérifier mes réponses.

1. Décomposer un programme en petites fonctions, ça sert surtout à…

2. Une variable créée à l'intérieur d'une fonction (variable locale)…

3. Que vaut x après x = afficher_moyenne(notes) si afficher_moyenne fait seulement des print ?

4. Pour qu'une fonction transmette un résultat réutilisable au reste du programme, on utilise…

5. Dans un fichier bien structuré, le programme principal (les appels) se place…

6. Que fait return moy, mention ?

7. Quelle est la meilleure façon de nommer une fonction ?

8. Dans un programme bien décomposé, le rôle du programme principal est de…

Ouvre Thonny. Écris le programme, teste-le, puis compare avec le corrigé. Pense à la structure : ### Fonctions d'abord, ### Programme principal ensuite. Il y a plus d'exercices que nécessaire : va à ton rythme.

Facile Moyen Difficile console Turtle
Exercice 1 — Une fonction qui en appelle une autre Facile console à écrire

Définis la focntion perimetre(cote) qui retourne le périmètre d'un carré (4 * cote). Puis définis la fonction prix_cloture(perim, prix_metre) qui retourne le prix d'une clôture. Dans le programme principal, calcule le périmètre d'un terrain carré de 5 m, puis son prix de clôture à 12.50 fr/m.

python 
### Fonctions
def perimetre(cote):
    return 4 * cote

def prix_cloture(perim, prix_metre):
    return perim * prix_metre

### Programme principal
p = perimetre(5)
print("Périmètre :", p, "m")
print("Prix :", prix_cloture(p, 12.50), "fr")
prix_cloture réutilise le résultat de perimetre : deux petites fonctions valent mieux qu'une grosse.
Exercice 2 — Retours multiples Moyen console à corriger

Depuis l'exercice précédent, modifie ton programme pour n'avoir qu'une seule fonction qui retourne les deux résultats.

python 
### Fonctions
def perimetre(cote, prix_metre):
    perimetre = 4 * cote
    return perimetre, perimetre * prix_metre

### Programme principal
p, pr = perimetre(5, 12.50)
print("Périmètre :", p, "m")
print("Prix :", pr, "fr")
En passant par un paramètre, la fonction devient autonome : elle marche avec n'importe quelle valeur, pas seulement la globale nombre.
Exercice 3 — le générateur de mot de passe (décomposition) Difficile console à écrire

C'est l'exercice central du cours : décompose la fabrication d'un mot de passe en petites fonctions qui s'appellent entre elles. Écris :

  • lettre_aleatoire() — retourne une lettre minuscule au hasard.
  • chiffre_aleatoire() — retourne un chiffre (0 à 9) au hasard, sous forme de texte (attention au piège).
  • caractere_aleatoire() — retourne au hasard soit une lettre, soit un chiffre : elle appelle les deux fonctions précédentes.
  • mot_de_passe(longueur) — construit et retourne un mot de passe de la longueur demandée, en assemblant des caractères aléatoires dans une boucle.

Puis, dans le programme principal, affiche trois mots de passe de 10 caractères. Chaque fonction fait une seule chose !

Rappel : from random import *, puis choice(...) (choisit au hasard) et randint(a, b). Pour transformer un nombre en texte : str(nombre).

python 
### Imports
from random import *

### Fonctions
def lettre_aleatoire():
    lettres = "abcdefghijklmnopqrstuvwxyz"
    return choice(lettres)

def chiffre_aleatoire():
    return str(randint(0, 9))

def caractere_aleatoire():
    # au hasard : soit une lettre, soit un chiffre
    if randint(1, 2) == 1:
        return lettre_aleatoire()
    else:
        return chiffre_aleatoire()

def mot_de_passe(longueur):
    mdp = ""
    for i in range(longueur):
        mdp = mdp + caractere_aleatoire()
    return mdp

### Programme principal
print("Trois mots de passe de 10 caractères :")
print(mot_de_passe(10))
print(mot_de_passe(10))
print(mot_de_passe(10))
Remarque la hiérarchie : mot_de_passe appelle caractere_aleatoire, qui appelle lettre_aleatoire ou chiffre_aleatoire. Chaque fonction est minuscule et fait une seule chose — assemblées, elles résolvent un problème complet.
Bonus. Ajoute une fonction symbole_aleatoire() (par ex. choice("!@#$%*?")) et fais en sorte que caractere_aleatoire puisse aussi retourner un symbole.
Damien Cardinaux © 2024 - 2026. Ce site est sous licence CC BY-NC-SA 4.0