18 - Exercices récapitulatifs
Quelques exercices d'entrainement sur les notions vues dans les activités précécedentes. Rien de nouveau.
Evaluation ✎ : questions 01-02-03-04-05-07-08-09-11-12-14-15-16
1 - Calcul de moyenne
✎ 01° Créer une fonction moyenne qui possède deux paramètres : le total cumulé des notes et le nombre n de notes qu'on a utilisé pour avoir ce total.
Exemple d'utilisation :
>>> moyenne(36, 3)
12
Les préconditions (c'est à dire les conditions d'utilisation de votre fonction): les paramètres n et total sont des nombres entiers positifs.
La postcondition : Votre fonction devra renvoyer la moyenne sous forme d'un integer.
✎ 02° Créer une fonction validation qui possède un paramètre : un nombre note.
La précondition : le paramètre note est un entier positif, négatif ou nul.
La postcondition : Votre fonction devra renvoyer True si la note est valide (comprise dans [0;20] et False sinon.
On utilisera les tests if et un and par exemple.
✎ 03° Créer une fonction demanderUneNote qui demande à l'utilisateur de rentrer une note en boucle, tant que la note fournie n'est pas bonne. La lecture clavier sera faite avec un input en Python. Voici l'algorithme correspondant :
Algorithme de demanderUneNote()
On initialise avec une note fausse
note ← -100
Permet de faire l'action tant que l'utilisateur répond mal
TANT QUE validation(note) renvoie FAUX
note ← lireClavier()
note ← transformerEnEntier(note)
Fin TANT QUE
Renvoyer note
✎ 04° Créer une fonction notes qui possède un seul paramètre : le nombre n de notes qu'on veut rentrer.
Votre fonction devra renvoyer la somme des notes fournies par l'utilisateur.
Précondition : le paramètre n est un nombre entier positif.
Postcondition : la fonction renvoie bien la somme des notes rentrées (en considérant que les entrées utilisateurs sont toutes interprétables comme un entier).
Pour cela, il faudra suivre l'algorithme suivant :
Algorithme de notes(n)
somme ← 0
Permet de faire l'action n fois
POUR x variant de 0 à (n - 1)
note ← demanderUneNote()
on obtient une note valide
somme ← somme + note
on rajoute les notes au fur et à mesure
Fin POUR
Renvoyer somme
Attention avec Python, range(n) provoque un boucle avec une variable de boucle variant de 0 à n-1. Le n est donc exclu.
Par contre, lorsqu'on écrit l'algorithme, on donne habituellement la valeur finale inclue ! Je n'y peux rien, c'est comme ça.
Si on veut écrire une boucle POUR variant de 0 à n-1, on écrira alors juste ceci dans un algorithme (pensez à regarder la remarque en rouge en dessous lorsque vous l'implémenterez en Python) :
POUR x variant de 0 à (n - 1)
✎ 05° Même si vos fonctions ne fonctionnent pas, fournir un programme (utilisant ces fonctions) demandant 5 notes pour en afficher la moyenne à l'écran. On utilisera donc les fonctions notes et moyenne.
2 - Turtle
Réalisons une animation comportant un crayon qui avance jusqu'au bord de notre dessin.
Le crayon tournera forcément à gauche. Disons que c'est le jeu du crayon qui ne tourne qu'à gauche...
Le crayon peut rebondir 200 fois.
Le principe est le suivant :
- On crée un terrain de jeu
- On crée un crayon positionné au hasard
- On initialise un compteur à 0
- On lance une boucle WHILE qui réalise les actions ci-dessous tant que le compteur reste inférieur à 200 :
- On récupére les coordonnées x et y du crayon
- Si l'une des coordonnées du crayon n'est plus dans le terrain de jeu :
- On tourne d'une valeur aléatoire comprise entre 40° et 50°
- On avance de 2 pixels
- On augmente le compteur de 1
- Sinon :
- On avance de 2 pixels
Voici la représentation sous forme d'un code Python :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58 | # Importation des modules nécessaires
import turtle as trt
import random as rd
# Constantes du plateau de jeu
compteur = 0 # Nbr de rebonds
pmax = 300 # Taille du plateau de jeu
fond = 'grey' # Couleur du fond
bordure = "blue" # Couleur du rebord
xo = rd.randint(0, pmax) # xo est compris entre 0 et pmax
yo = rd.randint(0, pmax) # yo est compris entre 0 et pmax
# Création du crayon
crayon = trt.Turtle()
# Création du plateau de jeu
crayon.penup()
crayon.pensize(10)
crayon.pencolor(bordure)
crayon.fillcolor(fond)
crayon.setposition(-pmax, -pmax)
crayon.pendown()
crayon.begin_fill()
crayon.setposition(-pmax, pmax)
crayon.setposition(pmax, pmax)
crayon.setposition(pmax, -pmax)
crayon.setposition(-pmax, -pmax)
crayon.end_fill()
crayon.penup()
# Mise en place du crayon en xo,yo
crayon.pencolor('black')
crayon.setposition(xo, yo)
crayon.pendown()
crayon.pensize(3)
crayon.left(rd.randint(40,50))
# Déplacement du crayon
while compteur < 200:
x,y = crayon.position()
if x > pmax:
crayon.left(rd.randint(40,50))
crayon.forward(2)
compteur = compteur + 1
elif y > pmax:
crayon.left(rd.randint(40,50))
crayon.forward(2)
compteur = compteur + 1
elif x < -pmax:
crayon.left(rd.randint(40,50))
crayon.forward(2)
compteur = compteur + 1
elif y < -pmax:
crayon.left(rd.randint(40,50))
crayon.forward(2)
compteur = compteur + 1
else:
crayon.forward(2)
|
06° Lancer le programme pour visualiser son fonctionnement.
✎ 07° Après avoir observer les lignes 39, 44, 48, 52 et 56, donner le nombre de changements de direction qui seront possibles.
✎ 08° Analyser le code pour trouver la ligne où l'on récupére les coordonnées x et y du crayon. Comment se nomme visiblement la méthode permettant de récupérer les coordonnées liées à la position actuelle du crayon ?
✎ 09° Que contient pmax ? Pensez à lire les commentaires.
En déduire les valeurs de x et y pour lesquelles le crayon change de direction.
Pour l'instant, le crayon tourne toujours à gauche et écrit toujours de la même couleur. C'est un peu monotone.
On peut faire mieux : on peut récupérer l'angle actuel du tracé à l'aide de la méthode heading. On peut alors placer cette valeur dans une variable. Par exemple :
angle = crayon.heading()
10° Modifier le code de façon à transformer la façon de dessiner : Si l'angle est supérieur à 180°, c'est que le crayon descend : on trace en blanc (white).
Sinon, c'est qu'on monte : on trace en noir.
Il faut inclure des modifications entre la ligne 40 et 41 par exemple.
Rappel : réglage de la couleur du dessin en cours
crayon.pencolor('black')
...CORRECTION...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63 | # Importation des modules nécessaires
import turtle as trt
import random as rd
# Constantes du plateau de jeu
compteur = 0 # Nbr de rebonds
pmax = 300 # Taille du plateau de jeu
fond = 'grey' # Couleur du fond
bordure = "blue" # Couleur du rebord
xo = rd.randint(0, pmax) # xo est compris entre 0 et pmax
yo = rd.randint(0, pmax) # yo est compris entre 0 et pmax
# Création du crayon
crayon = trt.Turtle()
# Création du plateau de jeu
crayon.penup()
crayon.pensize(10)
crayon.pencolor(bordure)
crayon.fillcolor(fond)
crayon.setposition(-pmax, -pmax)
crayon.pendown()
crayon.begin_fill()
crayon.setposition(-pmax, pmax)
crayon.setposition(pmax, pmax)
crayon.setposition(pmax, -pmax)
crayon.setposition(-pmax, -pmax)
crayon.end_fill()
crayon.penup()
# Mise en place du crayon en xo,yo
crayon.pencolor('black')
crayon.setposition(xo, yo)
crayon.pendown()
crayon.pensize(3)
crayon.left(rd.randint(40,50))
# Déplacement du crayon
while compteur < 200:
x,y = crayon.position()
angle = crayon.heading()
if angle >= 180:
crayon.pencolor('white')
else:
crayon.pencolor('black')
if x > pmax:
crayon.left(rd.randint(40,50))
crayon.forward(2)
compteur = compteur + 1
elif y > pmax:
crayon.left(rd.randint(40,50))
crayon.forward(2)
compteur = compteur + 1
elif x < -pmax:
crayon.left(rd.randint(40,50))
crayon.forward(2)
compteur = compteur + 1
elif y < -pmax:
crayon.left(rd.randint(40,50))
crayon.forward(2)
compteur = compteur + 1
else:
crayon.forward(2)
|
3 - Améliorations
Pour finir, on remarquera que notre déplacement avec Turtle possédait un code où on a appliqué le même code plusieurs fois.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63 | # Importation des modules nécessaires
import turtle as trt
import random as rd
# Constantes du plateau de jeu
compteur = 0 # Nbr de rebonds
pmax = 300 # Taille du plateau de jeu
fond = 'grey' # Couleur du fond
bordure = "blue" # Couleur du rebord
xo = rd.randint(0, pmax) # xo est compris entre 0 et pmax
yo = rd.randint(0, pmax) # yo est compris entre 0 et pmax
# Création du crayon
crayon = trt.Turtle()
# Création du plateau de jeu
crayon.penup()
crayon.pensize(10)
crayon.pencolor(bordure)
crayon.fillcolor(fond)
crayon.setposition(-pmax, -pmax)
crayon.pendown()
crayon.begin_fill()
crayon.setposition(-pmax, pmax)
crayon.setposition(pmax, pmax)
crayon.setposition(pmax, -pmax)
crayon.setposition(-pmax, -pmax)
crayon.end_fill()
crayon.penup()
# Mise en place du crayon en xo,yo
crayon.pencolor('black')
crayon.setposition(xo, yo)
crayon.pendown()
crayon.pensize(3)
crayon.left(rd.randint(40,50))
# Déplacement du crayon
while compteur < 200:
x,y = crayon.position()
angle = crayon.heading()
if angle >= 180:
crayon.pencolor('white')
else:
crayon.pencolor('black')
if x > pmax:
crayon.left(rd.randint(40,50))
crayon.forward(2)
compteur = compteur + 1
elif y > pmax:
crayon.left(rd.randint(40,50))
crayon.forward(2)
compteur = compteur + 1
elif x < -pmax:
crayon.left(rd.randint(40,50))
crayon.forward(2)
compteur = compteur + 1
elif y < -pmax:
crayon.left(rd.randint(40,50))
crayon.forward(2)
compteur = compteur + 1
else:
crayon.forward(2)
|
On pourrait diminuer cette répétition avec l'introduction d'une fonction, nommée tourne.
✎ 11° Fournir le code de la fonction tourne.
1
2
3
4
5
6
7
8
9 | def tourne(crayon, nombre):
"""Fait tourner le crayon et renvoie nombre en l'augmentant de 1
:: param crayon (objet Turle) :: l'objet Turtle qu'on veut déplacer
:: param nombre (int) :: le compteur de déplacement
:: return (int) :: la nouvelle valeur du compteur (+1)
"""
pass
|
Elle doit permettre d'écrire notre programme de cette façon :
1
2
3
4
5
6
7
8
9
10 | if x > pmax:
compteur = tourne(crayon, compteur)
elif y > pmax:
compteur = tourne(crayon, compteur)
elif x < -pmax:
compteur = tourne(crayon, compteur)
elif y < -pmax:
compteur = tourne(crayon, compteur)
else:
crayon.forward(2)
|
C'est mieux. Mais on répète toujours 4 fois la même instruction. C'est juste qu'elle est plus petite.
✎ 12° Simplifier encore une dernière fois le code en utilisant des and ou des or.
Vous devriez obtenir quelque chose qui ressemble à cela :
1
2
3
4 | if une_expression_avec_des_and_ou_des_or:
compteur = tourne(crayon, compteur)
else:
crayon.forward(2)
|
4 - Boucle imbriquée dans une autre boucle
A titre d'exemple final, on peut créer assez facilement un plateau de puissance 4 en réalisant à l'aide d'une boucle dans une boucle les trous ligne par ligne : pour chaque ligne, on trace les cercles sur les différentes colonnes.
13° Utiliser le code ci-dessous pour créer le plateau.
Visualiser la console de façon à comprendre comment s'exécute le programme.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 | # Importation des modules nécessaires
import turtle as trt
# Constantes du plateau de jeu
rayon = 30 # Rayon des cercles
distance = 90 # Distance entre deux tracés
fond = 'grey' # Couleur du fond du cercle
contour = 'black' # Couleur du contour du cercle
# Création du crayon
crayon = trt.Turtle()
crayon.fillcolor(fond)
crayon.pencolor(contour)
crayon.pensize(6)
# Création des cercles
for ligne in range(5):
for colonne in range(5):
print(f"ligne {ligne} - colonne {colonne}")
crayon.penup()
x = -250 + colonne * distance
y = 250 - ligne * distance
crayon.setposition(x,y)
crayon.pendown()
crayon.begin_fill()
crayon.circle(rayon, 360)
crayon.end_fill()
|
Nous reviendrons bientôt sur cette double boucle bornée qui permet de gérer les tableaux à deux dimensions.
✎ 14° Expliquer clairement pourquoi les variables ligne et colonne prennent les valeurs dans l'ordre qui apparaît sur la colonne.
ligne 0 - colonne 0
ligne 0 - colonne 1
ligne 0 - colonne 2
ligne 0 - colonne 3
ligne 0 - colonne 4
ligne 1 - colonne 0
ligne 1 - colonne 1
ligne 1 - colonne 2
ligne 1 - colonne 3
ligne 1 - colonne 4
ligne 2 - colonne 0
ligne 2 - colonne 1
ligne 2 - colonne 2
ligne 2 - colonne 3
ligne 2 - colonne 4
ligne 3 - colonne 0
ligne 3 - colonne 1
ligne 3 - colonne 2
ligne 3 - colonne 3
ligne 3 - colonne 4
ligne 4 - colonne 0
ligne 4 - colonne 1
ligne 4 - colonne 2
ligne 4 - colonne 3
ligne 4 - colonne 4
✎ 15° Le plateau de jeu apparaît ligne par ligne. Modifier le code pour qu'il apparaisse colonne par colonne.
5 - Equivalence
✎ 16° Créer deux fonctions équivalentes (l'une avec un for, l'autre avec un while) qui doivent permettre d'afficher les nombres entre un nombre de départ et un nombre d'arrivée.
1
2 | |
>>> afficher(14,17)
14
15
16
17
Activité publiée le 11 07 2020
Dernière modification : 30 01 2022
Auteur : ows. h.