PYTHON : EXERCICES NIVEAU C
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 C" 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 C0
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 C" :
- Modifier le programme C1F_frame de la
rubrique "Exemples Niveau C", pour remplacer le bouton rouge central
EXIT par quatre boutons
EXIT (respectivement de couleur rouge,
vert, bleu et jaune) disposés en carré
- Modifier le programme C2C_toggle de la
rubrique "Exemples Niveau C", pour faire en sorte que la couleur initiale
de chaque case de la grille soit choisie aléatoirement parmi l'ensemble
des 6 couleurs de base (rouge, vert, bleu, cyan, magenta, jaune) au
lieu d'avoir une couleur constante.
- Modifier le programme C3C_message de la
rubrique "Exemples Niveau C", pour faire en sorte que les actions associées
aux 3 touches 'AAA', 'BBB' et 'CCC' soient choisies aléatoirement à chaque
lancement du programme, au lieu d'être systématiquement les mêmes.
- Modifier le programme C6D_event de la
rubrique "Exemples Niveau C", pour faire en sorte que le déplacement du
curseur (= case verte) se fasse de manière automatique (une case au hasard,
soit en haut, en bas, à droite ou à gauche, toutes les secondes) au lieu
d'être contrôlée par l'utilisateur à l'aide des flèches.
- Modifier le programme C7A_canvas de la rubrique
"Exemples Niveau C", pour rajouter une fonction move_image() permettant
d'afficher une image sur le canvas et contrôler sa position de manière
interactive, en déplaçant la souris.
Exercice C1
A partir des exemples vus en cours sur l'utilisation du module
ezTK (et notamment de l'exemple C1C_frame),
écrire un programme grid composé des 6 fonctions suivantes:
- stripes(width=400, height=400, rows=40)
- colorstripes(width=400, height=400, rows=40)
- chessboard(width=400, height=400, rows=8, cols=8)
- colorboard(width=400, height=400, rows=8, cols=8)
- boxes(width=400, height=400, rows=13, cols=13)
- colorboxes(width=400, height=400, rows=13, cols=13)
qui vont respectivement de générer le résultat graphique de chacune des
six fenêtres présentées ci-dessous (widgets utilisées : Brick).
La taille globale de la fenêtre est contrôlée par les paramètres
width et height, tandis que les paramètres rows et cols définissent le nombre de lignes et de colonnes de la grille
utilisée pour définir la fenêtre.
Exercice C2
Ecrire un programme 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 C3
Ecrire un programme 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 C4
Ecrire un programme 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, Scale, Brick)
Exercice C5
Ecrire un programme 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, Button).
Exercice C6
Ecrire un programme 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
C5, 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 C7
Ecrire un programme 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'une grille rectangulaire qui représentera l'emplacement du trésor (la
taille de la grille 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 < 4, jaune pour une distance < 7, vert pour
une distance < 10, bleu pour une distance < 13, 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, Label, Button)
Exercice C8
Ecrire un programme 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. Le
résultat graphique souhaité est représenté dans l'image ci-dessous (widget
utilisée : Canvas)
Exercice C9
Ecrire un programme clock qui affiche et anime une
horloge analogique classique à 3 aiguilles (heures, minutes, secondes). Pour
récupérer l'heure exacte, on pourra utiliser la fonction localtime()
définie dans le module time de la bibliothèque standard de Python. Le
résultat graphique souhaité est représenté dans l'image ci-dessous
(widget utilisée : Canvas)
...
Christophe Schlick