TD — Débogage avec VS Code

Exercice 1 : Premier breakpoint

Créez une fonction additionner(a, b) qui retourne la somme de deux nombres.

  1. Placez un breakpoint au début de la fonction
  2. Lancez le debugger
  3. Observez les variables a et b dans le panneau Local
  4. Avancez pas à pas
  5. Observez la variable resultat

Exercice 2 : Déboguer une boucle

Créez une fonction qui affiche les carrés des nombres de 1 à 5 :

def afficher_carres():
    for i in range(1, 6):
        carre = i ** 2
        print(f"{i}² = {carre}")

afficher_carres()
  1. Placez un breakpoint dans la boucle
  2. Lancez le debugger
  3. Avancez pas à pas (F10)
  4. Observez comment i et carre changent

Exercice 3 : Step Into vs Step Over 

def double(valeur):
    return valeur * 2

def traiter(liste):
    resultats = []
    for element in liste:
        resultats.append(double(element))
    return resultats

print(traiter([1, 2, 3]))
  1. Placez un breakpoint sur la ligne resultats.append(double(element))
  2. Lancez le debugger
  3. Utilisez Step Into (F11) pour entrer dans double(), observez valeur, puis Step Out (Shift+F11) pour revenir
  4. Relancez, mais cette fois utilisez Step Over (F10) sur la même ligne
  5. Expliquez avec vos mots la différence entre les deux comportements

Exercice 4 : Breakpoint conditionnel 

def moyenne_partielle(notes):
    total = 0
    for i, note in enumerate(notes):
        total += note
        moyenne = total / (i + 1)
    return moyenne

notes = [12, 15, 8, 20, 0, 14]
print(moyenne_partielle(notes))

On soupçonne qu’une note à 0 fausse le résultat.

  1. Placez un breakpoint sur la ligne total += note
  2. Clic droit sur le breakpoint → Edit Breakpoint → ajoutez une condition, par exemple note == 0
  3. Lancez le debugger : l’exécution ne doit s’arrêter que lorsque note vaut 0
  4. Observez total et i à ce moment précis

Exercice 5 : Chasse au bug

Le code suivant doit calculer la moyenne des notes supérieures ou égales à 10, mais il renvoie un résultat incorrect :

def moyenne_admis(notes):
    total = 0
    compteur = 0
    for note in notes:
        if note >= 10:
            total += note
        compteur += 1
    return total / compteur

print(moyenne_admis([12, 8, 15, 6, 18]))

Consigne : sans lire le code en détail, utilisez uniquement le debugger pour trouver le bug.

  1. Placez un breakpoint au début de la boucle
  2. Avancez pas à pas et observez total et compteur à chaque itération
  3. Identifiez la ligne responsable du résultat incorrect
  4. Corrigez le bug, puis revérifiez avec le debugger que le résultat est maintenant correct

Exercice 6 : Panier de courses

Le code ci-dessous gère un panier d’achats, mais il contient un bug de portée des variables et n’a aucune trace de son exécution :

panier_total = 0

def ajouter_article(panier, nom, prix, quantite=1):
    ligne = prix * quantite
    panier_total += ligne
    panier.append({"nom": nom, "prix": prix, "quantite": quantite})
    return panier

panier = []
ajouter_article(panier, "Pain", 1.20, 2)
ajouter_article(panier, "Lait", 0.95)
print(panier_total)
  1. Ajoutez un logging.basicConfig en DEBUG et un logger.debug(...) au début de ajouter_article affichant nom, prix et quantite
  2. Lancez le programme : il plante. Placez un breakpoint sur la ligne panier_total += ligne et lancez le debugger pour comprendre l’erreur affichée
  3. Corrigez la fonction en respectant les bonnes pratiques vues en séance 2 (pas de dépendance à une variable globale modifiable — la fonction doit renvoyer le nouveau total plutôt que de modifier panier_total directement)
  4. Ajoutez un logger.info(...) qui affiche le total après chaque ajout, et vérifiez avec le debugger que panier_total évolue correctement à chaque appel

Exercice 7 : Fibonacci récursif 

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(5))
  1. Ajoutez un logger.debug(f"fibonacci({n})") au tout début de la fonction
  2. Exécutez le programme : combien de fois la fonction est-elle appelée pour fibonacci(5) ? Le nombre vous surprend-il ?
  3. Placez un breakpoint sur la ligne return fibonacci(n - 1) + fibonacci(n - 2) et utilisez Step Into (F11) pour descendre dans les appels successifs. Observez la pile d’appels (Call Stack, en haut du panneau Debug) : que représente chaque ligne de cette pile ?
  4. Remontez avec Step Out (Shift+F11) jusqu’à revenir à l’appel initial
  5. En vous appuyant sur ce que vous avez observé, expliquez en 2-3 phrases pourquoi fibonacci(30) serait beaucoup plus long à calculer que fibonacci(5)

Exercice 8 : Gestionnaire de notes

Écrivez un programme qui gère les notes d’un élève.

  1. Écrivez une fonction ajouter_note(notes, valeur, coefficient=1) qui ajoute un tuple (valeur, coefficient) à une liste notes et la renvoie — sans dépendre d’une variable globale
  2. Écrivez une fonction moyenne(notes) qui calcule la moyenne pondérée par les coefficients
  3. Ajoutez du logging : un logger.debug à chaque ajout de note, un logger.info avec la moyenne à chaque appel de moyenne(notes)
  4. Testez avec au moins 4 notes, dont une avec un coefficient différent de 1
  5. Placez un breakpoint dans moyenne() et utilisez le Watch pour surveiller l’expression du calcul de la moyenne pendant que vous avancez pas à pas

Exercice 9 : Somme des chiffres, en récursif

Écrivez une fonction récursive somme_chiffres(n) qui calcule la somme des chiffres d’un entier positif (par exemple somme_chiffres(1234) doit renvoyer 10).

  1. Identifiez vous-même le cas de base avant d’écrire la fonction
  2. Ajoutez un logger.debug affichant n à chaque appel
  3. Testez avec plusieurs valeurs, y compris n à un seul chiffre
  4. Utilisez le debugger (Step Into + Call Stack) pour vérifier que le nombre d’appels correspond bien au nombre de chiffres de n

Exercice 10 (bonus) : Petit projet complet

Si vous avez le temps, combinez tout :

  1. Créez un nouveau venv pour ce mini-projet et activez-le
  2. Installez un paquet de votre choix (par exemple tabulate, pour un affichage en tableau)
  3. Écrivez un petit programme qui reprend l’Exercice 8 (gestionnaire de notes), mais qui affiche le résultat avec le paquet installé plutôt qu’un simple print()
  4. Générez un requirements.txt pour ce projet
  5. Introduisez volontairement un bug, échangez votre code avec un·e camarade, et retrouvez son bug en n’utilisant que le debugger
This site uses Just the Docs, a documentation theme for Jekyll.