Exo récap

Identification

Infoforall

8 - 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

1 - Calcul de moyenne

✎ 01° Créer une fonction moyenne qui possède deux paramètres : le nombre n de notes qu'on a utilisé et le total cumulé des notes.

Les préconditions : 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 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.

La précondition de la fonction : le paramètre n est un nombre entier positif.

Aucun test de validité sur les entrées utilisateurs ne sera effectué lors de la saisie dans un premier temps.

La postcondition : la fonction renvoie bien la somme des notes rentrées (en considérant que les entrées utilisateurs sont toutes correctes).

Il faudra utiliser une boucle bornée FOR, du input et de la transformation de type.

✎ 03° 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.

✎ 04° Modifier la fonction notes pour qu'elle redemande une saisie de notes si la précédente n'est pas entre 0 et 20.

Il faudra utiliser une boucle non bornée WHILE et la fonction validation.

✎ 05° Même si vos fonctions ne fonctionnent pas, fournir un programme (utilisant ces fonctions) et demandant 5 notes pour en afficher la moyenne à l'écran.

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.

Voici pour le petit retour sur un grand nombre de connaissances que vous aviez vu jusqu'à présent.

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