đ”ïžââïž Trace dâexĂ©cution
Lorsqu'on a un morceau de code, on peut souhaiter savoir dans quel ordre les instructions sont exécutées.
On veut spécifier précisément :
- Quelles lignes de code s'exécutent dans quel ordre.
- Les effets de chaque ligne de code :
- quelles variables sont créées/modifiées,
- quelles valeurs elles contiennent,
- ce qui est affiché (si on a des
print).
- La portée des variables.
- Le contexte :
globalesi la ligne est à l'extérieur de toute fonction, sinon le nom de la fonction en cours d'exécution.
đ Vous pouvez imprimer ce tableau de trace d'exĂ©cution pour pratiquer vos traces Ă la main.
- Exemple simple
- Avec fonction
- Avec condition
- Avec boucle
- Valider une trace
Pour l'instant, tout votre code est écrit à l'extérieur de toute fonction : on dit qu'il s'exécute dans le contexte global.
đ Ăcrivez donc globale dans la colonne contexte de chaque ligne, et « Globale » au-dessus de vos variables (ligne des portĂ©es).
Vous découvrirez à la rencontre 3 à quoi servent vraiment ces colonnes!
Traceâ
On aura la trace suivante :
| portée globale | ||||
|---|---|---|---|---|
| #ligne | contexte | a | b | affichage |
| 1 | globale | 7 | ||
| 2 | globale | 7 | 14 | |
| 3 | globale | 7 | 14 | salut 14 |
Dans le cas d'une séquence d'instructions, on peut voir que les instructions sont exécutées dans l'ordre de lecture du code. Simple!
Codeâ
Si on a le code suivant :
def carre(n):
return n * n
def affiche_resultat():
a = 2
b = 3
total = carre(a) + carre(b)
print(f'La somme des carrés est : {total}')
z = 42
affiche_resultat()
Traceâ
On aura la trace suivante :
| Portées et variables | |||||||
|---|---|---|---|---|---|---|---|
| globale | affiche_resultat | carre | |||||
| #ligne | contexte | z | a | b | total | n | affichage |
| 10 | globale | 42 | |||||
| 11 | globale | 42 | |||||
| 5 | affiche_resultat | 42 | 2 | ||||
| 6 | affiche_resultat | 42 | 2 | 3 | |||
| 7 | affiche_resultat | 42 | 2 | 3 | |||
| 2 | carre | 42 | 2 | ||||
| 7 | affiche_resultat | 42 | 2 | 3 | |||
| 2 | carre | 42 | 3 | ||||
| 7 | affiche_resultat | 42 | 2 | 3 | 13 | ||
| 8 | affiche_resultat | 42 | 2 | 3 | 13 | La somme des carrés est : 13 | |
Explicationsâ
La colonne #ligne correspond exactement aux numéros de lignes que vous voyez défiler dans votre éditeur lorsque vous exécutez votre programme en mode débogage (pas à pas). Chaque ligne de la trace représente un moment précis de l'exécution, tout comme chaque fois que vous appuyez sur Pas suivant (Step Over / Step Into) dans le débogueur.
Produire une trace Ă la main, c'est donc faire le travail du dĂ©bogueur dans votre tĂȘte.
On indique la portée des variables en les regroupant par portée (premiÚre ligne).
Ici, on a la portée globale (variables définies en dehors de toute fonction), la portée de affiche_resultat() et la portée de carre().
On remarque que la variable n n'existe que dans la portée de la fonction carre(), et que les variables a, b et total n'existent que dans la portée de la fonction affiche_resultat().
La variable z est dans la portée globale, c'est pourquoi elle est visible dans toute la trace.
La colonne contexte indique oĂč se trouve l'exĂ©cution au moment de chaque ligne :
globalelorsque la ligne exécutée est à l'extérieur de toute fonction (le programme principal);- le nom de la fonction en cours d'exécution lorsque la ligne exécutée est à l'intérieur d'une fonction.
Dans l'exemple ci-dessus :
- Ă la ligne 11, l'appel
affiche_resultat()se fait depuis le programme principal : le contexte est encoreglobale. - Aux lignes 5 à 8, on exécute le code de
affiche_resultat: le contexte estaffiche_resultat. - Ă la ligne 7,
carre(a)est appelée : la ligne suivante (ligne 2) s'exécute dans le contextecarre. - Une fois le
returnexécuté, on revient à la ligne 7, de nouveau dans le contexteaffiche_resultat.
đ Le contexte indique quelles variables sont accessibles : seules celles de la portĂ©e globale et de la portĂ©e du contexte courant ont une valeur sur cette ligne de la trace.
Voici maintenant un petit exemple qui dĂ©montre l'importance de spĂ©cifier la portĂ©e des variables, oĂč on a une variable x dans la portĂ©e globale et une autre variable nommĂ©e x dans la portĂ©e de la fonction ma_fonction().
Codeâ
def ma_fonction(y):
x = 3 + y
print(f'dans ma_fonction, x vaut {x}')
x = 5
print(f'dans main, x vaut {x}')
ma_fonction(100)
print(f'dans main, x vaut toujours {x}')
Traceâ
| Portées et variables | |||||
|---|---|---|---|---|---|
| globale | ma_fonction | ||||
| #ligne | contexte | x | y | x | affichage |
| 5 | globale | 5 | |||
| 6 | globale | 5 | dans main, x vaut 5 | ||
| 7 | globale | 5 | |||
| 2 | ma_fonction | 5 | 100 | 103 | |
| 3 | ma_fonction | 5 | 100 | 103 | dans ma_fonction, x vaut 103 |
| 8 | globale | 5 | dans main, x vaut toujours 5 | ||
- On voit que la variable
xdans la portée dema_fonction()n'a rien à voir avec la variablexdans la portée globale. - Cette derniÚre n'est pas modifiée par l'exécution de
ma_fonction(), malgré le fait qu'on ait une instructionx = 3 + ydansma_fonction()et que la variable globalexsoit aussi accessible dansma_fonction()(car elle est globale). - La raison est que l'instruction
x = 3 + ycrée une nouvelle variable localexdans la portée dema_fonction(), qui masque la variable globalex. - Si on voulait modifier la variable globale
xdansma_fonction(), il faudrait utiliser le mot-cléglobal(ce qui est déconseillé en général).
- Certaines lignes ne s'exécutent pas, c'est le principe de la condition!
- On indique les lignes qui testent une condition :
if,elif,match,case(mais paselsenicase _).
Codeâ
Si on a le code suivant :
a = 42
if a > 100:
print('a est grand')
elif a > 10:
print('a est moyen')
elif a > 1:
print('a est petit')
else:
print('a est trĂšs petit')
if a == 0:
print('a est nul')
else:
print('fin')
Traceâ
On aura la trace suivante :
| portée globale | |||
|---|---|---|---|
| #ligne | contexte | a | affichage |
| 1 | globale | 42 | |
| 2 | globale | 42 | |
| 4 | globale | 42 | |
| 5 | globale | 42 | a est moyen |
| 11 | globale | 42 | |
| 14 | globale | 42 | fin |
- Certaines lignes s'exécutent plusieurs fois, c'est le principe de la boucle!
- On indique les lignes qui testent une condition (
whileetfor).
Traceâ
On aura la trace suivante :
| portée globale | |||
|---|---|---|---|
| #ligne | contexte | i | affichage |
| 1 | globale | 0 | |
| 2 | globale | 0 | |
| 3 | globale | 0 | i vaut 0 |
| 4 | globale | 1 | |
| 2 | globale | 1 | |
| 3 | globale | 1 | i vaut 1 |
| 4 | globale | 2 | |
| 2 | globale | 2 | |
| 5 | globale | 2 | fin |
Afin de valider une trace :
- Placer un point d'arrĂȘt sur la premiĂšre ligne qui s'exĂ©cute.
- Lancer l'exécution en mode débogage.
- Sauter de ligne en ligne pour voir si la trace est correcte.
Si on se rend à la fin de l'exécution et que toutes tes valeurs étaient bonnes, on a bien compris ce que fait le code.