Exo récap

Identification

Infoforall

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

      notelireClavier()

      notetransformerEnEntier(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)

    somme0

    Permet de faire l'action n fois

    POUR x variant de 0 à (n - 1)

      notedemanderUneNote()

      on obtient une note valide

      sommesomme + 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
def afficher(depart, arrivee) : pass
>>> afficher(14,17) 14 15 16 17

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 : 05 10 2020
Auteur : ows. h.