PYTHON : EXERCICES NIVEAU E
Pour tous les exercices de cette page, l'interaction entre l'utilisateur
et le programme est effectuée au moyen d'une "interface
graphique" ("graphics user interface" ou GUI, en anglais). Dans
ce mécanisme, l'utilisateur agit à l'aide du clavier et de la souris sur
différents éléments graphiques (appelés "widgets") d'une fenêtre sur l'écran.
Pour faciliter l'écriture de programme mettant en oeuvre ce principe, on vous
fournit le module Python ezTK qui sera détaillé en
cours et qui contient des outils permettant de simplifier au maximum les
opérations nécessaires à la création et la gestion des fenêtres graphiques.
Le module ezTK est en fait une surcouche simplifiée
de la bibliothèque tkinter disponible dans la
bibliothèque standard de Python.
Pour bien démarrer, il est fortement conseillé de s'inspirer de quelques
exemples de programmes. Trois sources de documentation sont fournies :
- Les codes sources disponibles dans la rubrique "Exemples
Niveau E" permettent de partir dans une bonne direction, en proposant un
squelette standardisé pour l'écriture de programmes mettant en oeuvre une
interface graphique, à l'aide du module ezTK.
- La lecture du chapitre 8 du livre de Gérard Swinnen, "Apprendre à programmer avec Python" constitue une bonne
introduction à tkinter en français.
- Mais le document de référence le plus intéressant est en anglais. Il
s'agit du manuel "Tkinter Reference" de John
Shipman qui détaille l'ensemble des paramètres de configuration des
objets graphiques de la bibliothèque.
Exercice E0
L'objectif de cet exercice d'introduction est de réaliser une série de
modifications simples sur les codes sources fournis dans la rubrique
"Exemples Niveau E" :
- Modifier la version finale du programme frame
(cf. exemple E1) pour remplacer le bouton rouge central
EXIT par quatre boutons EXIT (respectivement
de couleur rouge, bleu, vert et jaune) disposés en carré
- Modifier la version finale du programme toggle
(cf. exemple E2) pour faire en sorte que la couleur des boutons de la grille
alterne, de manière cyclique, entre les couleurs rouge, bleu, vert et jaune
Exercice E1
Ecrire une classe Counter qui affiche une fenêtre
graphique permettant à l'utilisateur de contrôler un compteur numérique dans
un intervalle [-1000, 1000] par une série de sept boutons de commande. Les
trois boutons [ |< ] , [ 0 ] , [ >| ]
permettent d'aller directement à la
valeur minimale, la valeur nulle ou la valeur maximale du compteur. Les
quatre boutons [ << ] , [ < ] ,
[ > ] , [ >> ] permettent de
modifier la valeur courante du compteur par pas de -10, -1, 1 et 10. A tout
moment, il faut vérifier que la valeur du compteur se trouve bien dans
l'intervalle autorisé.
Le résultat graphique souhaité est représenté dans l'image ci-dessous
(widgets utilisées : Frame, Label, Button)
Exercice E2
Ecrire une classe Chrono qui affiche une fenêtre
graphique permettant à l'utilisateur de contrôler un chronomètre par une
série de boutons. Le chronomètre est démarré avec le bouton "START" et sa
valeur de son compteur doit s'incrémenter automatiquement toutes les 10
millisecondes, jusqu'à l'appui sur le bouton "STOP". A tout moment, le bouton
"RESET" permet de réinitialiser la valeur du chronomètre à zéro. La fonction
after, disponible avec les widgets du module
ezTK, qui permet de lancer automatiquement une
fonction quelconque après un temps prédéterminé, sera utilisée pour obtenir
l'incrémentation automatique du chrono.
Le résultat graphique souhaité est représenté dans l'image ci-dessous
(widgets utilisées : Frame, Label, Button)
Exercice E3
Ecrire une classe Colors qui affiche une fenêtre
graphique permettant à l'utilisateur de créer interactivement une couleur dans
le mode RGB (Red, Green, Blue). Pour cela, le programme doit fournir trois
potentiomètres permettant de saisir une valeur entre 0 et 255, contrôlant
respectivement les intensités de rouge, de vert et de bleu. Les valeurs de ces
trois potentiomètres sont alors converties en hexadécimal pour créer une
chaîne de caractères de la forme "#RRGGBB" correspondant à la représentation
standard des couleurs en informatique. Cette couleur est
ensuite utilisée comme couleur de fond de la partie inférieure de la fenêtre,
ce qui permet à l'utilisateur de visualiser le résultat de ses manipulations.
Le résultat graphique souhaité est représenté dans l'image ci-dessous (widgets
utilisées : Frame, Label, Button, Scale)
Exercice E4
Ecrire une classe LeapFrog qui affiche une fenêtre
graphique permettant de jouer au classique casse-tête des grenouilles, que vous
pouvez tester sur une version
en ligne. L'exercice consiste à implémenter une première version qui se joue
à la souris (le joueur doit cliquer sur une grenouille pour la faire avancer ou
sauter), puis une seconde version qui se joue uniquement au clavier avec les
touches "Flèche Droite" et "Flèche Gauche" (à chaque appui de touche, le programme
devra détecter quelle est la grenouille qui peut réaliser l'action demandée).
Le résultat graphique souhaité est représenté dans l'image ci-dessous (widgets
utilisées : Frame, Label)
Exercice E5
Ecrire une classe GuiFibo qui reprend le
fonctionnement du programme fibo (cf. exercice A1)
en y ajoutant une interface graphique proposant la saisie de la valeur de n, ainsi que l'affichage du résultat calculé. Deux
ascenseurs (vertical et horizontal) doivent être inclus afin de permettre de
visualiser l'ensemble des résultats même pour de très grandes valeurs de n.
Le résultat graphique souhaité est représenté dans l'image ci-dessous (widgets
utilisées : Frame, Label, Button, Entry, Listbox)
Exercice E6
Ecrire une classe Slide qui affiche une fenêtre
graphique permettant à l'utilisateur de jouer au Jeu du Taquin ("Slide
Puzzle"). Vous pouvez tester
une version
en ligne pour avoir une idée générale du jeu.
La version implémentée dans cet exercice diffère de la version standard car
elle se base sur des couleurs plutôt que d'utiliser des lettres ou des nombres
pour les différentes cases. Ainsi au démarrage du jeu, le programme affiche une
grille de taille 5x5 dans laquelle se répartissent aléatoirement 6 jetons
rouges, 6 jetons verts, 6 jetons bleus, 6 jetons jaunes et une case blanche
(cf. image de gauche, ci-dessous). La case blanche correspond à la case vide
qui permet de faire "glisser" les jetons horizontalement ou verticalement. Au
départ de la partie, les 24 jetons de couleurs et la case blanche sont disposés
au hasard.
Le but du jeu est de reconstituer le plus rapidement possible (soit en temps
mimimal, soit en nombre de coups minimal), une configuration où les couleurs
sont rangées par blocs (cf. image de droite ci-dessous). Comme dans l'exercice
E4, on va implémenter deux versions du jeu : l'une utilisant les touches
fléchées du clavier, l'autre utilisant la souris pour sélectionner les cases à
déplacer. La fenêtre devra également comporter deux boutons: le bouton
SHUFFLE permet de remélanger l'ensemble des jetons pour créer une nouvelle
position de départ, et le bouton RESET permet de revenir à la position de
départ de la partie en cours (qui devra donc être mémorisée) si l'utilisateur
souhaite rejouer la partie dans un but d'obtenir un meilleur score.
Le programme devra ainsi détecter la fin du jeu qui se produit lorsque 4 blocs
2x3 de couleur uniforme sont obtenus, quelque soit leur position. Un moyen
algorithmique simple pour détecter ce cas de figure consiste à compter, pour
chaque case de la grille, le nombre de cases de sa couleur parmi ses 4 voisins.
Si pour toutes les cases, le compteur vaut 2 ou 3, la configuration gagnante
sera obtenue.
Exercice E7
Ecrire une classe Hunt qui affiche une fenêtre
graphique permettant à l'utilisateur de jouer au jeu classique de la chasse au
trésor ("Treasure Hunt"). Le programme sélectionne aléatoirement l'une des
cases d'un damier 16x8 qui représentera l'emplacement du trésor (la taille du
damier doit être un paramètre de configuration modifiable dans le code
source). A chaque tour, l'utilisateur clique sur une case et le programme y
affiche un code de couleur relatif à la distance entre cette case et la case
au trésor (rouge pour une distance < 3, jaune pour une distance < 6, vert
pour une distance < 9, bleu pour une distance < 12, et gris pour toutes les
distances au-delà). Attention, il ne s'agit pas d'une distance euclidienne,
mais d'une distance de Manhattan, correspondant au nombre de déplacements
horizontaux ou verticaux nécessaires pour rejoindre la case au trésor. Le but
du jeu est évidemment de trouver le trésor en un minimum de tours.
Le résultat graphique souhaité est représenté dans l'image ci-dessous (widgets
utilisées : Frame, Button, Label)
Exercice E8
Ecrire une classe Maze qui affiche une fenêtre
graphique permettant de visualiser un labyrinthe, et d'animer le cheminement
d'un marcheur à l'intérieur de ce labyrinthe. Le labyrinthe est défini par
un fichier texte, au format standard CSV (Comma Separated Values), basé sur un
formalisme très simple : chaque case de la grille est définie par un caractère
unique avec la sémantique suivante : A = mur, B = couloir. Le fichier
maze.csv donne un exemple de
labyrinthe décrit avec ce formalisme. De même, la trajectoire du marcheur est
définie par un autre fichier texte au format CSV, contenant les coordonnées des
cases successives parcourues par le marcheur. Le fichier
walk.csv donne un exemple de trajectoire
possible avec le labyrinthe précédent. Pour la lecture des fichiers CSV, le
plus simple est d'utiliser la fonction read_csv(filename)
fournie par la bibliothèque ezCLI (cf. l'exemple B4A fournit un mini-tuto
pour son utilisation)
Le résultat graphique souhaité est représenté dans l'image ci-dessous (widget
utilisée : Canvas)
Exercice E9
Ecrire une classe PixelArt qui affiche une fenêtre
graphique permettant de visualiser une image en utilisant des disques colorés
pour représenter des pixels. L'image est définie par un fichier texte, composé
de 2 parties séparées par une ligne de 3 tirets '---'. La partie supérieure
du fichier correspond à la définition de l'image, où chaque pixel est encodé
par un caractère unique. La partie inférieure du fichier correspond à la palette
de couleurs utilisée pour l'image, et contient une série de couleurs au format
hexadécimal standard '#RRGGBB'. Le fichier
pixelart.txt donne un exemple d'image
décrit avec ce formalisme. Pour la lecture de ces fichiers TXT, le
plus simple est d'utiliser la fonction read_txt(filename)
fournie par la bibliothèque ezCLI (cf. l'exemple B2A fournit un mini-tuto
pour son utilisation)
Pour améliorer l'effet visuel, les disques colorés ne sont pas simplement
positionnés dans une grille régulière, mais chaque disque sera déplacé
aléatoirement d'un petit vecteur de translation (dx, dy). Le résultat graphique
souhaité est représenté dans l'image ci-dessous. L'exemple E7B fournit un exemple
de tracé de disques colorés dans une widget Canvas
Exercice E10
Ecrire une classe Clock qui affiche une fenêtre
graphique montrant une horloge à aiguilles. Une première version du programme
devra uniquement afficher l'aiguille des secondes (qui sera évidemment animée
pour se déplacer d'un soixantième de tour (angle de 6 degrés) à chaque seconde.
Ensuite, une seconde version plus complexe, devra afficher et animer
correctement les trois aiguilles (heures, minutes et secondes).
Le résultat graphique souhaité est représenté dans l'image ci-dessous (widget
utilisée : Canvas)
...
Christophe Schlick