On regarde la fonction compte_triangle, qui utilise une boucle pour calculer la somme 1+2+3+...+n:

def compte_triangle(n):
    """calcule le n-ème nombre triangulaire,
en utilisant une boucle"""
    r = 0
    for i in range(1, n+1):
        r = r+i
    return r

Activez le débogueur et évaluez l'expression compte_triangle(15). Vérifiez les choses suivantes :

1. l'argument de la fonction est bien une variable locale et a la valeur attendue,
2. les autres variables locales n'apparaissent que lorsqu'on les définit,
3. le compteur de boucle est bien initialisé à la première valeur du range(...),
4. le compteur de boucle est automatiquement mis à sa valeur suivante lors d'un nouveau passage dans la boucle.

Utilisez le débogueur pour répondre aux questions suivantes :

1. après le dernier passage dans une boucle for i in range(debut, fin, 1), est-ce que la variable i prend la valeur fin ?
2. à la fin d'une boucle, est-ce que la variable locale servant de compteur de boucle disparait ?

1. Désactivez le débogueur et évaluez, dans l'interpréteur, l'expression compte_6(600). Quel est le résultat attendu ? Quel est le résultat constaté ?
2. Réactivez le débogueur (en cochant la case "Source" et décochant la case "Stack") et relancez l'évaluation de l'expression compte_6(600). Utilisez le mode pas à pas :
   • appuyez une fois sur la touche "Step" pour commencer l'appel détaillé à la fonction compte_6,
   • appuyez ensuite sur la touche "Over" pour détailler les calculs successifs sur chaque ligne.
3. Vérifiez ce qui se passe lorsque le résultat du tirage aléatoire est un 6 et, lorsque vous avez trouvé l'erreur, appuyez sur la touche "Go" pour finir l'exécution.
4. Corrigez le bogue.

Activez le débogueur et lancez l'évaluation de l'expression compte_6(35).

1. Vérifiez que le bouton "Step" permet de détailler toutes les étapes de calcul :
   • la première fois, cela permet de rentrer dans la fonction compte_6,
   • lorsqu'une ligne contient un appel à la fonction randint, le débogueur détaille le calcul de la fonction randint, en ouvrant le code de cette fonction dans une nouvelle fenêtre,
2. Vérifiez que le bouton "Out" permet de terminer l'évaluation de la fonction actuelle sans détails : lorsque que le débogueur est en train de détailler un appel à la fonction randint, il passe tout de suite à la ligne suivant l'appel en question, dans la fonction compte_6, (vous pouvez alors refermer la fenêtre contenant le code de la fonction randint)
3. Vérifiez que le bouton "Over" permet de ne pas détailler les appels à une fonction : lorsqu'une ligne contient un appel à la fonction randint, le débogueur passe directement à la ligne suivante,
4. Vérifiez que le bouton "Go" permet de finir le calcul.

Écrivez une fonction fact (pour factorielle) avec un argument entier n pour calculer 1 * 2 * 3 * ... * n.

Comme pour la fonction compte_triangle, vous utiliserez un accumulateur pour calculer le résultat final par étapes successives.

Utilisez le débogueur pour vérifier la valeur de l'accumulateur à chaque tour de boucle. Pour n=5, il doit valoir successivement

• 1
• 2
• 6
• 24
• 120 (c'est le résultat)

Mathématiquement, le nombre e est égal à la somme infinie 1 + 1/1! + 1/2! + 1/3! + 1/4! + ...

On peut donc calculer une approximation du nombre e en calculant 1 + 1/1! + 1/2! + 1/3! + 1/4! + ... + 1/n!.

1. Écrivez une fonction approx_e avec un argument entier n pour calculer une telle approximation.
2. Que pensez vous du calcul approx_e(100) lorsque votre fonction fact affiche des informations ? Commentez la ligne correspondante dans la fonction fact avant de continuer.
3. Ajoutez une ligne avec un print (dans la fonction approx_e) pour afficher les approximations successives, et commentez cette ligne dès que vous avez répondu à la question suivante.
4. Le nombre e est à peu près égal à 2.71828 18284 59045 23536 02874 71352 66249.... Cherchez la plus petite valeur de n pour que votre fonction trouve correctement les 10 premières décimales de e.

Mathématiquement, le nombre π/4 est égal à la somme infinie 1/1 + -1/3 + 1/5 + -1/7 + 1/9 + ...

On peut donc calculer une approximation du nombre π en calculant 4*(1/1 + -1/3 + 1/5 + -1/7 + ... + (-1)ⁿ/(2n+1)).

1. Écrivez une fonction approx_pi avec un argument entier n pour calculer une telle approximation.
2. Ajoutez une ligne avec un print pour afficher les approximations successives, et commentez cette ligne dès que vous avez répondu à la question suivante.
3. Le nombre π est à peu près égal à 3.14159 26535 89793 23846 26433 83279 50288.... Cherchez la plus petite valeur de n pour que votre fonction trouve correctement les 5 premières décimales de π.

Désactivez le débogueur et évaluez l'expression compare_lancers(1000). Quel est le résultat attendu ? Quel est le résultat obtenu ?

Réactivez le débogueur et insérez un point d'arrêt sur la déclaration de resultat2. Lancez l'évaluation de compare_lancers(1000) puis :

1. commencez l'évaluation en mode pas à pas en regardant l'évolution de la variable resultat1.
2. Lorsque que vous avez compris ce qui se passe, appuyez sur la touche "Go", qui permet de « sauter » tous les détails jusqu'au point d'arrêt suivant. Vous pouvez vérifiez que la première boucle s'est effectuée normalement en regardant les valeurs des variables i et resultat.
3. Continuez l'évaluation en mode pas à pas en regardant l'évolution de la variable resultat2. Lorsque que vous avez trouvé le bogue, terminez l'évaluation avec le bouton "Go".

Pourquoi est-il préférable de mettre le point d'arrêt sur la ligne précédent la boucle ? Refaites les mêmes opérations avec le point d'arrêt sur la ligne for j in range(1, n, 0).

Insérez un point d'arrêt sur la ligne contenant le return et lancez l'évaluation de compare_lancers(1000). Arrêtez le débogueur sur la ligne contenant le return et comparez les valeurs des variables resultat1 et resultat2. Quel type de lancers est plus avantageux ?