Quelle valeur possĂšde score Ă chaque appel de print() ?
score = 10
print(score)
score = 15
print(score)
- Une affectation avec
= remplace lâancienne valeur. - Il y a deux appels de
print(), donc deux lignes.
Solution expliquée10
15
Le premier affichage utilise la valeur initiale. Ensuite score = 15 remplace 10.
à toi : remplace 15 par score + 5, puis utilise le débogueur.
Python effectue la multiplication avant lâaddition.
resultat = 2 + 3 * 4
print(resultat)
- Calcule dâabord
3 * 4. - Ajoute ensuite
2.
Solution expliquée14
3 * 4 donne 12, puis 2 + 12 donne 14.
Ă toi : ajoute des parenthĂšses autour de 2 + 3 et compare.
Une seule des deux branches est exécutée.
temperature = 17
if temperature < 20:
print("Prends une veste")
else:
print("Il fait chaud")
- Compare
17 et 20. - Si la condition est vraie, Python nâentre pas dans
else.
Solution expliquéePrends une veste
17 < 20 vaut True. Python exécute donc le bloc indenté sous if.
Ă toi : teste avec temperature = 22.
Python teste les conditions de haut en bas et sâarrĂȘte Ă la premiĂšre qui est vraie.
note = 4.8
if note >= 5.5:
print("Excellent")
elif note >= 4:
print("Réussi")
else:
print("Ă revoir")
4.8 >= 5.5 est faux.- Le test suivant,
4.8 >= 4, est vrai.
Solution expliquéeRéussi
Le premier test échoue, le elif réussit et le else est ignoré.
Ă toi : trouve une valeur qui affiche chacun des trois messages.
range(dĂ©but, limite, pas) nâinclut jamais la limite.
for nombre in range(2, 8, 2):
print(nombre)
- La premiĂšre valeur est
2. - Ajoute
2 Ă chaque tour. - ArrĂȘte-toi avant
8.
Solution expliquée2
4
6
La boucle parcourt 2, 4, puis 6. La limite 8 est exclue.
Ă toi : remplace le pas par 3.
Observe lâindentation : le total nâest affichĂ© quâaprĂšs la boucle.
total = 0
for nombre in range(1, 5):
total = total + nombre
print(total)
range(1, 5) produit 1, 2, 3, 4.- Le total passe par
1, 3, 6, puis 10.
Solution expliquée10
Lâaccumulateur additionne chaque nombre. Le print() est hors de la boucle, donc il nâaffiche que le total final.
Ă toi : indente print(total) dans la boucle et compare.
La variable change à chaque tour, puis la condition est testée à nouveau.
tour = 1
while tour <= 3:
print("Tour", tour)
tour = tour + 1
- Le premier tour utilise la valeur
1. - AprĂšs lâaffichage,
tour augmente de 1. - La boucle sâarrĂȘte lorsque
tour vaut 4.
Solution expliquéeTour 1
Tour 2
Tour 3
La condition est vraie pour 1, 2 et 3, puis fausse pour 4.
Ă toi : retire temporairement lâincrĂ©mentation pour comprendre pourquoi une boucle peut devenir infinie.
Exercice 8 · Listes
Premier, deuxiĂšme, avant-dernier, dernier
Intermédiaire
Les indices positifs partent de gauche, les indices négatifs partent de droite.
couleurs = ["rouge", "vert", "bleu", "jaune"]
print(couleurs[0])
print(couleurs[1])
print(couleurs[-2])
print(couleurs[-1])
- Le premier indice dâune liste est
0. -1 dĂ©signe le dernier Ă©lĂ©ment.-2 dĂ©signe lâĂ©lĂ©ment juste avant le dernier.
Solution expliquéerouge
vert
bleu
jaune
0 et 1 lisent depuis le début ; -2 et -1 lisent depuis la fin.
à toi : affiche seulement le troisiÚme élément de la liste.
Une tranche liste[début:fin] inclut le début et exclut la fin.
nombres = [10, 20, 30, 40, 50]
milieu = nombres[1:4]
print(milieu)
- Lâindice
1 correspond Ă 20. - La borne
4 est exclue : 50 ne fait pas partie du résultat.
Solution expliquée[20, 30, 40]
La tranche conserve les Ă©lĂ©ments dâindices 1, 2 et 3.
Ă toi : essaie nombres[:3], puis nombres[2:].
Lâargument 6 entre dans la fonction sous le nom nombre.
def doubler(nombre):
resultat = nombre * 2
return resultat
print(doubler(6))
- Ă lâintĂ©rieur de la fonction,
nombre vaut 6. return renvoie le résultat au print().
Solution expliquée12
La fonction calcule 6 * 2, renvoie 12, puis print() lâaffiche.
Ă toi : appelle la fonction avec 9.
La valeur par dĂ©faut est utilisĂ©e seulement lorsquâaucun second argument nâest fourni.
def saluer(nom, message="Bonjour"):
print(message, nom)
saluer("Lina")
saluer("Noé", "Salut")
- Au premier appel,
message garde sa valeur par défaut. - Au second appel,
"Salut" remplace "Bonjour".
Solution expliquéeBonjour Lina
Salut Noé
Le premier appel utilise la valeur par défaut. Le second transmet explicitement les deux arguments.
Ă toi : inverse lâordre des appels et observe lâordre de la console.
append() ajoute Ă la fin, puis lâaffectation par indice remplace un Ă©lĂ©ment.
scores = [3, 5]
scores.append(7)
scores[0] = 4
print(scores)
print(len(scores))
- AprĂšs
append(7), la liste contient trois éléments. scores[0] = 4 remplace le premier élément, sans changer la longueur.
Solution expliquée[4, 5, 7]
3
La liste finale contient 4, 5 et 7. Sa longueur est donc 3.
Ă toi : ajoute scores.append(scores[-1] + 1).
Série avancée · Fonctions
Dâun appel simple Ă la rĂ©cursion extrĂȘme
Commence par repĂ©rer lâappel exĂ©cutĂ© en premier. Quand une fonction en appelle une autre, descends dans les appels avant de remonter avec les valeurs renvoyĂ©es par return. Les noms courts comme x, y et c sont volontairement rĂ©utilisĂ©s.
1 fonctionâ2 fonctionsâ3 fonctionsâRĂ©cursionâExtrĂȘme
Les paramĂštres x et c sont locaux. Ils ne remplacent pas les variables qui portent les mĂȘmes noms hors de la fonction.
def y(x, c):
x = x + c
c = x * 2
return x + c
x = 2
c = 3
print(y(c, x))
print(x, c)
- Lâappel
y(c, x) transmet dâabord 3, puis 2. - Dans la fonction,
x devient 5, puis c devient 10. - Les variables extĂ©rieures restent Ă©gales Ă
2 et 3.
Solution expliquée15
2 3
La fonction renvoie 5 + 10. Ses paramÚtres sont locaux, donc le second print() retrouve les valeurs extérieures inchangées.
Ă toi : inverse les deux arguments dans lâappel et prĂ©dis le nouveau rĂ©sultat.
Lis lâexpression de lâintĂ©rieur vers lâextĂ©rieur. La fonction x est appelĂ©e avant, pendant et aprĂšs y.
def x(n):
return n + 1
def y(n):
return x(n) * 2
print(x(y(x(3))))
- Lâappel le plus profond,
x(3), donne 4. y(4) appelle encore x(4), puis multiplie le résultat par 2.- Le dernier
x(...) ajoute encore 1.
Solution expliquée11
Les valeurs successives sont 3 â 4 â 5 â 10 â 11.
à toi : remplace le premier 3 par 5 sans exécuter immédiatement.
Un paramĂštre peut porter le mĂȘme nom quâune autre fonction. Observe ce que chaque nom reprĂ©sente dans son propre bloc.
def x(n):
return n - 1
def y(x):
return x * 2
def c(y):
return x(y) + 3
print(c(y(c(4))))
- Commence par
c(4). c(4) donne x(4) + 3, donc 6.- Calcule ensuite
y(6), puis applique une derniĂšre fois c.
Solution expliquée14
c(4) renvoie 6, y(6) renvoie 12, puis c(12) renvoie 14.
à toi : renomme mentalement les paramÚtres en valeur pour vérifier que les noms courts ne changent pas le calcul.
Python calcule les deux cĂŽtĂ©s de lâaddition de gauche Ă droite. Chaque appel affiche quelque chose avant de renvoyer sa valeur.
def x(n):
print("x", n)
return n + 1
def y(n):
print("y", n)
return x(n * 2)
def c(n):
print("c", n)
return y(n - 1) + x(n)
print(c(3))
c(3) affiche sa ligne avant de calculer son return.- Dans lâaddition,
y(n - 1) est entiÚrement calculé avant x(n). y(2) appelle x(4).
Solution expliquéec 3
y 2
x 4
x 3
9
y(2) renvoie 5, puis x(3) renvoie 4. Leur somme vaut 9.
Ă toi : inverse les deux termes de lâaddition dans c et prĂ©dis seulement lâordre des lignes.
La fonction y sâappelle elle-mĂȘme. Les affichages « aprĂšs » nâarrivent que pendant la remontĂ©e des appels.
def y(x):
if x == 0:
print("fin")
return 1
print("avant", x)
c = y(x - 1)
print("apres", x, c)
return c + x
print(y(3))
- La descente affiche
avant 3, avant 2, puis avant 1. - Le cas
x == 0 affiche fin et renvoie 1. - La remontĂ©e se fait dans lâordre
1, 2, 3.
Solution expliquéeavant 3
avant 2
avant 1
fin
apres 1 1
apres 2 2
apres 3 4
7
Le cas de base renvoie 1. Les retours deviennent ensuite 2, 4 et enfin 7.
Ă toi : dessine une pile avec quatre cadres, un pour chaque valeur de x.
Les fonctions sâappellent mutuellement. Ă chaque passage, n diminue, ce qui permet dâatteindre un cas dâarrĂȘt.
def x(n):
print("x", n)
if n == 0:
return 0
return y(n - 1) + 1
def y(n):
print("y", n)
if n == 0:
return 10
return x(n - 1) + 2
print(x(3))
- La chaĂźne dâappels commence par
x(3) â y(2) â x(1) â y(0). y(0) renvoie 10.- En remontant, ajoute successivement
1, puis 2, puis 1.
Solution expliquéex 3
y 2
x 1
y 0
14
Ă partir de 10, les retours valent 11, 13, puis 14.
à toi : essaie de prédire y(3) en changeant uniquement le premier appel.
La fonction x(1) sera exĂ©cutĂ©e deux fois Ă deux moments diffĂ©rents. Ne fusionne pas deux appels simplement parce quâils ont le mĂȘme argument.
def x(n):
print("x", n)
return n + 1
def y(n):
if n == 0:
return x(0)
return x(n) + y(n - 1)
def c(n):
print("c", n)
return y(n) - x(n - 1)
print(c(2))
y(2) calcule x(2) + x(1) + x(0).- Une fois
y(2) terminé, c(2) appelle encore x(1). - Le résultat de
y(2) vaut 6.
Solution expliquéec 2
x 2
x 1
x 0
x 1
4
La récursion produit 6. Le dernier x(1) renvoie 2, donc 6 - 2 donne 4.
Ă toi : compte le nombre total dâappels de x pour c(4).
Pour prĂ©parer lâappel rĂ©cursif, Python calcule dâabord n + c, puis appelle x(c). Suis sĂ©parĂ©ment les deux paramĂštres.
def x(n):
print("x", n)
return n - 1
def y(n, c):
print("y", n, c)
if c == 0:
return n
return y(n + c, x(c))
def c(n):
print("c", n)
return y(x(n), 2)
print(c(4))
c(4) commence par calculer x(4), qui renvoie 3.- Les appels de
y reçoivent successivement (3, 2), (5, 1) et (6, 0). - Chaque nouvel argument
c est produit par un appel Ă x.
Solution expliquéec 4
x 4
y 3 2
x 2
y 5 1
x 1
y 6 0
6
Le second paramĂštre descend de 2 Ă 0, tandis que le premier passe de 3 Ă 5, puis Ă 6.
à toi : écris un tableau avec les colonnes n, c et valeur renvoyée.
Chaque appel de y(n) peut crĂ©er deux nouveaux appels. Respecte lâordre de gauche Ă droite et nâoublie aucun affichage rĂ©pĂ©tĂ©.
def x(n):
print("x", n)
return n + 1
def y(n):
print("y", n)
if n <= 1:
return x(n)
return y(n - 1) + y(n - 2)
def c(n):
print("c", n)
return x(y(n))
print(c(3))
y(3) calcule entiÚrement y(2) avant le second y(1).y(2) appelle y(1), puis y(0).- AprÚs toute la récursion,
y(3) renvoie 5 et c appelle alors x(5).
Solution expliquéec 3
y 3
y 2
y 1
x 1
y 0
x 0
y 1
x 1
x 5
6
La branche y(2) renvoie 3, le second y(1) renvoie 2, puis x(5) produit le résultat final 6.
Ă toi : dessine lâarbre des appels de y(3) avant dâessayer y(4).