Déboguer son code

Le débogueur (debugger) est un moyen d'exécuter le code ligne à ligne et de pouvoir visualiser et modifier l'état interne de l'interpréteur. Ceci permet de très rapidement corriger un programme.

Comprendre comment fonctionne un débogueur vous permet également de comprendre comment fonction un interpréteur et par là comment s'exécute un programme informatique.

L'idée est de remplacer les divers print utilisés pour visualiser un problème par une exécution contrôlée du code et de pouvoir stopper son exécution à des endroit prédéterminés appelés breakpoint.

Breakpoint et exécution pas à pas

x = 4
for i in range(10):
    print(i)
    if x == i:
        print("égalité !")

print("c'est fini.")

Exécution du debugger

On peut exécuter le programme via le debugger de plusieurs façons :

• menu exécuter > démarrer le débogage
• choisir le menu exécuter (menu affichage > exécuter) puis cliquer sur exécuter et déboguer.

Une fois le programme lancé il a du s'exécuter et afficher dans le terminal :

0
1
2
3
4
égalité !
5
6
7
8
9
c'est fini.

Il ne s'est rien passé de plus que si vous aviez exécuté votre programme python normalement.

C'est normal par il faut demander explicitement au débogueur de s'arrêter un créant un point d'arrêt (breakpoint).

Création d'un breakpoint

Pour créer un point d'arrêt (breakpoint) :

• menu exécuter > activer/désactiver le point d'arrêt
• cliquer sur la gouttière du fichier, à gauche des numéros de lignes (vous savez que vous êtes au on endroit lorsque un disque rouge foncé apparaît)
• appuyer sur la touche <F9>

Une fois le breakpoint placé, un point rouge doit apparaître dans la gouttière du fichier :

On voit que le breakpoint est actif car il est sélectionné en bas à gauche du panneau du débogueur

Lancement du débogueur

Le breakpoint est placé à la ligne 1 :

On a plusieurs types d'actions possibles (le nom de l'action apparaît lorsque la souris est placée dessus) :

• les actions bleues, Continuer, pas à pas principal, pas à pas détaillé et pas à pas sortant qui gèrent l'exécution de l'interpréteur :
  • Continuer : l'interpréteur se lance et s'arrête à l prochaine ligne avec un breakpoint qu'il rencontre
  • pas à pas principal (step over) : l'interpréteur exécute la ligne
  • pas à pas détaillé (step into) : si la ligne consiste à exécuter une fonction que l'on a écrite, l'interpréteur d'arrête juste après l'appel de la fonction
  • pas à pas sortant : si l'interpréteur exécute une fonction que l'on a écrite, l'interpréteur continue son exécution jusqu'à ce qu'il sorte de la fonction
• l'action verte, Redémarrer, qui redémarre le débogueur
• l'action rouge, Arrêter, qui stoppe le débogueur

Action Continuer

L'interpréteur à continué son exécution jusqu'à trouver une ligne avec un breakpoint, ce qu'il n'a pas trouvé.

Vous devriez vous retrouver dans l'état suivant :

On voit l'état interne de l'interpréteur avec les deux variables i (valant 0) et x valant 4 (ces deux variables sont également ici des variables globales, on verra pourquoi plus tard).

Action pas à pas principal

L'interpréteur est remonté en ligne 2. Puisque i est différent de x, le bloc conditionnel n'est pas considéré. Voyez que l'instruction for n'est pas exécuté puisque i vaut toujours 0.

Continuons d'exécuter cette action :

La ligne 2 a été exécutée : i vaut bien 1.

Vous devez vous retrouver devant l'état suivant :

L'interpréteur à du s'arrêter en ligne 5

Vous devriez voir la ligne égalité s'afficher dans le terminal.

L'interpréteur va continuer son exécution jusqu'à la fin du programme.

Breakpoint conditionnel

Supposons que l'on veuille juste vérifier que notre condition if fonctionne bien. On s'en fiche des cas où i est différent de x lors de l'exécution du programme, donc inutile de s'arrêter à chaque fois que l'interpréteur passe en ligne 4.

Pour cela, on peut créer des breakpoint conditionnels :

Placement du breakpoint conditionnel :

Valeur du breakpoint conditionnel, en passant la souris dessus :

Vous devriez vous arrêter au breakpoint de la ligne 4, mais i vaut 4 (donc x).

Pour finir cette partie, sortons du débogueur :

Autre Breakpoint

Outre les breakpoint simple et les breakoint conditionnel, il existe deux autres types de points d'arrêts:

• les points de journalisation (logpoint) : comme un print
• les nombres d'accès : s'arrête lorsque le nombre d'accès est atteint

Gestion des Fonctions

def test_égalité(i, x):
    print("fonction test_égalité avec comme paramètre :", i, x)
    if x == i:
        print("égalité !")


x = 4
for i in range(10):
    print(i)
    test_égalité(i, x)

print("c'est fini.")

Ce programme va vous permettre de voir :

• les actions pas à pas détaillée et pas à pas sortant
• le concept de variables locales et globales

Différentes actions pas à pas

Nous allons voir la différence entre les différents types d'actions.

pas à pas principal

Normalement, l'interpréteur a :

1. effectué la ligne 10 et exécuté la fonction test_égalité. On sait que la fonction a été exécutée car :
   • elle a affiché fonction test_égalité avec comme paramètre : 0 4 sur le terminal
   • le débogueur garde la valeur de retour de la fonction. Ici None puisque notre fonction ne rend rien (elle ne fait qu'afficher des choses à l'écran).
2. l'interpréteur s'est arrêté au début de la prochaine instruction, qui est à la ligne 8 : c'est la boucle for.

Changeons de type d'action.

pas à pas détaillé

Vous voyiez que l'interpréteur ne s'est pas arrêté à la ligne 8 comme précédemment, mais à la ligne 2 c'est à dire juste avant le début de l'exécution de la fonction test_égalité :

La prochaine ligne de code à exécuter est la ligne 2, qui est un print.

Vous remarquez que l'interpréteur est maintenant arrêté au début de la ligne 3 et a affiché fonction test_égalité avec comme paramètre : 1 4 sur le terminal :

Continuons notre programme jusqu'à la prochaine exécution de la fonction :

Vous devriez vous retrouver en début de ligne deux.

pas à pas sortant

Vous devez vous retrouver ligne 10.

Nous allons exhiber ce comportant en créant un petit programme. Mais avant tout sortons de débogueur :

Faisons le test en créant le petit programme suivant :

def somme(x, y):
    return x + y


x = 2
y = 10
s = somme(x, y)

print(" La somme de", x, "et", y, "vaut :", s)

Analysons les variables présentes :

• le retour de la fonction somme, valant 12
• la variable x, valant 2
• la variable y, valant 10

Remarquez que la variable s n'existe pas encore : l'interpréteur est sorti de la fonction (on a son résultat) mais n'a pas encore créer de variable s pour y stocker son résultat.

Remarquez que la variable s a été créée et vaut 12.

Pile des appels

Lorsque l'on exécute une fonction, on ne passe à la ligne suivante que lorsque la fonction est terminée, c'est à dire lorsque toutes les instructions de la fonction ont été effectuées. Ce processus est récursif : on peut appeler une fonction à l'intérieur d'une fonction...

Ce mécanisme est gérféavec ce que l'on appelle une pile d'exécution (ou pile d'appels) :

Pour visualiser ce mécanisme, créons un petit programme :

def factorielle(n):
    if n <= 1:
        return n
    else:
        return n * factorielle(n - 1)


n = 10
print(factorielle(n))

La fonction étant récursive, à chaque appel de la fonction, on va passer par le breakpoint et s'arrêter. Vous devriez vous retrouver dans une situation identique celle ci-dessous :

Dans la partie VARIABLES :

• La partie locals donne les variables définies dans l'espace de noms de la fonction actuelle. Ici n (son paramètre), qui vaut 7
• La partie globals donne :
  • les variables définies dans l'espace de nom principal. Ici n (définie ligne 8), qui vaut 10
  • deux champs spéciaux permettant le fonctionnement interne de python :
    • les noms spéciaux de python dans la partie special variables
    • les fonctions définies, ici uniquement factorielle, ainsi que ses variables spéciales permettant de l'exécuter

La partie PILE DES APPELS contient tous les appels de fonctions actuels. Il y en a 5, et cela se lit de haut en bas. La plus haute contient l'appel actuel, celui où le paramètre n vaut 7. On voit qu'elle est actuellement positionnée ligne 2.

Cette fonction a été appelée par la fonction en-dessous-d'elle dans la pile d'appels.

Vous devriez vous retrouver dans une situation identique celle ci-dessous :

On voit :

• l'espace de noms de la fonction sélectionné dans la partie locals de la section VARIABLES (un paramètre n valant 8)
• sa position actuelle (ligne 5)

On se trouve au niveau du programme principal :

• les parties locals et globals de la section VARIABLES coincident
• c'est la ligne 9 qui est exécutée

Terminons cette exécution en voyant la pile d'appel se vider :

On est en fin de récursion. On peut maintenant voir toutes les différentes récursions se terminer :

Remarquez que la première fonction factorielle à s'arrêter le fait en ligne 3, et toutes les autres en ligne 5. Remarquez alors que l'on connaît le retour de la fonction dans la partie locals de la section VARIABLES.

Espions

Lorsque l'on a beaucoup de variables, on peut spécifier des espions qui permettent d'avoir toujours la variable souhaitée à portée de main. Ces espions sont des expressions, ils permettent donc d'afficher la valeur de nombres possibilités :

• une variable
• une expression (comme une somme, une formule, etc)
• l'exécution d'une fonction
• un bout de liste
• ...

En utilisant le fichier pile-appels.py et un breakpoint en ligne 2, on peut par exemple créer les 3 espions suivant :

• n qui montre la valeur locale n
• n > 1 qui montre le résultat d'une expression
• factorielle(n) qui montre le résultat de la fonction factorielle pour la valeur locale de n

Exercice

Le code ci-dessous est une implémentation python du crible d’Ératosthène :

def élague(x, crible):
    y = 2 * x
    while y < len(crible):
        crible[y] = False
        y += x


def nouveau_max_premier(ancien_max, crible):
    nouveau_max = ancien_max
    while not crible[nouveau_max]:
        nouveau_max -= 1

    return nouveau_max


def nouveau_min_premier(ancien_min, crible):
    nouveau_min = ancien_min
    while not crible[nouveau_min]:
        nouveau_min += 1

    return nouveau_min


def érathostène(n):
    crible = [True] * (n + 1)
    crible[0] = False
    crible[1] = False

    x = 2
    max_premier = len(crible) - 1

    while x ** x < max_premier:
        élague(x, crible)
        max_premier = nouveau_max_premier(max_premier, crible)

        if x < max_premier:
            x = nouveau_min_premier(x + 1, crible)

    return [i for i in range(len(crible)) if crible[i]]


n = 13

print("Les nombres premiers plus petits que", n, "sont :")
print(érathostène(n))

Il y a cependant une erreur...

A vous de corriger le code :