Outils Pour

Identification

Infoforall

10 - Boucles Bornées


Voyons maintenant comment limiter la taille des codes. Nous avions créé des fonctions trois et quatre qui réalisaient trois fois ou quatre fois la même chose. Il fallait donc taper trois ou quatre fois la même chose. C'est un peu lourd non ?

Evaluation ✎ : questions 19-20

1 - Boucle bornée POUR / FOR

01° Placer le code suivant en mémoire : il permet de tracer un triangle en faisant appel à la fonction trois.

Lancer le code pour visualiser que vous avez bien créé un triangle.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
# Partie Importation import turtle as trt # Partie déclaration des fonctions d'interface def trois(feutre, distance, angle) : '''Fait avancer le crayon de la distance, tourne de l'angle donné. Trois fois.''' feutre.forward(distance) feutre.left(angle) feutre.forward(distance) feutre.left(angle) feutre.forward(distance) feutre.left(angle) def avance_et_tourne(feutre, distance, angle) : '''Fait avancer le crayon de la distance puis tourne de l'angle donné.''' feutre.forward(distance) feutre.left(angle) # Programme principal stylo = trt.Turtle() trois(stylo, 100, 120)

Comme vous voyez, la fonction trois fait trois la même chose. Nous pourrions plutôt utiliser avance_et_tourne pour simplifier un peu le code.

02° Replacer la fonction trois par celle-ci, qui fait appel à avance_et_tourne.

1 2 3 4 5
def trois(feutre, distance, angle) : '''Fait avancer le crayon de la distance, tourne de l'angle donné. Trois fois.''' avance_et_tourne(feutre, distance, angle) avance_et_tourne(feutre, distance, angle) avance_et_tourne(feutre, distance, angle)

On raccourcit un peu le code mais on voit bien que ce n'est pas encore ça. Imaginez si on voulait réaliser une fonction mille qui fait mille fois la même chose :

1 2 3 4 5 6 7 8 9 10 11 12 13 ... 1002
def mille(feutre, distance, angle) : '''Fait avancer le crayon de la distance, tourne de l'angle donné. Trois fois.''' avance_et_tourne(feutre, distance, angle) avance_et_tourne(feutre, distance, angle) avance_et_tourne(feutre, distance, angle) avance_et_tourne(feutre, distance, angle) avance_et_tourne(feutre, distance, angle) avance_et_tourne(feutre, distance, angle) avance_et_tourne(feutre, distance, angle) avance_et_tourne(feutre, distance, angle) avance_et_tourne(feutre, distance, angle) avance_et_tourne(feutre, distance, angle) ... avance_et_tourne(feutre, distance, angle) avance_et_tourne(feutre, distance, angle)

On ne va pas devoir faire mille copier/coller, si ?

Heureusement, il y a un outil qui permet de réaliser les choses en boucle plusieurs fois : la boucle bornée POUR.

En anglais, POUR se traduit par FOR.

03° Replacer la fonction trois par cette version qui utilise une boucle POUR / FOR. Tester pour visualiser qu'on continue à obtenir un triange.

1 2 3 4 5
def trois(feutre, distance, angle) : '''Fait avancer le crayon de la distance, tourne de l'angle donné. Trois fois.''' for x in range(3) : feutre.forward(distance) feutre.left(angle)

Vous avez du comprendre le principe : le mot-clé for et in provoquent ensemble l'apparition d'une boucle : on réalise les lignes 4 et 5 trois fois à cause, visiblement, de la présence de range(3).

04° Que trouve-t-on à la fin de la ligne 3 ? Pourquoi les lignes 4 et 5 sont-elles tabulées à votre avis ?

...CORRECTION...

Comme pour la déclaration de fonctions, on trouve un : pour indiquer qu'on a finit la "déclaration" de la boucle.

Et comme pour les codes dans les fonctions, c'est la tabulation qui permet de faire comprendre à l'interpréteur Python quelles sont les instructions à réaliser en boucle.

Ici, on déclare donc de réaliser en boucle les lignes 4 et 5.

05° Si on utilise ce code, combien de fois va-t-on faire la série d'action "avance et tourne" ? Pour répondre, il faut se demander quelles sont les lignes qui appartiennent à la boucle POUR et quelles sont les lignes qui n'en font pas partie.

1 2 3 4 5 6 7
def exo(feutre, distance, angle) : '''Que fait cette fonction ?''' for x in range(3) : feutre.forward(distance) feutre.left(angle) feutre.forward(distance) feutre.left(angle)

...CORRECTION...

Lignes 4 et 5 appartiennent à la boucle : on réalise donc trois fois l'action "avance et tourne".

Ensuite, on sort de la boucle.

On réalise donc les lignes 6 et 7 et donc "avance et tourne" une fois de plus.

En tout, on réalise donc "avance et tourne" 4 fois.

C'est l'indentation vers la droite qui permet à Python de comprendre les actions que vous voulez réaliser en boucle. Il faut donc placer une tabulation ou 4 espaces de suite pour savoir qu’elles sont les instructions rattachées au bloc. De plus, on remarquera qu’on met un double point [ : ] à la fin de la déclaration de la boucle for. Sans ce symbole, vous déclenchez une erreur. Ce double point permet de dire à l'interpréteur que la déclaration est finie : il peut maintenant exécuter en boucle.

Dans Thonny ou tout autre éditeur spécialisé dans Python, la tabulation est équivalente à 4 espaces. Attention par contre aux éditeurs multi-langages. La tabulation est parfois de 2 ou 3 espaces. Dans ce cas, votre code ne sera pas compris par l'interpréteur Python. Dans ce cas de figure, préférez les 4 espaces ou configurez votre éditeur pour forcer une tabulation équivalente à 4 espaces.

06° Observer le code suivant sans utiliser l'animation : combien de fois va-t-on réaliser la boucle ? Combien de fois va-t-on réaliser l'action d'avancer ? Combien de fois va-t-on réaliser l'action de tourner ?

Tester l'animation suivante pour être certain d'avoir compris le déroulé :

1 2 3 4 5 6 7
def exo(feutre, distance, angle) : '''Que fait cette fonction ?''' feutre.forward(distance) for x in range(5) : feutre.forward(distance) feutre.left(angle) feutre.forward(distance)

CLIQUEZ ICI POUR VOIR LE DEROULEMENT SEQUENTIEL

...CORRECTION...

On voit range(5) : la boucle va être réalisée 5 fois.

On va donc avancer 1 fois avant la boucle, 5 fois avec la boucle et une fois après la boucle : soit 7 fois au total.

On ne tourne que pendant la boucle : soit 5 fois.

Reste un point à voir : qu'est-ce que ce x qui traîne dans la boucle ?

2 - Etude de la variable de boucle

Regardons ce que contient cette variable x lors du déroulement de la boucle.

Commençons par une animation qui vous permettra de comprendre de quelle valeur elle part et sa valeur finale.

07° Tester l'animation suivante.

Que vaut la variable x lors du premier tour de boucle ? Que vaut x lors du dernier tour de boucle ?

Quels sont les valeurs successives prises par x ?

A-t-on bien 5 valeurs différentes ?

1 2 3 4 5 6 7
def exo(feutre, distance, angle) : '''Que fait cette fonction ?''' feutre.forward(distance) for x in range(5) : feutre.forward(distance) feutre.left(angle) feutre.forward(distance)

CLIQUEZ ICI POUR VOIR LE DEROULEMENT SEQUENTIEL

x :

...CORRECTION...

La variable de boucle x varie donc de 0 à 4.

On ne va pas jusqu'à 5 !

Les différentes valeurs sont : 0 1 2 3 4

Par contre, il y a bien 5 valeurs différentes car on commence à 0.

08° Quelles vont être les valeurs prises par la variable de boucle toto ?

Combien de cas différents en tout ?

1
for toto in range(10) :

...CORRECTION...

La variable de boucle toto varie donc de 0 à 9.

On ne va pas jusqu'à 10 !

Les différentes valeurs sont : 0 1 2 3 4 5 6 7 8 9

Par contre, il y a bien 10 valeurs différentes car on commence à 0.

Pour visualiser la valeur de la variable de boucle à l'aide de Turtle, nous pourrions réaliser une boucle où on avance d'une longueur variant avec la variable de boucle, avant de tourner comme avant.

09° Lancer le code ci-dessous.

Voici le résultat :

Questions

  1. Que vaut la longueur du trait lors du premier tour de boucle (lorsque x vaut 0)  ?
  2. Que vaut la longueur du trait lors du deuxième tour de boucle (lorsque x vaut 1)  ?
  3. Quel va être la valeur finale de la variable de boucle x ?
  4. Pourquoi le trait devient-il de plus en plus épais ?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
# Partie Importation import turtle as trt # Partie déclaration des fonctions d'interface def visualiserX(feutre) : '''Permet de visualiser la valeur de la variable de boucle''' feutre.speed(1) for x in range(5) : feutre.pensize(1+x) feutre.forward(50+x*50) feutre.left(90) return x # Programme principal stylo = trt.Turtle() visualiserX(stylo)

...CORRECTION...

Lors du premier tour de boucle, x vaut 0.

Ligne 12 : on voit qu'on va avancer de 50 + 0*50, soit 50.

Lors du deuxième tour de boucle, la variable de boucle x vaut 1.

Ligne 12 : on voit qu'on va avancer de 50 + 1*50, soit 100.

La variable de boucle toto va varier de 0 à 4.

Le trait est de plus en plus gros au fil des étapes à cause de la ligne 11 : plus la variable de boucle augmente, plus on augmente l'épaisseur du trait.

10° On peut également demander d'afficher du texte. Il sera situé juste au dessus de la position du moment du crayon-tortue.

Pour cela, il faut utiliser la méthode write sur le stylo (voir ligne 12).

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
# Partie Importation import turtle as trt # Partie déclaration des fonctions d'interface def visualiserX(feutre) : '''Permet de visualiser la valeur de la variable de boucle''' feutre.speed(1) for x in range(5) : feutre.pensize(1+x) feutre.write(f"x = {x}") feutre.forward(50+x*50) feutre.left(90) return x # Programme principal stylo = trt.Turtle() visualiserX(stylo)

Vous devriez obtenir ceci maintenant (sans les couleurs, je les ai rajouté pour identifier facilement les étapes):

...CORRECTION...

Lors du premier tour de boucle, x vaut 0.

Ligne 12 : on voit qu'on va avancer de 50 + 0*50, soit 50.

Lors du deuxième tour de boucle, la variable de boucle x vaut 1.

Ligne 12 : on voit qu'on va avancer de 50 + 1*50, soit 100.

La variable de boucle toto va varier de 0 à 4.

Le trait est de plus en plus gros au fil des étapes à cause de la ligne 11 : plus la variable de boucle augmente, plus on augmente l'épaisseur du trait.

Comme vous pouvez le voir, on peut donc utiliser une boucle POUR de façon à :

  • soit faire plusieurs fois la même chose
  • soit faire quelque chose qui dépend de la valeur de la variable de boucle

Du coup, nous pouvons maintenant tracer plein de formes. Pas simplement des trianges (trois épapes avec rotation de 120°), des carrés (quatre étapes avec rotation de 90°)...

11° Compléter la fonction polygone pour qu'elle réalise cela :

  • Calculer l'angle en faisant la division entière (enclidienne) de 360 par le nombre de côtés nbr voulus
  • Réaliser une boucle où on fait nbr_cotes fois la même chose :
    • Avancer de la longueur longueur
    • Tourner de l'angle angle

Ici la variable de boucle ne sert qu'à compter les étapes : elle n'a aucune influence sur les actions : on peut faire à chaque fois. Vous pourriez alors la nommer etape plutôt que x pour bien comprendre qu'elle n'a pas de "rôle" particulier.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
# Partie Importation import turtle as trt # Partie déclaration des fonctions d'interface def polygone(feutre, nbr, longueur) : '''Crée un polygone à nbr cotés ayant chacun la longueur voulue.''' pass def avance_et_tourne(feutre, distance, angle) : '''Fait avancer le crayon de la distance puis tourne de l'angle donné.''' feutre.forward(distance) feutre.left(angle) # Programme principal stylo = trt.Turtle() polygone(stylo, 6, 100)

Vous devriez obtenir ceci après l'appel fourni dans le programme :

...CORRECTION...

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
# Partie Importation import turtle as trt # Partie déclaration des fonctions d'interface def polygone(feutre, nbr, longeur) : '''Crée un polygone à nbr cotés ayant chacun la longueur voulue.''' angle = 360 // nbr for etape in range(nbr) : avance_et_tourne(feutre, longeur, angle) def avance_et_tourne(feutre, distance, angle) : '''Fait avancer le crayon de la distance puis tourne de l'angle donné.''' feutre.forward(distance) feutre.left(angle) # Programme principal stylo = trt.Turtle() polygone(stylo, 6, 100)

Du coup, on peut s'amuser et réaliser plein de formes différentes. Imaginons qu'on fasse un appel du type polygone(stylo, 10, 50), il devrait provoquer cela :

Ou tracer un triangle avec un appel du type polygone(stylo, 3, 150), il devrait provoquer cela :

3 - Description plus complète de range

On peut en réalité décider de partir d'une autre valeur que 0.

Description plus complète de range

En réalité, on peut transmettre autre chose que la valeur finale (non incluse) avec range.

On peut en réalité transmettre :

  1. La valeur de départ ( 0 par défaut)
  2. La valeur bornant la fin (non incluse)
  3. Le pas : la variation à appliquer à chaque tour de boucle ( +1 par défaut)

Si on veut créer une variable de boucle prenant les valeurs entières de 0 à 9, on a donc deux façons de l'écrire :

1
for x in range(10) :
1
for x in range(0, 10, 1) :

Dans les deux cas, la variable de boucle x va prendre les valeurs 0 1 2 3 4 5 6 7 8 et finalement 9.

Si on ne transmet qu'une valeur entre les parenthèses, l'interpréteur Python va donc décider de placer par défaut le départ à 0 et incrémenter de 1 à chaque boucle.

Il existe trois possibilités :

  1. On ne fournit que la borne extrême :
  2. 1
    for x in range(10) :

    Ici on obtient l'ensemble de valeurs 0-1-2-3-4-5-6-7-8-9.

  3. On fournit la valeur initiale et la borne finale (non atteinte) :
  4. 1
    for x in range(2, 10) :

    Ici on obtient l'ensemble de valeurs 2-3-4-5-6-7-8-9.

  5. On fournit tout : la valeur initiale, la borne finale (non atteinte) et la valeur du pas :
  6. 1
    for x in range(2, 10, 3) :

    Ici on obtient l'ensemble de valeurs 2-5-8.

    • On part de 2.
    • On rajoute 3 : on obtient 5.
    • On rajoute 3 : on obtient 8.
    • On stoppe puisque 8+3 donne 11 : c'est supérieur ou égal à 10 qui est la valeur extrême, donc on n'y va pas.

Pour changer un peu de Turtle, nous allons créer une chaîne de caractères (string) par concaténation en y plaçant au fur et à mesure les valeurs de la variable de boucle (transformés en string à l'aide de la fonction native str).

1 2 3
chaine = "" for nombre in range(0, 10, 1) : chaine = chaine + str(nombre) + " "

Si on devait retranscrire ce code en commandes manuelles dans la console, cela pourrait donner quelque chose comme cela :

>>> chaine = "" >>> x = 0 >>> chaine = chaine + str(x) + " " >>> chaine '0 ' >>> x = 1 >>> chaine = chaine + str(x) + " " >>> chaine '0 1 ' >>> x = 2 >>> chaine = chaine + str(x) + " " >>> chaine '0 1 2 '

12° Lancer ce code et vérifier dans Thonny ou via la console que la chaine est correcte :

1 2 3
chaine = "" for nombre in range(0, 10, 1) : chaine = chaine + str(nombre) + " "
>>> chaine '0 1 2 3 4 5 6 7 8 9 '

13° Fournir le code permettant d'obtenir une chaîne où on compte de 10 à 40 (inclus), de deux en deux. Attention à la borne finale

On veut donc obtenir ceci :

>>> chaine '10 20 30 40 '

...CORRECTION...

1 2 3
chaine = "" for nombre in range(10, 41, 10) : chaine = chaine + str(nombre) + " "

14° Fournir un code permettant de compter cette fois de 100 à 10 (inclus) en diminuant de cinq à chaque tour de boucle. Attention à la borne finale

On veut donc obtenir ceci :

>>> chaine '100 95 90 85 80 75 70 65 60 55 50 45 40 35 30 25 20 15 10 '

...CORRECTION...

1 2 3
chaine = "" for nombre in range(100, 9, -5) : chaine = chaine + str(nombre) + " "

4 - Mode DEBUG de Thonny

Si vous n'utilisez pas Thonny, vous pouvez passer à la partie suivante.

Le logiciel Thonny possède une fonctionnalité qu'il va falloir apprendre à utiliser : le mode PAS A PAS qui permet d'exécuter du code ligne par ligne. Cela permet de comprendre certains bugs car on peut suivre l'évolution des variables et voir le déroulement du programme.

15° Placer ce code dans Thonny SANS LE LANCER. Ouvrir l'onglet VIEW-VARIABLES pour observer les variables.

1 2 3
chaine = "" for nombre in range(2, 10, 2) : chaine = chaine + str(nombre) + " "

Pour lancer le mode DEBUG / PAS A PAS, il faut appyer sur le bouton "BUG" situé à DROITE de la flèche verte permettant juste de lancer le script.

Appuyer sur ce bouton et suivre les indications ci-dessous.

Vous devriez obtenir la première ligne en surbrillance : Thonny attend que vous validiez cette ligne. Pour l'instant, il n'a rien fait.

Pour lui demander d'exécuter cette ligne, il faut appuyer sur le bouton qui se trouve à droite du BUG et qui se nomme STEP OVER :

15-2° Appuyer sur le bouton STEP OVER.

On constate alors bien l'apparition d'une variable chaine ne contenant rien.

On voit que Thonny attend patiemment qu'on lui donne l'autorisation d'exécuter ce bloc en surbrillance.

Or, nous voulons voir comment s'exécute ce bloc, pas l'exécuter d'un coup. Pour cela, il va encore falloir appuyer sur un autre bouton :le bouton STEP INTO, qui permet de rentrer dans l'évaluation du bloc.

15-3° Appuyer sur le bouton STEP INTO.

On rentre bien dans le bloc et Thonny vous demande s'il peut commencer à évaluer l'ensemble des valeurs qu'il va devoir générer une à une :

15-4° Appuyer sur le bouton STEP OVER pour autoriser Thonny à exécuter cette évaluation (sans rentrer dans le détail de l'évaluation)

On obtient alors bien la première valeur de la suite, à savoir 2.

15-5° Appuyer encore sur le bouton STEP OVER pour autoriser Thonny à exécuter cette évaluation (sans rentrer dans le détail de l'évaluation)

On voit à droite qu'il a créé une variable x valant 2.

Il attend donc de pouvoir exécuter la ligne en surbrillance.

15-6° Valider chacune des instructions pour voir la création progressive de la chaîne de caractères.

Voici le résultat :

Lorsqu'on validera cette ligne, Python va donc concaténer '2 ' + '4' + ' ' qui sera évaluée à '2 4 ' et placé à nouveau dans la variable chaine. Résultat en image ci-dessous :

Lorsqu'on validera cette ligne, Python va donc concaténer '2 4 ' + '6' + ' ' qui sera évaluée à '2 4 6 ' et placé à nouveau dans la variable chaine. Résultat en image ci-dessous :

Nous arrivons ici à la dernière instruction puisque la variable de boucle ne pourra plus augmenter de 2. La chaîne de caractères va donc subir une dernière concaténation avant d'arriver à son état final.

Lorsqu'on validera cette ligne, Python va donc concaténer '2 4 6 ' + '8' + ' ' qui sera évaluée à '2 4 6 8 ' et placé à nouveau dans la variable chaine. Résultat en image ci-dessous :

Nous reviendrons régulièrement sur ce mode DEBUG. Dès qu'on change vous semble étrange, pensez à l'utiliser : cela vous permet de voir ce que Python fait VRAIMENT avec votre code.

5 - DEBUG avec Pythontutor

Vous pouvez également faire la même chose avec le site Pythontutor bien entendu/

16° Placer ce code sur le site Pythontutor. Il faut

  1. cliquer sur Start visualizing your code now,
  2. placer votre code.
  3. cliquer sur Visualize Execution
  4. avancer instruction par instruction avec Next
1 2 3
chaine = "" for nombre in range(2, 10, 2) : chaine = chaine + str(nombre) + " "

Au final, vous arriverez bien entendu au même point qu'avec Thonny, à savoir ceci :

6 - Un autre outil pratique : l’affectation multiple

Les deux dernières parties n'ont rien à voir avec les boucles mais c'est bien pratique à connaitre.

Imaginons qu’on désire créer 6 variables a, b, c, d, e et f contenant 3,78. Il faudrait créer 6 lignes de code. On peut faire plus simple avec la ligne suivante :

a = b = c = d = e = f = 3.78

7 - La permutation

Une chose courante en informatique : la permutation.

Si vous voulez inverser les pièces qui se trouvent dans votre poche droite et dans votre poche gauche, en tant qu'humain, c'est facile puisque vous avez deux mains.

L'ordinateur lui ne peut faire qu'une chose à la fois. Il va donc devoir utiliser un stockage temporaire d'informations pour parvenir à inverser le contenu de deux variables.

Si vous voulez mettre l’argent argentGauche dans argentDroite et inversement, il faut créer une troisième variable temporaire car l'ordinateur n'a qu'une "main". On pourrait la nommer videPoche.

Déroulé étape par étape :

videPoche = argentDroite

Cela permet de créer une variable videPoche et y placer le contenu de la variable argentDroite.

argentDroite = argentGauche

Mettre le contenu de la variable argentGauche dans la variable argentDroite.

  • Mettre le contenu de la variable videPoche (qui contient l’argent initialement à droite) dans argentGauche.
  • argentGauche = videPoche

    17° Permuter les deux variables à l'aide de ces commandes dans la console. A SAVOIR REFAIRE.

    >>> g = 5 >>> d = 55 >>> temp = d >>> d = g >>> g = temp >>> g 55 >>> d 5

    Bref, c’est long et plutôt compliqué puisqu'on a besoin de 3 conteneurs au total.

    Python intègre un outil de permutation automatique. Il suffit de taper une seule ligne d'instruction. Il suffit de noter :

    a,b = b,a

    18° Tentez de permuter les poches droite et gauche à l’aide de la commande ci-dessus.

    >>> g = 5 >>> d = 55 >>> g,d = d,g >>> g 55 >>> d 5

    En réalité, cette permutation magique d'une ligne va simplement automatiquement créer la permutation à 3 conteneurs. Mais vous n'aurez pas en vous en occuper.

    Permutation en NSI

    Si vous êtes en NSI, nous allons utiliser uniquement la méthode des 3 variables. Pourquoi ?

    Simplement car cet outil de permutation est un spécificité de Python. Beaucoup d'autres langages ne l'implémentent pas.

    Nous écrirons donc plutôt ceci (même si on peut faire plus simple avec une permutation) :

    a = 5 b = 10 temporaire = b b = a a = temporaire

    8 - Exos

    Deux petits exos pour la route.

    ✎ 19° Expliquer clairement pourquoi le code suivant crée exactement 16 cercles. Vous expliquerez notamment le rôle de setheading présent en ligne 8. Faites une recherche sur le Web si nécessaie.

    Voici le code utilisé pour réaliser ce dessin.

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
    import turtle as trt def cercle(rayon, angle) : '''Fonction basique qui trace un cercle ayant le rayon proposé. Sans retour''' feutre = trt.Turtle() feutre.color('red') feutre.pensize(5) feutre.setheading(angle) feutre.circle(rayon, 360) def cercles(rmin, rmax, pas, angle) : '''Fonction qui trace plusieurs cercles...''' for rayon in range(rmin,rmax, pas) : cercle(rayon, angle) def dessin() : '''Fonction qui trace la figure complexe''' for angle in range(0,360,90) : cercles(50,150,25, angle) dessin()

    ✎ 20° On veut réaliser une fonction somme qui renvoie la somme des n premiers entiers.

    Par exemple, somme(4) doit renvoyer la somme de 0+1+2+3+4, soit 10.

    Nous allons donc faire cela en boucle.

    On crée une variable de stockage qu'on nommera s.

    A chaque étape, on va donc rajouter la valeur de la valeur de boucle à la variable s et remettre le résultat dans la variable s.

    On aura ainsi :

    Initialisation : s = 0

    Premier tour de boucle : s = s + 0, soit s = 0

    Deuxième tour de boucle : s = s + 1, soit s = 1

    Troisième tour de boucle : s = s + 2, soit s = 3

    Quatrième tour de boucle : s = s + 3, soit s = 6

    ...

    Compléter la fonction pour qu'elle fonctionne correctement :

    1 2 3 4 5 6
    def somme(n) : '''Renvoie la somme des entiers de 1 jusqu'à n INCLUS''' s = XXX for x in range(XXX, XXX, XXX) : s = XXX return XXX
    >>> somme(3) 6 >>> somme(4) 10 >>> somme(5) 15 >>> somme(6) 21

    Tant que la fonction ne renvoie pas cela, c'est que votre fonction ne fonctionne pas !

    9 - FAQ

    J'ai vu un code bizarre une variable... bizarre aussi. C'est quoi ?

    Le code ressemble peut-être à ceci, avec une variable de boucle limité à un underscore :

    1 2 3 4 5
    def polygone(feutre, nbr, longeur) : '''Crée un polygone à nbr cotés ayant chacun la longueur voulue.''' angle = 360 // nbr for _ in range(nbr) : avance_et_tourne(feutre, longeur, angle)

    C'est juste une notation qui permet en gros de dire : "La variable de boucle n'a aucune importante : on fait x fois la même chose"

    Remplacez ce nom de variable de boucle par choucroute et ca marchera toujours aussi bien. Du coup, pourquoi pas juste un underscore ?

    Voilà pour les boucles bornées qui permettent donc de faire plusieurs fois la même chose, ou presque puisqu'on peut utiliser la variable de boucles qui possède une valeur différente à chaque tour de boucle.

    Nous pourrons ainsi laisser les balles se déplacer TANT QUE la condition choisie reste VRAI.

    Et stopper uniquement lorsqu'elle sera évaluée à FAUX.

    Activité publiée le 01 11 2020
    Dernière modification : 01 11 2020
    Auteur : ows. h.