Mon premier jeu en Python — 4 semaines pour créer « Le mot mystère »

Deux façons de répéter

Une boucle fait répéter un groupe d'instructions. Tu en as déjà utilisé en Scratch. Python en a deux :

1. for : quand tu sais combien de fois.

for i in range(5):
    print("Bonjour !")

Affiche cinq fois Bonjour !. Les lignes décalées de 4 espaces sous le for forment le corps de la boucle : ce qui est répété (comme les pièces glissées dans « répéter »). Chaque passage dans la boucle s'appelle un tour.

Que vaut i ? À chaque tour, i prend la valeur suivante donnée par range :

for i in range(5):
    print(i)

Affiche 0, 1, 2, 3, 4. range(5) commence à 0 et s'arrête avant 5 : il donne bien 5 valeurs, mais la dernière est 4.

2. while : tant qu'une condition est vraie.

compte = 3
while compte > 0:
    print(compte)
    compte = compte - 1
print("Partez !")

Affiche 3, 2, 1, puis Partez !. Avant chaque tour, Python vérifie la condition (compte > 0). Dès qu'elle est fausse, il sort de la boucle et passe à la suite. Attention : si rien ne change dans la boucle, la condition reste vraie pour toujours et le programme ne s'arrête plus. C'est une boucle infinie.

Correspondance avec Scratch

Exemple de « répéter jusqu'à » :

reponse = ""
while reponse != "oui":
    reponse = input("Tu es prête ? (oui/non) ")
print("C'est parti !")

On tape non, peut-être, puis oui : la question est posée trois fois, puis C'est parti ! s'affiche.

« Repérer la répétition »

Rappel en une phrase : for répète un nombre de fois connu, while répète tant qu'une condition est vraie (voir épisode 1).

1. Surligne ce qui se répète dans ton idée ou dans ton code recopié.
2. Compte : sais-tu à l'avance combien de tours ? Oui → for. Non → while.
3. Écris la boucle : la ligne for …: ou while …:, puis le corps décalé de 4 espaces.
4. Teste le premier et le dernier tour : ce sont eux qui cachent le plus d'erreurs.

Avec for : la table de 7

for i in range(1, 11):
    print(i, "× 7 =", i * 7)

Affiche de 1 × 7 = 7 à 10 × 7 = 70. Le premier tour vaut 1 et le dernier 10, grâce à range(1, 11).

Avec while : rejouer tant qu'on veut

rejouer = "oui"
while rejouer == "oui":
    reponse = int(input("Combien font 7 × 8 ? "))
    if reponse == 56:
        print("Bonne réponse !")
    else:
        print("Non, c'était 56.")
    rejouer = input("Veux-tu rejouer ? (oui/non) ")
print("À bientôt !")

On tape 56, oui, 54, non :

La ligne rejouer = input(...) est dans la boucle : c'est elle qui permet un jour de sortir. Le if est lui aussi dans la boucle, et son propre corps est décalé de 8 espaces (4 + 4).

Une boucle remplace des lignes recopiées par une seule ligne qui répète. Moins de lignes recopiées, c'est moins d'endroits où une faute peut se glisser, et une seule ligne à changer pour tout modifier. Le tutoriel officiel montre d'ailleurs for comme la façon de parcourir des valeurs « dans l'ordre », sans les écrire une par une [1].

Bon réflexe ou piège ?

Jouer avec les mots

Une chaîne de caractères (str, vue au Boost) est une suite de caractères rangés dans l'ordre. On peut les compter, les regarder un par un et fabriquer de nouvelles chaînes.

Mesurer et regarder

mot = "python"
print(len(mot))
print(mot[0])
print(mot[-1])
print("y" in mot)
print("z" in mot)

Affiche 6, p, n, True, False.

• len(mot) donne le nombre de caractères.
• mot[0] est le premier caractère (on compte à partir de 0, comme range) ; mot[-1] est le dernier.
• "y" in mot vaut True si la lettre se trouve dans le mot.

Parcourir les lettres : for marche aussi sur un mot.

for lettre in "chat":
    print(lettre)

Affiche c, h, a, t, une lettre par tour.

Transformer : une méthode s'écrit après la chaîne, avec un point.

Piège : une méthode ne modifie pas la chaîne d'origine, elle en fabrique une nouvelle. Il faut la ranger :

ville = "ROME"
ville.lower()
print(ville)
ville = ville.lower()
print(ville)

Affiche ROME, puis rome.

Composer un message : les f-strings. Une f-string commence par f devant les guillemets ; ce qui est entre accolades { } est remplacé par sa valeur.

pseudo = "Inès"
score = 4
print(f"Bravo {pseudo}, tu as {score} sur 5 !")
print(f"Cela fait {score * 20} % de bonnes réponses.")
print("_ " * 5)

Affiche :

On peut mettre un calcul entre les accolades. Et * répète un texte : "_ " * 5 donne cinq tirets, très utile pour cacher un mot.

« Une question, un test »… dans une boucle

Rappels : la méthode « une question, un test » du Boost (voir Boost, épisode 4) ; while et les f-strings (voir épisodes 1 et 3).

Construis le jeu en 4 étapes, en testant à chaque fois :

1. Un seul essai : secret = 42, on demande un nombre, on compare, on affiche « Plus grand ! », « Plus petit ! » ou « Bravo ! ». Teste avec 50, 30 et 42.
2. La boucle : on met la demande dans while essai != secret:. Pour que la condition puisse être testée au premier tour, on donne d'abord à essai une valeur qui ne peut pas être le secret (essai = 0).
3. Le compteur : nb_essais = 0 avant la boucle, nb_essais = nb_essais + 1 dans la boucle.
4. Le message final, après la boucle, avec une f-string.

secret = 42
essai = 0
nb_essais = 0
while essai != secret:
    essai = int(input("Ton nombre ? "))
    nb_essais = nb_essais + 1
    if essai < secret:
        print("Plus grand !")
    elif essai > secret:
        print("Plus petit !")
print(f"Bravo ! Trouvé en {nb_essais} essais.")

On tape 50, 30, 42 :

Quand on trouve, ni le if ni le elif ne s'exécute ; la condition du while devient fausse, et le programme passe au message final.

Construire une boucle étape par étape évite le piège des 30 lignes écrites d'un coup : chaque nouvelle étape n'ajoute qu'une ou deux lignes, et si quelque chose casse, tu sais où chercher. C'est la même méthode qu'au Boost, appliquée à un jeu. Le programme du cycle 4 demande justement, en fin de collège, d'écrire un programme qui utilise une boucle conditionnelle pour atteindre un objectif [1].

Bon réflexe ou piège ?

« for ou while ? »

🎨 Carrousel récapitulatif — Semaine 1

Une liste, c'est une boîte à compartiments

Une liste range plusieurs valeurs, dans l'ordre, sous un seul nom. On l'écrit entre crochets, valeurs séparées par des virgules :

mots = ["chat", "python", "robot"]
print(mots[0])
print(mots[-1])
print(len(mots))

Affiche chat, robot, 3.

• Chaque élément a un numéro, son indice. Le premier est à l'indice 0, comme pour les lettres d'un mot (voir épisode 3). mots[-1] est le dernier.
• len(mots) donne le nombre d'éléments.

Ajouter, modifier, chercher

mots.append("lune")
print(mots)
print(len(mots))
mots[1] = "pomme"
print(mots)
print("robot" in mots)

Affiche :

• .append(valeur) ajoute un élément à la fin : la liste grandit d'une case.
• mots[1] = "pomme" remplace l'élément d'indice 1. Contrairement à une chaîne, une liste se modifie.
• "robot" in mots dit si la valeur est dans la liste.

Parcourir : comme pour un mot, for passe sur chaque élément, dans l'ordre.

for mot in mots:
    print(mot.upper())

Affiche CHAT, POMME, ROBOT, LUNE.

Si l'indice n'existe pas, Python s'arrête avec une erreur que tu sais lire (voir Boost, épisode 2) :

Index out of range = « indice hors des limites » : dans une liste de 3 éléments, les indices vont de 0 à 2.

À vérifier toi-même dans Scratch : crée une liste de trois mots, puis utilise le bloc « élément (1) de (liste) ». Quel mot obtiens-tu ? Compare avec mots[1] en Python. Les deux langages ne comptent pas forcément de la même façon : c'est une erreur classique quand on passe de l'un à l'autre.

« Ranger ce qui change, répéter ce qui reste »

Rappels : une liste range plusieurs valeurs (voir épisode 6) ; for répète (voir épisode 1) ; .strip().lower() rend une réponse tolérante (voir épisode 3).

1. Repère ce qui change d'un bloc à l'autre : ici, la question et la bonne réponse.
2. Range-le dans des listes, dans le même ordre : questions et reponses. La question d'indice 0 va avec la réponse d'indice 0.
3. Écris le bloc une seule fois, dans une boucle qui passe sur les indices : for i in range(len(questions)):.
4. Teste avec toutes les bonnes réponses, puis avec quelques fausses.

questions = [
    "Quelle est la capitale de l'Italie ?",
    "Combien de côtés a un hexagone ?",
    "Combien font 7 × 8 ?",
    "Quelle planète est surnommée la planète rouge ?",
    "Combien de pattes a une araignée ?",
]
reponses = ["rome", "6", "56", "mars", "8"]
score = 0
for i in range(len(questions)):
    reponse = input(questions[i] + " ").strip().lower()
    if reponse == reponses[i]:
        print("Bonne réponse !")
        score = score + 1
    else:
        print(f"Non, la réponse était {reponses[i]}.")
print(f"Ton score : {score} sur {len(questions)}")

Essai réel avec rome, 5, 56, venus, ␣8␣ :

Remarque : les réponses en chiffres sont rangées comme du texte ("6", "56"). On compare donc du texte avec du texte, sans int(...). Une liste peut se couper sur plusieurs lignes entre ses crochets : c'est plus lisible.

Le code qui se répète n'est écrit qu'une fois ; les données qui changent sont rangées à part. Pour ajouter une question, on ajoute une ligne dans chaque liste, sans toucher la boucle. Le tutoriel officiel montre d'ailleurs range(len(...)) comme la façon de parcourir les indices d'une séquence [1].

Bon réflexe ou piège ?

Les modules, des boîtes à outils déjà écrites

Un module est un ensemble d'outils déjà programmés, fourni avec Python. Pour s'en servir, on l'importe en haut du programme avec import, puis on écrit module.outil(...).

random : le hasard

import random
nombre = random.randint(1, 100)
print(nombre)
mots = ["chat", "python", "robot"]
print(random.choice(mots))

Affiche un nombre entre 1 et 100, puis un des trois mots : le résultat change à chaque lancement.

• random.randint(1, 100) tire un nombre entier entre 1 et 100, 1 et 100 compris (attention, ce n'est pas comme range).
• random.choice(mots) tire un élément de la liste.

math : les calculs de maths

import math
print(math.sqrt(16))
print(math.pi)

Affiche 4.0 (la racine carrée de 16) et 3.141592653589793.

turtle : la tortue qui dessine. C'est la tortue du langage Logo, ancêtre de Scratch : elle avance et tourne en traçant un trait.

import turtle
for i in range(4):
    turtle.forward(100)
    turtle.left(90)
turtle.done()

Dessine un carré de 100 pixels de côté : 4 fois, avancer de 100, tourner de 90° à gauche. turtle.done() garde le dessin affiché ; c'est la dernière ligne.

Le hasard de l'ordinateur est-il vraiment du hasard ? Pas tout à fait. L'ordinateur suit un calcul très compliqué qui imite le hasard : on parle de nombres pseudo-aléatoires. Pour un jeu, c'est parfait. Pour un mot de passe ou un secret, il faut d'autres outils.

« Remplacer le fixe par le hasard »

Rappels : random.randint et random.choice (voir épisode 8) ; la devinette (voir épisode 4) ; le mot caché sous des tirets (voir épisode 5).

1. Repère la valeur fixe dans ton programme (secret = 42, mot = "python").
2. Remplace-la par un tirage (random.randint(1, 100), random.choice(mots)), et ajoute import random en première ligne.
3. Teste plusieurs fois : le résultat doit changer. Pour vérifier un tirage pendant tes tests, affiche-le provisoirement (print(secret)), puis retire cette ligne.

La devinette, version hasard : seules deux lignes changent par rapport à l'épisode 4.

import random
secret = random.randint(1, 100)
essai = 0
nb_essais = 0
while essai != secret:
    essai = int(input("Ton nombre ? "))
    nb_essais = nb_essais + 1
    if essai < secret:
        print("Plus grand !")
    elif essai > secret:
        print("Plus petit !")
print(f"Bravo ! Trouvé en {nb_essais} essais.")

Le mot mystère, version 1

import random
mots = ["chat", "python", "robot", "lune", "pirate"]
mot = random.choice(mots)
print("_ " * len(mot))
lettre = input("Propose une lettre : ").strip().lower()
if lettre in mot:
    print(f"Oui, il y a un {lettre} !")
else:
    print(f"Non, pas de {lettre}.")
affichage = ""
for l in mot:
    if l == lettre:
        affichage = affichage + l + " "
    else:
        affichage = affichage + "_ "
print(affichage.strip())

Essai réel, quand le mot tiré est « robot » et qu'on propose o :

La lettre apparaît partout où elle se trouve dans le mot, grâce à la boucle for.

On ne change que la valeur de départ : toute la logique du jeu reste la même. C'est pour cela qu'on avait d'abord écrit la devinette avec un nombre fixe : un jeu qui marche avec une valeur connue marchera avec une valeur tirée au hasard. Et pour vérifier un tirage pendant les tests, l'afficher un instant est la façon la plus simple de savoir ce que le programme a choisi.

Bon réflexe ou piège ?

« Liste ou variable ? »

🎨 Carrousel récapitulatif — Semaine 2

Une fonction, c'est un bloc que tu inventes

Tu utilises déjà des fonctions toutes faites : print, input, len, random.choice. Une fonction, c'est un morceau de code qui porte un nom : tu l'écris une fois, et tu l'appelles autant de fois que tu veux.

Définir et appeler

def saluer(pseudo):
    print(f"Salut {pseudo} !")


saluer("Inès")
saluer("Malik")

Affiche Salut Inès !, puis Salut Malik !.

• def (pour define, définir) commence la définition, suivi du nom de la fonction, des parenthèses et des deux-points.
• pseudo est un paramètre : une boîte qui reçoit la valeur donnée à l'appel ("Inès", puis "Malik").
• Le corps est décalé de 4 espaces. Écrire def n'exécute rien : la fonction ne fait quelque chose que quand on l'appelle, avec ses parenthèses.

Renvoyer un résultat avec return

def double(n):
    return n * 2


resultat = double(21)
print(resultat)
print(double(5) + 1)

Affiche 42, puis 11. return renvoie une valeur au programme, qui peut la ranger dans une variable ou s'en servir dans un calcul. Dès que Python rencontre return, il sort de la fonction.

Afficher n'est pas renvoyer

def afficher_double(n):
    print(n * 2)


x = afficher_double(5)
print(x)

Affiche 10, puis None. La fonction affiche 10 à l'écran, mais ne renvoie rien : x reçoit None, la valeur spéciale de Python qui veut dire « rien ».

Les variables d'une fonction restent dans la fonction. Une variable créée dans une fonction est locale : elle n'existe que pendant l'appel.

def ajouter_point():
    points = 1


ajouter_point()
print(points)

Python s'arrête avec : NameError: name 'points' is not defined. Did you mean: 'print'?. La boîte points a disparu à la fin de l'appel. Remarque : la suggestion de Python (print) est fausse ici. Sa proposition n'est qu'une idée, pas toujours la bonne correction.

Correspondance avec Scratch : dans Scratch, « Créer un bloc » fabrique un bloc « définir » ; ses entrées n'existent qu'à l'intérieur de ce script. En Python, def joue le rôle du bloc « définir », les paramètres celui des entrées.

« Une tâche, une fonction »

Rappel en une phrase : def définit une fonction, return renvoie son résultat (voir épisode 11).

1. Liste les tâches du programme, chacune en quelques mots (« tirer un nombre »).
2. Donne à chaque fonction un nom qui commence par un verbe : tirer_nombre, demander_essai, jouer.
3. Écris les fonctions en haut, les unes sous les autres, séparées par deux lignes vides ; l'appel qui lance tout (jouer()) va tout en bas.
4. Teste chaque fonction seule avant de les assembler.

import random


def tirer_nombre():
    return random.randint(1, 100)


def demander_essai():
    return int(input("Ton nombre ? "))


def jouer():
    secret = tirer_nombre()
    essai = 0
    nb_essais = 0
    while essai != secret:
        essai = demander_essai()
        nb_essais = nb_essais + 1
        if essai < secret:
            print("Plus grand !")
        elif essai > secret:
            print("Plus petit !")
    print(f"Bravo ! Trouvé en {nb_essais} essais.")


jouer()

Le jeu se comporte exactement comme la devinette de l'épisode 9 (vérifié avec les mêmes tirages). Mais chaque tâche porte maintenant un nom.

Tester une fonction seule : avant d'assembler, on vérifie qu'elle fait son travail.

for i in range(5):
    print(tirer_nombre())

Cinq nombres entre 1 et 100 s'affichent : tirer_nombre marche. On supprime ensuite ce test.

Un programme découpé en tâches nommées se lit comme une liste d'étapes : jouer raconte la partie, sans le détail du tirage ou de la saisie. Si un bug apparaît dans le tirage, on sait dans quelle fonction chercher. Et une fonction testée seule est une pièce sur laquelle on peut compter. Le tutoriel officiel va dans le même sens : il recommande de séparer les fonctions par des lignes vides et d'écrire une docstring pour chacune, pour que le code reste lisible [1].

Bon réflexe ou piège ?

Un code lisible

Un programme est lu bien plus souvent qu'il n'est écrit : par toi dans une semaine, par Malik, par ton professeur. Python a un guide officiel de style, la PEP 8.

Exemple : le même code, illisible puis lisible. Les deux affichent p y t _ _ _.

a = "python"
b = ""
for c in a:
    if c in "pyt":
        b = b + c + " "
    else:
        b = b + "_ "
print(b.strip())

def afficher_mot(mot, trouvees):
    """Renvoie le mot avec un tiret à la place de chaque lettre pas encore trouvée."""
    affichage = ""
    for lettre in mot:
        if lettre in trouvees:
            affichage = affichage + lettre + " "
        else:
            affichage = affichage + "_ "
    return affichage.strip()


print(afficher_mot("python", "pyt"))

1. Des noms parlants. Le nom dit ce que contient la boîte : affichage plutôt que b, lettre plutôt que c. Règle de la PEP 8 : fonctions et variables en minuscules, mots séparés par _ (nb_essais, afficher_mot). Les valeurs qui ne changent jamais, comme la liste des mots du jeu, s'écrivent en MAJUSCULES : MOTS. Évite les noms d'une lettre l, O et I, qu'on confond avec 1 et 0.

2. Une docstring : une phrase entre triples guillemets """…""", juste sous la ligne def, qui dit ce que fait la fonction. Python la garde : help(afficher_mot) l'affiche.

3. Des commentaires utiles. Un commentaire (#) explique pourquoi, pas quoi : # 6 erreurs permises, comme au pendu classique est utile ; # on ajoute 1 au-dessus de erreurs = erreurs + 1 répète le code. Et un commentaire faux est pire que pas de commentaire.

4. La mise en page : 4 espaces par niveau de décalage ; deux lignes vides autour de chaque fonction ; les import tout en haut ; une espace autour de = et après chaque virgule (a = f(1, 2)).

« La relecture en 3 passes »

Rappels : une tâche, une fonction (voir épisode 12) ; noms, docstrings et commentaires (voir épisode 13).

1. Passe 1, les noms : chaque variable et chaque fonction dit-elle ce qu'elle contient ou ce qu'elle fait ?
2. Passe 2, le découpage : chaque tâche est-elle dans sa propre fonction ? Une fonction fait-elle une seule chose ?
3. Passe 3, les explications : chaque fonction a-t-elle sa docstring ? Les commentaires disent-ils pourquoi ?

Le mot mystère, version rangée : cinq fonctions et une liste fixe en majuscules.

import random

MOTS = ["chat", "python", "robot", "lune", "pirate"]


def choisir_mot(mots):
    """Tire un mot au hasard dans la liste."""
    return random.choice(mots)


def afficher_mot(mot, proposees):
    """Renvoie le mot avec un tiret à la place de chaque lettre pas encore trouvée."""
    affichage = ""
    for lettre in mot:
        if lettre in proposees:
            affichage = affichage + lettre + " "
        else:
            affichage = affichage + "_ "
    return affichage.strip()


def demander_lettre(proposees):
    """Demande une lettre jusqu'à ce qu'elle soit nouvelle, puis la renvoie."""
    lettre = input("Propose une lettre : ").strip().lower()
    while lettre in proposees:
        print("Tu as déjà proposé cette lettre !")
        lettre = input("Propose une lettre : ").strip().lower()
    return lettre


def mot_trouve(mot, proposees):
    """Renvoie True si toutes les lettres du mot ont été proposées."""
    for lettre in mot:
        if lettre not in proposees:
            return False
    return True


def jouer():
    """Joue une partie du mot mystère, avec 6 erreurs permises."""
    mot = choisir_mot(MOTS)
    proposees = []
    erreurs = 0
    while erreurs < 6:
        print(afficher_mot(mot, proposees))
        lettre = demander_lettre(proposees)
        proposees.append(lettre)
        if lettre in mot:
            print("Bien vu !")
            if mot_trouve(mot, proposees):
                print(f"Gagné ! Le mot était {mot}.")
                return
        else:
            erreurs = erreurs + 1
            print(f"Raté ! Erreurs : {erreurs} sur 6")
    print(f"Perdu ! Le mot était {mot}.")


jouer()

Deux nouveautés à remarquer :

• not in veut dire « n'est pas dans » : c'est le contraire de in.
• Dans mot_trouve, dès qu'une lettre manque, return False fait sortir de la fonction ; si la boucle arrive au bout, toutes les lettres sont là : return True. Dans jouer, return sert à terminer la partie dès qu'on a gagné (voir épisode 11).

Essai réel, quand le mot tiré est « robot », avec r, r, z, x, o, b, t :

Avec six lettres absentes à la suite, la partie se termine par Perdu ! Le mot était robot. (testé aussi).

Chaque passe ne cherche qu'une sorte de problème : on en rate moins qu'en voulant tout vérifier à la fois. Et une fonction qui ne fait qu'une chose se lit d'un coup d'œil : jouer se lit presque comme une phrase. C'est l'idée de départ de la PEP 8 : le code est lu bien plus souvent qu'il n'est écrit [1].

Bon réflexe ou piège ?

« Faut-il une fonction ? »

🎨 Carrousel récapitulatif — Semaine 3

Les bugs silencieux

Tu sais lire une erreur qui s'affiche (voir Boost, épisode 2). Mais beaucoup de bugs ne s'affichent pas : le programme tourne, et donne un mauvais résultat. On les appelle des bugs silencieux. Pour les trouver, on enquête en quatre gestes.

1. Reproduire : trouve une situation précise où le bug apparaît à chaque fois (« avec les lettres z, x et w, le compteur reste à 0 »).

2. Afficher : ajoute des print de contrôle pour voir ce que valent les variables pendant que le programme tourne.

erreurs = 0
for lettre in ["z", "x", "w"]:
    if lettre not in "robot":
        erreurs + 1
    print(f"CONTRÔLE lettre={lettre} erreurs={erreurs}")
print(erreurs)

Affiche :

Le contrôle montre que erreurs ne change jamais, même quand la lettre est absente. Le coupable est donc la ligne qui devrait l'augmenter : erreurs + 1 calcule 1, mais ne range rien. Il fallait écrire erreurs = erreurs + 1. Corrigé, le programme affiche 3.

3. Isoler : quand un grand programme cache un bug, recopie la plus petite partie qui le montre encore (ici, 5 lignes au lieu de 60). Moins il y a de code, plus le bug se voit.

4. Expliquer à voix haute : raconte ton programme, ligne par ligne, à quelqu'un… ou à un objet posé sur ton bureau. En disant « ici, j'ajoute 1 à erreurs », tu entends que le code ne le fait pas. Les programmeurs appellent ça la méthode du canard en plastique.

N'oublie pas de retirer tes print de contrôle quand le bug est corrigé : ils ne sont pas faits pour les joueurs.

« Reproduire, afficher, isoler, corriger, retester »

Rappel en une phrase : un bug silencieux se trouve en reproduisant, en affichant et en isolant (voir épisode 16).

1. Reproduire : joue avec des entrées précises et note ce qui ne va pas (« avec z, le jeu dit Bien vu ! »).
2. Afficher : ajoute un print de contrôle dans la fonction concernée.
3. Isoler : trouve la ligne exacte.
4. Corriger : une seule ligne à la fois.
5. Retester : rejoue la même partie pour vérifier.

Le jeu piégé : c'est le mot mystère de l'épisode 14, dans lequel quatre lignes ont été modifiées.

Code à copier (le jeu piégé)

import random

MOTS = ["chat", "python", "robot", "lune", "pirate"]


def choisir_mot(mots):
    """Tire un mot au hasard dans la liste."""
    return random.choice(mots)


def afficher_mot(mot, proposees):
    """Renvoie le mot avec un tiret à la place de chaque lettre pas encore trouvée."""
    affichage = ""
    for lettre in mot:
        if lettre in proposees:
            affichage = affichage + lettre + " "
        else:
            affichage = affichage + "_ "
    return affichage.strip()


def demander_lettre(proposees):
    """Demande une lettre jusqu'à ce qu'elle soit nouvelle, puis la renvoie."""
    lettre = input("Propose une lettre : ").strip()
    while lettre in proposees:
        print("Tu as déjà proposé cette lettre !")
        lettre = input("Propose une lettre : ").strip().lower()
    return lettre


def mot_trouve(mot, proposees):
    """Renvoie True si toutes les lettres du mot ont été proposées."""
    for lettre in mot:
        if lettre not in proposees:
            return False
    return True


def jouer():
    """Joue une partie du mot mystère, avec 6 erreurs permises."""
    mot = choisir_mot(MOTS)
    proposees = []
    erreurs = 0
    while erreurs <= 6:
        print(afficher_mot(mot, proposees))
        lettre = demander_lettre(proposees)
        proposees.append(lettre)
        if lettre not in mot:
            print("Bien vu !")
            if mot_trouve(mot, proposees):
                print(f"Gagné ! Le mot était {mot}.")
                return
        else:
            erreurs + 1
            print(f"Raté ! Erreurs : {erreurs} sur 6")
    print(f"Perdu ! Le mot était {mot}.")


jouer()

Ce que voient les testeurs (essais réels, mot tiré : « robot ») :

• Avec z, x, w… : le jeu répond « Bien vu ! » à chaque fois, et la partie ne s'arrête jamais.
• Avec R, o, b, t : R est accueilli par « Bien vu ! » sans être révélé ; les bonnes lettres affichent « Raté ! Erreurs : 0 sur 6 ».

Les quatre bugs (corrigé, à ne lire qu'après avoir cherché) :

1. Condition inversée dans jouer : if lettre not in mot: au lieu de if lettre in mot:. Les bonnes et les mauvaises lettres sont échangées.
2. Compteur jamais augmenté : erreurs + 1 au lieu de erreurs = erreurs + 1 (comme lundi). La partie ne peut jamais être perdue.
3. lower oublié dans la première ligne de demander_lettre : R majuscule n'est jamais égal à r. La deuxième ligne, elle, a bien .lower() : un bug peut se cacher dans une ligne presque identique à une ligne juste.
4. Un tour de trop : while erreurs <= 6: laisserait 7 erreurs au lieu de 6. On ne le voit qu'une fois les trois autres bugs corrigés : c'est pour cela qu'on reteste après chaque correction.

Le bug 4 montre pourquoi on corrige une chose à la fois et on reteste à chaque fois : certains bugs en cachent d'autres. Tant que le compteur ne bougeait pas, impossible de voir qu'il comptait un tour de trop. La méthode transforme une chasse au hasard en enquête où chaque étape réduit l'endroit où chercher.

Bon réflexe ou piège ?

Le débogueur

Un débogueur est un outil qui exécute ton programme pas à pas et te montre ses variables pendant qu'il tourne. Tu n'as rien à ajouter dans ton code.

Dans Thonny (logiciel installé par un adulte, voir Boost, épisode 2) :

Pas besoin de point d'arrêt : Thonny démarre au début et tu avances à ton rythme. Quand une fonction est appelée et que tu avances à petits pas, Thonny ouvre une fenêtre à part pour cette fonction, avec ses propres variables locales (voir épisode 11).

Exemple à suivre pas à pas

mot = "lune"
affichage = ""
for lettre in mot:
    affichage = affichage + lettre.upper()
print(affichage)

Affiche LUNE. Au pas à pas, la vue « Variables » montre lettre qui vaut "l", "u", "n", "e", et affichage qui devient "L", "LU", "LUN", "LUNE".

Sans Thonny ? Les environnements en ligne n'ont pas tous de débogueur. Tu peux alors utiliser les print de contrôle (épisode 16), ou le widget « Suivre les variables » de ce livre pour t'entraîner à lire un programme pas à pas.

Le plan de test

Rappels : la méthode de chasse aux bugs (voir épisodes 16 et 17) ; le jeu rangé en fonctions (voir épisode 14).

Un plan de test est une liste de parties à jouer, chacune avec ce qu'on tape et ce qu'on attend. On joue chaque partie et on coche : obtenu = attendu ?

Ce que la partie 5 révèle : avec la version de l'épisode 14, une saisie vide et ro sont acceptées. Essai réel, mot « robot » :

Pourquoi ? Pour Python, le texte vide "" est « dans » tous les mots, et "ro" est bien dans "robot" : "" in "robot" et "ro" in "robot" valent tous les deux True (vérifié).

La correction : une fonction qui vérifie qu'on a tapé une seule lettre, jamais proposée.

def lettre_valide(lettre, proposees):
    """Renvoie True si c'est une seule lettre, jamais proposée ; sinon explique pourquoi."""
    if len(lettre) != 1:
        print("Tape une seule lettre !")
        return False
    if lettre in proposees:
        print("Tu as déjà proposé cette lettre !")
        return False
    return True


def demander_lettre(proposees):
    """Demande une lettre jusqu'à ce qu'elle soit valide, puis la renvoie."""
    lettre = input("Propose une lettre : ").strip().lower()
    while not lettre_valide(lettre, proposees):
        lettre = input("Propose une lettre : ").strip().lower()
    return lettre

not veut dire « le contraire de » : while not lettre_valide(...) se lit « tant que la lettre n'est pas valide ». C'est le même not que dans not in (voir épisode 14).

Celui qui écrit un programme le teste avec les entrées auxquelles il pense ; les joueurs, eux, tapent tout le reste. Un plan de test écrit d'avance oblige à essayer les cas bizarres, pas seulement ceux où tout va bien. Et il se rejoue à l'identique après chaque correction : c'est ce qui a permis de vérifier que lettre_valide ne cassait rien.

Bon réflexe ou piège ?