Niveau : moyen. Durée estimée : 60 min. 10 exercices avec corrections détaillées.
Rappel des notions clés
Une fonction est un bloc de code qui porte un nom : elle reçoit des valeurs, ses paramètres, et renvoie un résultat avec return. Avec def carre(x): return x * x, l'appel carre(5) vaut 25. Une liste range des valeurs dans l'ordre et numérote leurs places à partir de 0 : ce numéro s'appelle l'indice. Dans t = [4, 7, 9], t[0] vaut 4 et le dernier élément est t[len(t) - 1], c'est-à-dire t[2].
Un dictionnaire associe des clés à des valeurs : dans d = {"nom": "Lina", "note": 14}, d["note"] vaut 14. On parcourt une liste avec for x in t, un dictionnaire avec for cle, valeur in d.items(). Lire une clé absente, comme d["age"], déclenche l'erreur KeyError : on vérifie d'abord avec "age" in d, qui vaut True ou False (documentation Python, « Structures de données »).
Ces notions sont au programme de NSI de première (arrêté du 17 janvier 2019), qui appelle « tableau » ce que Python appelle « liste ».
Syntaxe à retenir :
- Fonction :
def nom(parametre):puis, en retrait,return resultat. - Liste :
t.append(x)ajoutexà la fin ;len(t)donne le nombre d'éléments. - Liste en compréhension, construite en une ligne :
[2 * x for x in t]vaut[8, 14, 18]; unifplacé à la fin filtre les éléments. - Dictionnaire :
d["age"] = 16crée l'entrée ou remplace sa valeur ;del d["age"]la supprime.
Piège classique : print affiche une valeur à l'écran, return la renvoie au programme qui a appelé la fonction. Une fonction sans return renvoie None, la valeur « rien » de Python : après x = f(3), x vaut alors None. C'est aussi ce que renvoie sort(), qui trie la liste elle-même au lieu d'en fabriquer une nouvelle (documentation Python).
Exercices : niveau facile
Exercice 1 : Écris une fonction moyenne(nombres) qui reçoit une liste de nombres non vide et renvoie leur moyenne, en parcourant la liste avec une boucle for. Calcule ensuite moyenne([10, 20, 30, 40]).
Correction :
On additionne les éléments un par un, puis on divise par leur nombre.
def moyenne(nombres):
total = 0
for x in nombres:
total = total + x
return total / len(nombres)Le total vaut 100 pour 4 éléments : $\dfrac{100}{4} = 25$. L'opérateur / renvoie toujours un nombre à virgule (un flottant), d'où le résultat 25.0.
La liste doit être non vide : avec [], le programme divise par 0 et s'arrête sur une erreur.
Exercice 2 : Écris un programme qui demande trois fruits à l'utilisateur avec input, les range dans une liste, puis affiche le deuxième fruit en majuscules. La méthode upper(), qui s'écrit après un point, met un texte en majuscules : "kiwi".upper() vaut "KIWI". Qu'affiche le programme si l'on saisit pomme, banane, orange ?
Correction :
On remplit une liste vide avec append, puis on lit l'élément d'indice 1.
fruits = []
for i in range(3):
fruits.append(input("Fruit : "))
print(fruits[1].upper())La liste vaut ["pomme", "banane", "orange"] et le programme affiche BANANE.
Erreur à éviter : fruits[2] donne le troisième fruit, car les indices partent de 0.
Exercice 3 : Le dictionnaire eleve = {"nom": "Alice", "age": 17, "note": 15} décrit une élève. Écris une fonction presenter(eleve) qui affiche « Alice a 17 ans et 15 de moyenne. » en lisant chaque valeur dans le dictionnaire.
Correction :
On lit chaque valeur avec eleve[cle], la clé écrite entre guillemets.
def presenter(eleve):
print(eleve["nom"], "a", eleve["age"], "ans et", eleve["note"], "de moyenne.")print sépare ses morceaux par un espace. L'appel presenter(eleve) affiche Alice a 17 ans et 15 de moyenne.
Exercices : niveau moyen
Exercice 4 : Écris une fonction filtrer_pairs(liste) qui renvoie une nouvelle liste ne contenant que les nombres pairs de liste, en une ligne, avec une liste en compréhension. Que renvoie filtrer_pairs([1, 2, 3, 4, 5, 6]) ?
Correction :
Un nombre est pair quand le reste de sa division par 2 est nul, ce que teste n % 2 == 0.
def filtrer_pairs(liste):
return [n for n in liste if n % 2 == 0]Résultat : [2, 4, 6]. La liste de départ n'est pas modifiée.
Exercice 5 : Une épicerie suit son stock dans le dictionnaire stock = {"pommes": 10, "bananes": 5, "oranges": 8}. Elle reçoit 10 bananes et arrête de vendre des pommes. Écris une fonction mettre_a_jour(stock) qui ajoute 10 au stock de bananes et supprime l'entrée des pommes, puis donne le dictionnaire obtenu.
Correction :
On change une valeur en l'affectant à sa clé, et on supprime une entrée avec del.
def mettre_a_jour(stock):
stock["bananes"] = stock["bananes"] + 10
del stock["pommes"]La fonction modifie le dictionnaire qu'on lui donne : après l'appel, stock vaut {"bananes": 15, "oranges": 8}.
Exercice 6 : Un élève veut une fonction qui renvoie la liste des doubles. Il écrit :
def doubler(liste):
for x in liste:
print(2 * x)
resultat = doubler([1, 2, 3])
print(resultat)Qu'affiche ce programme ? Corrige la fonction pour que resultat vaille [2, 4, 6].
Correction :
La fonction affiche les doubles mais ne contient aucun return : elle renvoie donc None. Le programme affiche 2, 4 et 6, un par ligne, puis None.
Il faut construire la liste et la renvoyer :
def doubler(liste):
return [2 * x for x in liste]Cette fois, print(resultat) affiche [2, 4, 6].
Exercices : niveau difficile
Exercice 7 : Écris une fonction longueurs(mots) qui reçoit une liste de mots et renvoie un dictionnaire associant chaque mot à sa longueur (son nombre de caractères). Que renvoie longueurs(["code", "python", "liste"]) ?
Correction :
On part d'un dictionnaire vide et on crée une entrée par mot.
def longueurs(mots):
resultat = {}
for mot in mots:
resultat[mot] = len(mot)
return resultatRésultat : {"code": 4, "python": 6, "liste": 5}. Un mot présent deux fois ne crée pas deux entrées : une clé est unique, sa valeur est simplement réécrite.
Exercice 8 : Une classe est décrite par une liste de dictionnaires :
classe = [{"nom": "Lina", "note": 14},
{"nom": "Tom", "note": 17},
{"nom": "Inès", "note": 12}]Écris une fonction meilleur(classe) qui renvoie le nom de l'élève ayant la meilleure note. La liste n'est jamais vide.
Correction :
C'est une recherche de maximum : on garde le meilleur élève vu jusqu'ici et on le remplace dès qu'une note est plus haute.
def meilleur(classe):
champion = classe[0]
for eleve in classe:
if eleve["note"] > champion["note"]:
champion = eleve
return champion["nom"]Tom (17) remplace Lina (14), puis Inès (12) ne le dépasse pas : la fonction renvoie "Tom".
Partir du premier élément évite d'inventer une note de départ qui pourrait fausser le résultat.
Exercice 9 : Deux magasins comptent leurs fournitures : m1 = {"stylos": 12, "cahiers": 5} et m2 = {"cahiers": 3, "gommes": 4}. Écris une fonction fusionner(d1, d2) qui renvoie un nouveau dictionnaire réunissant les deux : quand une clé est dans les deux, on additionne les valeurs. Donne fusionner(m1, m2).
Correction :
On recopie d1 dans un dictionnaire neuf, puis on parcourt d2 avec items() en testant si chaque clé existe déjà.
def fusionner(d1, d2):
total = {}
for cle, valeur in d1.items():
total[cle] = valeur
for cle, valeur in d2.items():
if cle in total:
total[cle] = total[cle] + valeur
else:
total[cle] = valeur
return totalRésultat : {"stylos": 12, "cahiers": 8, "gommes": 4}.
Sans le test if cle in total, la lecture de total["gommes"], clé absente, déclencherait une KeyError.
Exercice 10 : Écris une fonction sans_doublons(liste) qui renvoie les valeurs de liste sans répétition, rangées de la plus grande à la plus petite, en construisant la nouvelle liste avec une boucle. Teste-la avec [4, 1, 4, 7, 1, 9].
Correction :
On ne garde une valeur que si elle n'est pas déjà dans la nouvelle liste, puis on trie avec sort(reverse=True), qui range dans l'ordre décroissant.
def sans_doublons(liste):
unique = []
for x in liste:
if x not in unique:
unique.append(x)
unique.sort(reverse=True)
return uniqueLa boucle donne [4, 1, 7, 9], et le tri [9, 7, 4, 1].
Erreur à éviter : écrire unique = unique.sort(reverse=True). Comme sort() renvoie None, unique vaudrait None.
Bilan et conseils
Avant de rendre une fonction, teste-la sur un exemple dont tu connais la réponse, puis sur un cas limite comme une liste vide ou une clé absente. Si un résultat vaut None, cherche le return qui manque.
Ce qu'il faut retenir : les indices d'une liste partent de 0 ; on teste une clé avec in avant de la lire ; une fonction qui doit fournir un résultat le renvoie avec return, pas avec print.
Sources
- Programme de numérique et sciences informatiques de première générale, fixé par l'arrêté du 17 janvier 2019 : texte du programme sur eduscol.
- Documentation Python, tutoriel, « Définir des fonctions » : docs.python.org.
- Documentation Python, tutoriel, « Structures de données » : docs.python.org.