6 - Boucle non bornée

⏪

⏬

⏩

1 - cours

2 - Exos

3 - FAQ

Voyons aujourd'hui les boucles non bornées : il agit d'agir en boucle tant qu'une condition est évaluée à True.

Les boucles non bornées avec Scratch

Nous allons voir comment faire comprendre cela à l'interpréteur Python.

IDE Python proposé : Thonny

Documents de cours : pdf ou odt.

MODE COURS (cacher les questions)

1 - Découverte du cours, pas à pas

⇩ ⇧ ⤊

✔ Intro A (Mise en place)° Réaliser les actions suivantes :

Ouvrir Thonny. Réduire la fenêtre de Thonny et de votre navigateur Web pour que chaque fenêtre occupe la moitié de l'écran.
Ouvrir votre dossier/répertoire personnel. Créer dans le dossier SNT un nouveau sous-dossier qu'on nommera python06.
Sur Windows : vérifier via le menu affichage de votre explorateur de dossiers que vous avez bien coché la case "Afficher les extensions".

✔ Intro B (rappel)° On peut demander à Python de tirer des nombres au hasard avec la fonction randint(), comme "random integer". Cette fonction fait partie du module nommée random.

valeur = random(1, 6) va générer un nombre aléatoire allant de 1 (compris) à 6 (compris).

Utiliser plusieurs fois ce programme qui tire un nombre au hasard et affiche le résultat obtenu.

from random import randint
 
valeur = randint(1, 6)
print(valeur)

Questions

Dans quelle variable stocke-on le nombre aléatoire ? Donner son nom et la ligne sur laquelle l'affectation est faite.

from random import randint
 
valeur = randint(1, 6)
print(valeur)

Sur quelle ligne demande-t-on d'afficher ce nombre ?

from random import randint
 
valeur = randint(1, 6)
print(valeur)

✔ Intro C° Nous allons maintenant utiliser la boucle TANT QUE : nous voudrions tirer un dé et afficher le résultat, tant que le dé tiré ne vaut pas 6. Comme pour démarrer au jeu des petits chevaux.

Le principe du while :

On évalue l'expression booléenne qui se trouve le while.
Si elle est vraie, on réalise un tour de boucle et on revient sur la ligne du while.
Si elle est fausse, on sort en cherchant la prochaine instruction non indentée de 4 espaces.

from random import randint
 
valeur = randint(1, 6)
print(valeur)
 
while valeur != 6:
    valeur = randint(1, 6)
    print(valeur)
 
print("Bravo, vous avez tiré un 6 !")

Questions-réponses

Utiliser plusieurs fois ce programme pour vérifier qu'on ne peut pas prévoir à l'avance combien de fois il va falloir tirer le dé.
Donner les lignes exécutées si on tire 4 au départ puis 2 puis 6.

L01 - L03(valeur=4) - L04

L06(True car 4 est différent de 6) - L07(valeur=2 maintenant) - L08

L06(True car 2 est différent de 6) - L07(valeur=6 maintenant) - L08

L06(False car 6 n'est pas différent de 6) - L10

✔ Intro D° On remarque que les lignes 3-4 sont les mêmes que les lignes 7-8. Pour éviter ce copier-coller, on utilise la stratégie suivante : on fournit avant la boucle une fausse valeur qui ne sert qu'à valider la condition de façon à rentrer au moins une fois dans la boucle.

from random import randint
 
valeur = 0
 
 
while valeur != 6:
    valeur = randint(1, 6)
    print(valeur)
 
print("Bravo, vous avez tiré un 6 !")

Questions-réponses

Que vaut valeur avant la boucle ? Ligne 3, on voit 0.
Cette fausse valeur permet-elle de rentrer dans la boucle ? Oui, puisqu'on voit ligne 6 qu'il faut fournir une valeur différente de 6.

✔ Intro E° Utiliser l'animation permettant de voir les lignes suivies par l'interpréteur et vérifier qu'il correspond à ce mécanisme :

SI la condition de poursuite est VRAIE, réalise un tour de BOUCLE et revient au début de la boucle.

SINON, passe à la suite.

x = 0
 
while x < 40:
    print(x)
    x = x + 10
 
print("Fin du TANT QUE")

CLIQUEZ ICI POUR VOIR LE DEROULEMENT SEQUENTIEL

x :

x < 40 ? :

✔ Intro F° L'un des risques majeurs des boucles TANT QUE est la boucle infinie : la condition sera toujours VRAIE. Bilan : l'ordinateur ne sortira jamais de l'exécution de la boucle et le programme ne s'arrêtera jamais : il boucle à l'infini.

Question-réponse

Quelle est la "petite" erreur de programmation qui cause une boucle infinie sur ce programme ?

x = 0
 
while x < 31:
    print(x)
x = x + 10
 
print("FIN DU TANT QUE")

Il y a une mauvaise indentation de la ligne 5 : l'incrémentation de la variable x n'est plus à l'intérieur de la boucle et donc x n'est jamais modifiée...

Si vous êtes en TP, passez directement à la partie 2 suivante, sans lire les bilans ci-dessous : ils seront analysés oralement à la fin du TP.

1.1 Boucle TANT QUE

Voir

A - Principe

Le mot-clé while permet de réaliser une boucle sous condition. Le principe est le suivant :

Lorsqu’on tombe sur le début de la boucle, on évalue l’expression de poursuite.

Si elle est vraie, on réalise un tour de boucle et on revient au début.

Si elle est fausse, on arrête la boucle, en cherchant la première instruction hors boucle (non indentée).

Comme pour for et if, c'est l'indentation qui renseigne sur le bloc à réaliser :


L1  début du programme
L2
L3  while condition de poursuite:
L4      instruction A
L5      instruction B
L6      instruction C
L7
L8  suite du programme

On a donc deux possibilités d'exécution :

si poursuite est True en L3 : L3(True) - L4-L5-L6 puis L3 à nouveau.
si poursuite est False en L3 : L3(True) - L8.

B - Un classique : valeur de seuil

Le programme suivant permet de répondre à ce problème :

on considère une épargne initiale de 10 euros.
On double l'épargne tous les mois.
Tant que l'épargne est inférieure à 500 euros, on laisse la somme sur le compte.
Au bout de combien de mois va-t-on atteindre 5000 euros ou plus ?

epargne = 10
nb_mois = 0
 
while epargne < 500:
    epargne = epargne * 2
    nb_mois = nb_mois + 1
 
print(epargne)
print(nb_mois)

Si on lance le programme :


>>> %Run boucleTQ.py
5120
9

On voit qu'on atteint 640 euros au bout de 6 mois. Un compte bancaire qui rapporte 100% tous les mois, c'est rentable mais malheureusement totalement imaginaire.

Traduction et déroulé

L1 (epargne=10) - L2 (nb_mois=0)
L4 (condition 10<500 vrai) - L5 (epargne=10*2=20) - L6 (nb_mois=0+1=1)
L4 (condition 20<500 vrai) - L5 (epargne=20*2=40) - L6 (nb_mois=1+1=2)
L4 (condition 20<500 vrai) - L5 (epargne=40*2=80) - L6 (nb_mois=2+1=3)
L4 (condition 20<500 vrai) - L5 (epargne=160) - L6 (nb_mois=3+1=4)
L4 (condition 20<500 vrai) - L5 (epargne=320) - L6 (nb_mois=4+1=5)
L4 (condition 20<500 vrai) - L5 (epargne=640) - L6 (nb_mois=5+1=6)
L4 (condition 640<500 faux) : FIN DU TANT QUE.
L8-L9 : affichage des variables

1.2 Boucle bornée ou boucle non bornée

Voir

Si on connait à l'avance le nombre de fois où on va devoir agir, on peut utiliser une boucle POUR.

La boucle POUR est une boucle bornée.

Si on ne peut pas savoir à l'avance le nombre de fois où on va devoir agir, on utilise une boucle TANT QUE.
C'est la condition de poursuite fournie qui va permettre de faire le choix de continuer ou pas.
Si l'action peut potentiellement se dérouler à l'infini, il faut utiliser une boucle TANT QUE.

C'est pour cela que la boucle TANT est une boucle non bornée.

1.3 Première évaluation de la condition

Voir

Les variables nécessaires à l'évaluation du TANT QUE doivent toutes être définies avant la ligne du TANT QUE.

Si la condition est basée sur une variable qui est calculée dans le bloc de la boucle elle-même, comment faire ? Initialiser cette variable avec une "fausse première valeur" de façon à rentrer dans la boucle au départ.

Exemple : en ligne 3, on place 0 dans total, ce qui permet de valider la condition de poursuite : le total est inférieur à 16. On rentre ainsi une première fois dans la boucle.

from random import randint
 
total = 0
 
while total < 16:
    total = randint(1, 6) + randint(1, 6) + randint(1, 6)
    print(total)
 
print(f"La valeur retenue avec les 3 trois dés est {total}")

2 - Exercices

⇩ ⇧ ⤊

⚙ 01° On veut faire avancer la tortue avec une boucle : tant que la tortue n'a pas dépassé x = 300 pixels, on tire un nombre aléatoire entre 0 et 3 et on la fait avancer de ce nombre.

Remarque : on peut récupérer la position x de la tortue avec la fonction xcor(), et la position y de la tortue avec ycor().

La fonction forward() permet de faire avancer la tortue.

Compléter les ... dans le programme pour qu'il fonctionne comme on le veut. Pensez à lire le début de l'énoncé pour savoir comment compléter.

from turtle import *
from random import randint
 
# On trace la igne d'arrivée
penup()
goto(300, 200)
pendown()
goto(300, -200)
penup()
goto(0,0)
pendown()
 
# On définie couleur et taille de tortue
pencolor("blue")
pensize(5)
speed(1)
 
# On commence la course
while xcor() < ...:
    distance = randint(..., ...)
    print(distance)
    forward(...)
 
print("Course terminée !")

Correction ?

...CORRECTION...

from turtle import *
from random import randint
 
# On trace la igne d'arrivée
penup()
goto(300, 200)
pendown()
goto(300, -200)
penup()
goto(0,0)
pendown()
 
# On définie couleur et taille de tortue
pencolor("blue")
pensize(5)
speed(1)
 
# On commence la course
while xcor() < 300:
    distance = randint(0, 3)
    print(distance)
    forward(distance)
 
print("Course terminée !")

⚙ 02° Dans ce nouveau programme, on fait tourner la tortue d'un angle aléatoire en plus de la faire avancer.

Visualiser bien, en ligne 22 qu'on demande de tourner d'un angle compris entre -5° et +5° avant d'avancer.
Lancer le programme.
Modifier l'angle de rotation aléatoire pour passe à -20° jusqu'à +20°.
Est-on certain d'atteindre la ligne d'arrivée ? Aurait-on pu faire la même chose avec une boucle for :

from turtle import *
from random import randint
 
# On trace la igne d'arrivée
penup()
goto(300, 200)
pendown()
goto(300, -200)
penup()
goto(0,0)
pendown()
 
# On définie couleur et taille de tortue
pencolor("blue")
pensize(5)
speed(1)
 
# On commence la course
while xcor() < 300:
    distance = randint(0, 3)
    print(distance)
    left( randint(-5, 5) )
    forward(distance)
 
print("Course terminée !")

Correction ?

...CORRECTION...

Non, il est possible que la tortue dévie totalement sa course vers la gauche et qu'elle ne revienne jamais jusqu'à la ligne d'arrivée. Nous ne pouvons bien entendu pas réaliser la même chose avec une boucle for de python qui, elle, s'arrête nécessairement à un moment.

⚙ 03° Tant que deux dés ne forment pas une paire (2 dés identiques), on veut relancer les deux dés. On donne, lignes 2 et 3, deux fausses premières valeurs aux variables de1 de2.

Remarque : on peut fournir plusieurs choses à print() sous condition de les séparer par des virgules.

from random import randint
 
de1 = 0
de2 = 1
 
while ... != ...:
     
    de1 = randint(1, 6)
    ... = randint(1, 6)
    print(de1, " et ", de2)
 
print("Vous avez obtenu une paire de ", ...)

Questions

Compléter les ... dans le programme pour qu'il fonctionne correctement.
Les deux fausses valeurs stockées en lignes 3 et 4 permettent-elles de faire au moins un tour de boucle de cette boucle while ?
Donner mentalement les lignes exécutées en supposant qu’on ai besoin de faire trois tours de boucle avant de tirer une paire.

Correction ?

...CORRECTION...

Le programme :

from random import randint
 
de1 = 0
de2 = 1
 
while de1 != de2:
    nombre = nombre + 1
    de1 = randint(1, 6)
    de2 = randint(1, 6)
    print(de1, " et ", de2)
 
print("Vous avez obtenu une paire de ", de1)

On rentrera bien au moins une fois dans la boucle car les deux dés contiennent bien des valeurs différentes.
Voici la succession des lignes :

01 - 03(de1=1) - 04(de2=0)

06 (True) - 07 - 08 - 09 - 10

06 (False car de1 et de2 sont identiques)

12 - Fin

⚙ 04° Revenons à notre jeu de hasard où il faut tenter de deviner un nombre mystère compris entre 1 et 10.

from random import randint
 
mystere = randint(..., ...)
reponse = 0
 
while ... != ...:
    print("Votre réponse ? ")
    reponse = ...
 
print("Bravo")

Questions

Compléter les ... pour que le jeu fonctionne correctement : tant que l'utilisateur ne trouve pas, on lui demande de recommencer. Si vous ne trouvez pas, vous pouvez répondre aux questions ci-dessous qui devraient vous aiguiller.
Dans quelle variable sera stockée la bonne valeur à trouver ?
Pourquoi la fausse réponse 0 de la ligne 4 va-t-elle permettre de rentrer une première fois dans la boucle ?
Puisqu'on va lui demander de répondre par un nombre, doit-on utiliser input() ou int(input()) pour interroger l'utilisateur ?
Lancer et tester le jeu.

Correction ?

...CORRECTION...

Compléter les ... pour que le jeu fonctionne correctement : tant que l'utilisateur ne trouve pas, on lui demande de recommencer.

from random import randint
 
mystere = randint(1, 10)
reponse = 0
 
while mystere != reponse:
    print("Votre réponse ? ")
    reponse = int(input())
 
print("Bravo")

C'est la variable mystere qui contient la valeur à trouver.
On peut mettre n'importe quoi, sauf un nombre entre 1 et 10. 0 fonctionne, -50 aussi, 28 aussi ect..
int(input()) puisqu'il faudra convertir le string récupéré du clavier en entier.

✎ 05° Finir Py-rate maintenant que vous avez toutes les bases : utilisation de fonctions, for, if, while.

Revenez ensuite dans cette activité pour terminer les dernières questions.

⚙ 06° Transformons le jeu de la question 04 pour en faire un jeu de plus et du moins : si la réponse n'est pas bonne, il faut aider le joueur en lui indiquant s'il doit donner un résultat plus grand ou plus petit la prochaine fois.

from random import randint
 
mystere = randint(1, 10)
reponse = 0
 
while mystere != reponse:
    print("Votre réponse ? ")
    reponse = int(input())
    if ... > ...:
        print("Le nombre à trouver est plus grand que ", reponse)
    elif ... < ...:
        print("Le nombre à trouver est plus petit que ", reponse)
 
print("Bravo")

Correction ?

...CORRECTION...

from random import randint
 
mystere = randint(1, 10)
reponse = 0
 
while mystere != reponse:
    print("Votre réponse ? ")
    reponse = int(input())
    if mystere > reponse:
        print("Le nombre à trouver est plus grand que ", reponse)
    elif mystere < reponse:
        print("Le nombre à trouver est plus petit que ", reponse)
 
print("Bravo")

⚙ 07° Voyons comment créer une animation qui ne s'arrête jamais : il suffit d'écrire derrière le while quelque chose qui va toujours rester vraie, comme... True.

from turtle import *
from random import randint
 
# Création de la particule
pencolor("blue")
pensize(5)
speed(9)
dx = randint(1, 5)
dy = randint(1, 5)
 
while True:
 
    # déplacement de la particule 
    x = xcor() + dx
    y = ycor() + dy
    goto(x, y)
 
    # Gestion collision plafond et sol
    if y > 200:
        dy = - dy  # Change direction en y
    elif y < -200:
        dy = - dy  # Change direction en y
 
    # Gestion collision droite et gauche
    if x > 200:
        dx = - dx  # Change direction en x
    elif x < -200:
        dx = - dx  # Change direction en x

Le principe est assez facile même si le code a l'air impressionnant :

on tire en lignes 8-9 les déplacements qui permettront d'incrémenter x et y à chaque tour de boucle : si on tire 4 et 2, on veut que la tortue gagne 4 en x et 2 en y à chaque fois qu'on fait un tour de boucle.
En ligne 11, on lance une boucle infinie
En lignes 14-15-16, on calcule les nouvelles coordonnées et on y déplace la particule avec goto()
Sur les lignes 18-28, on gère les rebonds si on atteint une limite de 200 pixels.

Questions

Lancer plusieurs fois l'animation pour voir le résultat. Si vous ne l'arrêtez pas manuellement, l'animation ne va jamais s'arrêter à cause de la ligne 11.
Si dy vaut 4, la particule va-t-elle monter ou descendre à l'écran ?
Lire les lignes 19-20 : si y atteint 200 et que dy vaut 4 par exemple, quelle sera la nouvelle valeur de dy ?
La particule va-t-elle maintenant monter ou descendre ?

Correction ?

...CORRECTION...

Lancer plusieurs fois l'animation pour voir le résultat. Si vous ne l'arrêtez pas manuellement, l'animation ne va jamais s'arrêter à cause de la ligne 11.
Si dy vaut 4, la particule va-t-elle monter ou descendre à l'écran ?

La particule va monter, puisque l'axe y des ordonnées est orienté vers le haut dans Turtle.

Lire les lignes 19-20 : si y atteint 200 et que dy vaut 4 par exemple, quelle sera la nouvelle valeur de dy ?

Si y devient trop grand, on change le signe de la variation en y : si la variation valait 4, elle vaut maintenant -4. De la même façon, si la variation valait -4, elle vaut maintenant -(-4), soit 4.

La particule va-t-elle maintenant monter ou descendre ?

Puisqu'on change le signe de la variation, on change bien entendu la direction : si elle montait, elle va descendre et si elle descendait, elle va monter.

⚙ 08° Voici un programme Turtle qui génère maintenant plusieurs tortues et les déplace aléatoirement.

Attention, on utilise une syntaxe un peu différente :

Ligne 01 : on importe juste le nom turtle (alors qu'avant on importait tout avec l'utilisation du symbole * qui veut dire "tout")
Ligne 16 : on crée un cheval virtuel en utilisant la syntaxe turtle.Turtle().
Lorsqu'on veut agir sur un cheval en particulier, il faut noter le nom de la variable qui lui correspond, un point et la fonction qu'on veut faire agir :

cheval1.pencolor("blue")

Cela veut dire : la couleur d'écriture du cheval 1 est maintenant le bleu.

import turtle
from random import randint
 
# Création du cadre
crayon = turtle.Turtle()
crayon.penup()
crayon.goto(-250, -250)
crayon.pendown()
for _ in range(4):
    crayon.forward(500)
    crayon.left(90)
crayon.hideturtle()
 
 
# Création du premier cheval
cheval1 = turtle.Turtle()
cheval1.pencolor("blue")
cheval1.pensize(5)
cheval1.speed(9)
cheval1.penup()
cheval1.goto(-200, 20)
cheval1.pendown()
 
# Création du deuxième cheval
cheval2 = turtle.Turtle()
cheval2.pencolor("red")
cheval2.pensize(5)
cheval2.speed(9)
cheval2.penup()
cheval2.goto(-200, 0)
cheval2.pendown()
 
# Création du troisième cheval
...
...
...
...
...
...
...
 
# tous les chevaux sont en -200 au départ
maximum = -200
 
# On commence la course
while maximum < 250:
 
    # déplacement du cheval 1
    cheval1.forward( randint(0, 6) )  # on le déplace
    x1 = cheval1.xcor()               # on récupère son abscisse
    if x1 > maximum:                  # si son abscisse est plus grande que le maximum actuel
        maximum = x1                  # cette abscisse devien le nouveau maximum temporaire
 
    # déplacement du cheval 2
    cheval2.forward( randint(0, 6) )
    x2 = cheval2.xcor()
    if x2 > maximum:
        maximum = x2
 
    # déplacement du cheval 3
    ...
    ...
    ...
    ...
 
 
# Course terminée
if maximum == x1:
    cheval1.write("Le cheval 1 gagne !")
elif maximum == x2:
    cheval2.write("Le cheval 2 gagne !")
else:
    ...

Questions

Utiiser ce programme qui stoppe bien lorsqu'un cheval dépasse la ligne d'arrivée.
Compléter les ... pour rajouter et déplacer un troisième cheval.

Correction ?

...CORRECTION...

import turtle
from random import randint
 
# Création du cadre
crayon = turtle.Turtle()
crayon.penup()
crayon.goto(-250, -250)
crayon.pendown()
for _ in range(4):
    crayon.forward(500)
    crayon.left(90)
crayon.hideturtle()
 
 
# Création du premier cheval
cheval1 = turtle.Turtle()
cheval1.pencolor("blue")
cheval1.pensize(5)
cheval1.speed(9)
cheval1.penup()
cheval1.goto(-200, 20)
cheval1.pendown()
 
# Création du deuxième cheval
cheval2 = turtle.Turtle()
cheval2.pencolor("red")
cheval2.pensize(5)
cheval2.speed(9)
cheval2.penup()
cheval2.goto(-200, 0)
cheval2.pendown()
 
# Création du troisième cheval
cheval3 = turtle.Turtle()
cheval3.pencolor("green")
cheval3.pensize(5)
cheval3.speed(9)
cheval3.penup()
cheval3.goto(-200, -20)
cheval3.pendown()
 
# tous les chevaux sont en -200 au départ
maximum = -200
 
# On commence la course
while maximum < 250:
 
    # déplacement du cheval 1
    cheval1.forward( randint(0, 6) )  # on le déplace
    x1 = cheval1.xcor()               # on récupère son abscisse
    if x1 > maximum:                  # si son abscisse est plus grande que le maximum actuel
        maximum = x1                  # cette abscisse devien le nouveau maximum temporaire
 
    # déplacement du cheval 2
    cheval2.forward( randint(0, 6) )
    x2 = cheval2.xcor()
    if x2 > maximum:
        maximum = x2
 
    # déplacement du cheval 3
    cheval3.forward( randint(0, 6) )
    x3 = cheval3.xcor()
    if x3 > maximum:
        maximum = x3
 
 
# Course terminée
if maximum == x1:
    cheval1.write("Le cheval 1 gagne !")
elif maximum == x2:
    cheval2.write("Le cheval 2 gagne !")
else:
    cheval3.write("Le cheval 3 gagne !")

⚙ 09° Nouveau programme : déplacement aléatoire de 3 particules.

On veut les laisser se déplacer tant qu'aucune des particules ne sort d'un carré de 400 pixels sur 400 pixels : c'est à dire une zone où l'abscisse est dans l'intervalle [-200;+200] et où l'ordonnée est également dans [-200;+200].

Quelques éléments qu'il faudra utiliser :

On peut récupérer les valeurs sur l'abscisse et l'ordonnée à l'aide de xcor() et ycor().
On peut récupérer la plus grande valeur parmi une série de valeurs à l'aide de la fonction max().

Question

Compléter les ... de ce programme pour qu'il parvienne à faire se déplacer correctement les 3 particules tant qu'elles restent dans le cadre (c'est à dire que toutes les abscisses et ordonnées sont bien dans l'intervalle [-200;200]).

import turtle
from random import randint
 
# Création du cadre
crayon = turtle.Turtle()
crayon.penup()
crayon.goto(-200, -200)
crayon.pendown()
for _ in range(4):
    crayon.forward(400)
    crayon.left(90)
crayon.hideturtle()
 
 
# Création de la première particule
particule1 = turtle.Turtle()
particule1.pencolor("blue")
particule1.pensize(5)
particule1.speed(9)
particule1.left( randint(-0, 359) )
 
# Création de la deuxième particule
particule2 = turtle.Turtle()
particule2.pencolor("red")
particule2.pensize(5)
particule2.speed(9)
particule2.left( randint(-0, 359) )
 
# Création de la troisième particule
particule3 = turtle.Turtle()
...
...
...
...
 
# Fausses valeurs initiales pour démarrer le while
maximum = 0
 
# On commence la course
while maximum < ...:
 
    # déplacement de la particule 1
    particule1.left( randint(-20, 20) )
    particule1.forward(5)
 
    # déplacement de la particule 2
    particule2.left( randint(-20, 20) )
    particule2.forward(5) 
 
    # déplacement de la particule 3
    ...
    ...
 
    # recherche des coordonnées extrêmes 
    x1 = particule1.xcor()
    y1 = particule1.ycor()
    x2 = particule2.xcor()
    y2 = particule2.ycor()
    ...
    ...
    maximum = max(x1, -x1, y1, -y1, x2, -x2, y2, -y1, ...)
 
print("Course aléatoire terminée !")

Correction ?

...CORRECTION...

import turtle
from random import randint
 
# Création du cadre
crayon = turtle.Turtle()
crayon.penup()
crayon.goto(-200, -200)
crayon.pendown()
for _ in range(4):
    crayon.forward(400)
    crayon.left(90)
crayon.hideturtle()
 
 
# Création de la première particule
particule1 = turtle.Turtle()
particule1.pencolor("blue")
particule1.pensize(5)
particule1.speed(9)
particule1.left( randint(-0, 359) )
 
# Création de la deuxième particule
particule2 = turtle.Turtle()
particule2.pencolor("red")
particule2.pensize(5)
particule2.speed(9)
particule2.left( randint(-0, 359) )
 
# Création de la troisième particule
particule3 = turtle.Turtle()
particule3.pencolor("green")
particule3.pensize(5)
particule3.speed(9)
particule3.left( randint(-0, 359) )
 
# Fausses valeurs initiales pour démarrer le while
maximum = 0
 
# On commence la course
while maximum < 200:
 
    # déplacement de la particule 1
    particule1.left( randint(-20, 20) )
    particule1.forward(5)
 
    # déplacement de la particule 2
    particule2.left( randint(-20, 20) )
    particule2.forward(5)
 
    # déplacement de la particule 3
    particule3.left( randint(-20, 20) )
    particule3.forward(5)
 
    # recherche des coordonnées extrêmes 
    x1 = particule1.xcor()
    y1 = particule1.ycor()
    x2 = particule2.xcor()
    y2 = particule2.ycor()
    x3 = particule3.xcor()
    y3 = particule3.ycor()
    maximum = max(x1, -x1, y1, -y1, x2, -x2, y2, -y1, x3, -x3, y3, -y3)
 
print("Course aléatoire terminée !")

⚙ 10° Passons à un exemple financier. Vous avez 500 euros sur un compte qui rapporte 10 % par an. Regardons combien d’années il faudra laisser l’argent en banque pour parvenir à dépasser à 1000 euros.

argent = 500
duree = 0
 
while argent < 1000:
    duree = duree + 1
    argent = argent * 1.1
 
print("Argent au final")
print(argent)
print("Durée total")
print(duree)

Questions

Donner la traduction en français des lignes 4, 5 et 6.
Calculer argent et duree après le premier tour de boucle.
Calculer argent et duree après le deuxième tour de boucle.
Calculer argent et duree après le troisième tour de boucle.

Correction ?

...CORRECTION...

Donner la traduction en français des lignes 4, 5 et 6.

Tant que nous n'avons pas 1000 euros sur le compte
On incrémente la durée (on rajoute un mois)
On augmente la somme sur le compte de 10% (en la multipliant par 1.1)

Calculer argent et duree après le premier tour de boucle.

duree passe de 0 à 1 an.
argent passe de 500*1.1, soit 550 euros.

Calculer argent et duree après le deuxième tour de boucle.

duree passe de 1 à 2 ans.
argent passe de 550*1.1, soit 605 euros.

Calculer argent et duree après le troisième tour de boucle.

duree passe de 2 à 3 ans.
argent passe de 605*1.1, soit 665.5 euros.

3 - FAQ

⇩ ⇧ ⤊

Rien pour le moment

Activité publiée le 05 01 2023
Dernière modification : 05 01 2023
Auteur : ows. h.

⏪

⏫

⏩