Produire une trace d'exécution

Si un as un morceau de code, on peut souhaiter savoir dans quel ordre les instructions sont exécutées.

Pour cela, on peut utiliser un outil de traçage.

Principe

On veut accomplir 2 éléments principaux:

1. indiquer quelles lignes de code s'exécutent dans quel ordre
2. indiquer les effets de chaque ligne de code

Exemple simple

Si on a le code suivant:

a = 3 + 4
b = a * 2
print("salut " + str(b))

Trace

On aura la trace suivante:

ligne exécutée	effet
a = 3 + 4	a: 7
b = a * 2	a: 7, b: 14
print("salut " + str(b))	a: 7, b: 14, affiche "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!

Exemple avec boucle

Si on a le code suivant:

for i in range(3):
    if (i % 2 == 0):
        print("c'est pair " + str(i))
    else:
        print("ah ben ah ben, c'est impair " + str(i))

Trace

On aura la trace suivante:

ligne exécutée	effet
for i in range(3):	i parcourt l'interval 0, 1, 2
if (i % 2 == 0):	i: 0 i%2 vaut 0
print("c'est pair " + str(i))	i: 0 affiche "c'est pair 0"
if (i % 2 == 0):	i: 1 i%2 vaut 1
print("ah ben ah ben, c'est impair " + str(i))	i: 1 affiche "ah ben ah ben, c'est impair 1"
if (i % 2 == 0):	i: 2 i%2 vaut 0
print("c'est pair " + str(i))	i: 2 affiche "c'est pair 2"

On voit que:

• on n'indique que les lignes qui s'exécutent en vrai
• certaines lignes s'exécutent plusieurs fois, c'est le principe de la boucle

Exemple avec une fonction

Si on a le code suivant:

def ma_fonction(a, b):
    c = a + b
    return c
mavariable = 3
tavariable = 5
z = ma_fonction(mavariable, tavariable)
y = ma_fonction(4, 9)
print("z vaut " + str(z) + " et y vaut " + str(y))

Trace

S'il y a des fonctions dans le code, on ajouter la pile d'appels pour indiquer quelles fonctions ont été commencées mais pas finies.

ligne exécutée	effet	pile d'appels
mavariable = 3	mavariable: 3	main
tavariable = 5	mavariable: 3 tavariable: 5	main
z = ma_fonction(a, b)	mavariable: 3 tavariable: 5 appelle ma_fonction avec a→3 et b→5	main
c = a + b	a: 3 b: 5 c: 8	ma_fonction main
return c	a: 3 b: 5 c: 8, retourne 8, z = 8	ma_fonction main
y = ma_fonction(4, 9)	mavariable: 3 tavariable: 5 z: 8 appelle ma_fonction avec a→4 et b→9	main
c = a + b	a: 4 b: 9 c: 13	ma_fonction main
return c	a: 4 b: 9 c: 13 retourne 13, y = 13	ma_fonction main
print("z vaut " + str(z) + " et y vaut " + str(y))	mavariable: 3 tavariable: 5 z: 8 y = 13 affiche "z vaut 8 et y vaut 13"	main

Dans ce cas, on doit ajouter la pile d'appels pour indiquer quelles fonctions ont été commencées mais pas finies.

Valider ta trace

Afin de valider ta trace, tu vas utiliser le débogueur de ton IDE préféré.

1. place un point d'arrêt sur la première ligne qui s'exécute
2. lance l'exécution en mode débogage
3. saute d'une ligne en une ligne pour voir si ta trace est correcte

Si tu te rends à la fin de l'exécution et que toutes tes valeurs étaient bonnes, tu as bien compris ce que fait le code.