26 - (Mini-projet) Le pendu
La suite de l'activité précédente.
La dernière fois, nous avons réalisé les fonctions gérant les données. Nous allons aujourd'hui faire l'interface avec la console pour obtenir un petit jeu autonome : pour l'instant, quelqu'un désirant joueur doit savoir coder en Python puisqu'il doit faire les appels aux fonctions lui-même !
Logiciel nécessaire pour l'activité : Python 3 : Thonny, IDLE ...
Evaluation ✎ : rien, tous les exercices sont corrigés. Par contre, il y a le DS qui va bien derrière :o)
1 - Interface Console
Rappel : les deux fonctions natives d'interface liées à la console
Les deux fonctions natives que propose Python pour gérer une interface texte :
- print pour afficher sur l'écran et
- input pour récupérer le texte tapé sur le clavier (sous forme d'un string).
Attention : pas de print ou de print en spécialité math pour ceux qui font à la fois NSI et Maths : en maths, vous n'aurez jamais à gérer l'interface : vous aurez à créer les fonctions et vous enverrez juste les informations via les paramètres.
2 - Affichage du pendu
Pour afficher le pendu, il faut déterminer le nombre de tentatives possibles.
Partons sur 6 :
L'affichage initial sera par exemple (0 faute)
1 ╔═══════╦═══
2 ║
3 ║
4 ║
5 ║
6 ║ ███
L'avant-dernier affichage sera par exemple (5 fautes):
1 ╔═══════╦═══
2 ║ |
3 ║ O
4 ║ -|-
5 ║ / \
6 ║ ███
Le dernier affichage sera par exemple (6 fautes, fin de partie):
1 ╔═══════╦═══
2 ║ |
3 ║ O
4 ║ -|-
5 ║ / \
6 ║ perdu !
01° Réaliser les autres tableaux permettant à la fonction d'interface de fonctionner quelque soit l'étape.
A quoi servent les caracères \n ?
>>> recuperer_pendu(5)
'1 ╔═══════╦═══\n2 ║ |\n3 ║ O\n4 ║ -|-\n5 ║ / \\ \n6 ║ perdu !'
>>> afficher_pendu(5)
1 ╔═══════╦═══
2 ║ |
3 ║ O
4 ║ -|-
5 ║ / \
6 ║ perdu !
1
2
3
4
5
6
7
8 | |
...CORRECTION...
Le caracère d'échappement suivi de n (\n) signale qu'on veut passer à la ligne. Le n est là pour dire new line.
Sinon, il suffit de définir les autres index à afficher.
3 - Récupération de la lettre voulue
02° Réaliser la fonction d'interface récupérant la réponse de l'utilisateur depuis le clavier.
Voici son prototype :
1 | |
Voici un exemple de ce qu'elle doit faire :
>>> lettre_voulue = recuperer_reponse()
A quelle lettre pensez-vous ? a
>>> lettre_voulue
'a'
...CORRECTION...
1
2 | |
4 - Les autres affichages
04° Pour afficher le mot déjà découvert au joueur, quelqu'un réalise la fonction ci-dessous :
1
2
3 | |
Pourquoi a-t-il effectivement le droit d'utliser cette façon d'utiliser le FOR (for 'nominatif') ?
...CORRECTION...
On peut utiliser cette façon de faire car on veut juste LIRE les cases.
04° Aurait-on pu l'utiliser si on avait voulu MODIFIER les cases du tableau ?
...CORRECTION...
Non : dans ce cas, il faut taper un code du type tableau[numero]. Il faut donc utiliser un FOR pour obtenir les valeurs numériques des index possibles.
05° Transformer la fonction précédente en utilisant cette fois plutôt un FOR sous la forme for index in range (len(mot)).
...CORRECTION...
1
2
3 | |
06° Réaliser la dernière fonction d'affichage dont nous avons besoin : voici son prototype.
1 | |
Elle doit afficher un message de victoire si le paramètre booléen reussite est VRAI. Dans le cas contraire, elle doit afficher un message signalant que c'est fini et afficher le mot qu'il fallait trouver. On l'obtient via le paramètre vrai_mot.
...CORRECTION...
1
2
3
4
5 | |
5 - Le jeu
Nous avons maintenant réalisé toutes nos fonctions d'interface et de gestion de données. Il ne reste que l'assemblage final. Voici une possibilté d'utilisation :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 | |
On constate que le programme ne fait que deux lignes (19-20 ici) !
Il consiste à choisir un mot (pour l'instant, on l'impose à la main) et à lancer le jeu en transmettant notre mot.
Et que fait la fonction jouer ? C'est une fonction de liaison qui utilise toutes nos fonctions de gestion de données et nos fonctions d'interface. Elle contrôle le jeu. La seule nouveauté pour vous est le rajout d'une variable etape permettant de compter le nombre d'échec et d'ainsi savoir où en est le joueur.
07° Mettre le jeu en mémoire et faire une partie ou deux.
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117 | |
09° Ligne 104 : quelles sont les deux conditions à réunir pour continuer à poser la question au joueur ? Expliquer pourquoi on rentre dans la boucle au moins une fois au départ.
Pour rendre le jeu plus intéressant, il faudrait par exemple que le mot choisi soit issu d'une liste présente dans un fichier-texte et qu'on tire le mot au hasard.
Nous verrons la gestion des fichiers-texte un peu plus tard dans l'année mais voici la fonction qu'il suffit de rajouter pour le moment pour rendre cela utilisable.
Cela vous permettra de voir que ce n'est pas très compliqué à faire : il suffit de connaître la syntaxe.
6 - Récupérer les mots dans un fichier-texte
Pas trop d'explications sur cette partie. Nous verrons comment comprendre ce code plus tard. L'important est que vous comprenniez le principe.
10° Créer un nouveau fichier avec Thonny. N'y mettre que des mots, un par ligne. Enregister (dans un dossier que vous saurez localiser bien) le tout sous le nom "desmots.txt".
Par exemple :
informatique
ordinateur
boucle
fonction
condition
sciences11° Ouvrir une nouvelle page dans Thonny et rajouter cette fonction en mémoire en sauvegardant au même endroit que le fichier-texte précédent.
1
2
3
4
5
6
7
8 | |
>>> recuperer_des_mots("desmots.txt")
['informatique', 'ordinateur', 'boucle', 'fonction', 'condition', 'sciences']
12° D'après le code, quel est le point important à ne pas oublier une fois le fichier ouvert ?
...CORRECTION...
Il ne faut pas oublier de fermer le fichier.
Encore une fois : une tâche par fonction uniquement.
Maintenant, il faudrait tirer l'un des mots au hasard avec une autre fonction.
13° Rajouter cette nouvelle fonction en mémoire : elle permet de tirer un mot au hasard parmi les mots présents. En réalité, on tire au hasard un numéro d'index valide. Question : pourquoi marquer qu'on prend la longeur - 1 sur la ligne 14 ?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 | |
...CORRECTION...
Contrairement à range, la fonction randint prend réellement la valeur finale. Or si le tableau comporte x éléments, l'index final sera x-1 puisqu'on commence à 0.
Nous avons maintenant deux fonctions basiques : l'une récupére les données dans un fichier-texte et les transforme en tableau. L'autre tire aléatoirement un élément d'un tableau. Vous devinez ce qu'on va pouvoir faire : les associer dans une fonction plus "complexe" qui va utiliser les deux fonctions "basiques" précédentes.
14° Mettre les trois fonctions en mémoire.
Vérifiez ensuite que cela fonctionne :
>>> recuperer_un_mot("desmots.txt")
'boucle'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 | |
Et voilà : on réalise une tâche complexe en la décomposant en tâches plus simples. Du coup, on peut maintenant intégrer ce qu'on vient de faire et demander au jeu de tirer un mot aléatoirement plutôt que de n'utiliser que le mot mystère qu'on avait noté à la main.
15° Mettre le code suivant en mémoire. Observer bien que le code est décomposé en plusieurs parties :
- Une documentation présentant les prototypes des fonctions du fichier
- Ensuite la partie Importation
- Ensuite les déclarations de fonctions triées : fonctions d'interface, fonctions gestion de données et fonctions de liaison.
- Le programme lui-même si besoin
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139 | |
Voilà, c'est la fin de cette grande séquence permettant de stabiliser vos connaissances.
La prochaine fois que vous aurez un projet à faire, vous serez beaucoup plus autonome.
Vous appliquez la méthode suivante :
- Réflexion globale sur les petites fonctions qu'il faudra créer
- Créer les prototypes de fonctions, leurs documentations et quelques exemples d'utilisation qu'on placera directement dans la documentation.
- Se lancer dans la conception des premières fonctions, en envoyant directement les arguments depuis la console en mode interactif
- Une fois qu'une majorité des petites fonctions sont réalisées, passer à la phase conception des fonctions les utilisant
- Réaliser quelques fonctions d'interface basiques
- Réaliser votre premier prototype utilisant une fonction de liaison au moins
- Affiner le projet une fois qu'un premier prototype fonctionne même s'il manque des fonctionnalités : inutile d'affiner AVANT qu'un prototype même basique ne soit fonctionnel...
Activité publiée le 22 11 2020
Dernière modification : 07 09 2024
Auteur : ows. h.