Mon projet de jeu de A à Z — 4 mois pour créer, documenter et transmettre « Attrape-lettres »

Le dictionnaire, un rangement par étiquettes

Une liste range des valeurs par numéro (indice 0, 1, 2… voir Pro, épisode 6). Un dictionnaire les range par étiquette : chaque valeur est rangée sous une clé. On l'écrit entre accolades, avec des paires clé: valeur séparées par des virgules.

scores = {"Pixel": 9, "Lynx": 7}
print(scores["Pixel"])
scores["Comete"] = 4
scores["Lynx"] = 8
print(scores)
print(len(scores))
print("Nova" in scores)
for pseudo, score in scores.items():
    print(f"{pseudo} : {score}")
print(scores.get("Nova", 0))

Affiche :

Une clé est unique. Écrire scores["Lynx"] = 8 alors que "Lynx" existe déjà remplace l'ancienne valeur : il n'y a jamais deux « Lynx ».

Si la clé n'existe pas, scores["Nova"] arrête le programme avec une erreur que tu sais lire (voir Boost, épisode 2) :

Key = clé. Pour éviter cette erreur, on vérifie avec in, ou on lit avec .get(clé, valeur par défaut).

« Le compteur à étiquettes »

Rappel en une phrase : un dictionnaire range des valeurs sous des clés, et .get(clé, 0) lit une valeur sans erreur si la clé n'existe pas encore (voir épisode 1).

1. Crée un dictionnaire vide : compteur = {}.
2. Pour chaque élément, ajoute 1 à son compteur : compteur[x] = compteur.get(x, 0) + 1. La première fois, get donne 0, donc le compteur passe à 1.
3. Affiche le résultat avec .items() et une f-string.

Compter les lettres d'un mot

mot = "attrape"
compteur = {}
for lettre in mot:
    compteur[lettre] = compteur.get(lettre, 0) + 1
print(compteur)
for lettre, nombre in compteur.items():
    print(f"{lettre} : {nombre}")

Affiche {'a': 2, 't': 2, 'r': 1, 'p': 1, 'e': 1}, puis une ligne par lettre.

Compter les parties de chaque joueur

joueurs = ["Pixel", "Lynx", "Pixel", "Comete", "Pixel", "Lynx"]
parties = {}
for pseudo in joueurs:
    parties[pseudo] = parties.get(pseudo, 0) + 1
print(parties)

Affiche {'Pixel': 3, 'Lynx': 2, 'Comete': 1}.

Garder le meilleur score de chaque joueur : au lieu d'ajouter 1, on ne remplace la valeur que si le nouveau score est meilleur.

def enregistrer(meilleurs, pseudo, score):
    """Garde le meilleur score de chaque pseudo."""
    if pseudo not in meilleurs or score > meilleurs[pseudo]:
        meilleurs[pseudo] = score


meilleurs = {}
enregistrer(meilleurs, "Pixel", 6)
enregistrer(meilleurs, "Lynx", 8)
enregistrer(meilleurs, "Pixel", 9)
enregistrer(meilleurs, "Lynx", 5)
print(meilleurs)

Affiche {'Pixel': 9, 'Lynx': 8} : le 9 de Pixel a remplacé son 6, mais le 5 de Lynx n'a pas remplacé son 8. or veut dire « ou » : on enregistre si le joueur est nouveau ou si son score est meilleur. La fonction modifie directement le dictionnaire qu'on lui donne : elle n'a pas besoin de return.

Le dictionnaire fait le travail de tri à ta place : chaque joueur a sa propre case, retrouvée par son pseudo, et personne ne peut se retrouver avec le score d'un autre. C'est exactement le problème des deux listes de mardi. La méthode get avec une valeur par défaut, décrite dans le tutoriel officiel, évite de devoir tester à chaque fois si la clé existe déjà [1].

Bon réflexe ou piège ?

Grouper et combiner

Le tuple : des valeurs qui vont ensemble. Un tuple groupe quelques valeurs, entre parenthèses, séparées par des virgules. On le lit comme une liste, par indice.

position = (40, 100)
print(position[0])
x, y = position
print(x, y)
lettres = [("A", 40, 0), ("T", 90, 20)]
for caractere, x, y in lettres:
    print(f"{caractere} en ({x}, {y})")

Affiche 40, puis 40 100, puis A en (40, 0) et T en (90, 20).

• x, y = position déballe le tuple : chaque valeur part dans sa variable. Il faut autant de variables que de valeurs.
• Une boucle peut déballer chaque tuple d'une liste : for caractere, x, y in lettres:.

Un tuple ne se modifie pas.

position = (40, 100)
position[0] = 50

Python s'arrête avec : TypeError: 'tuple' object does not support item assignment. Pour changer de position, on crée un nouveau tuple : position = (50, 100).

Combiner listes et dictionnaires. Les boîtes peuvent se ranger les unes dans les autres.

fiche = {"pseudo": "Pixel", "score": 9, "niveau": "facile"}
print(fiche["score"])
joueurs = [
    {"pseudo": "Pixel", "score": 9, "niveau": "facile"},
    {"pseudo": "Lynx", "score": 7, "niveau": "moyen"},
]
for joueur in joueurs:
    print(f"{joueur['pseudo']} ({joueur['niveau']}) : {joueur['score']}")
mots = {"facile": ["chat", "lune"], "difficile": ["pirate", "python"]}
print(mots["difficile"][0])

Affiche 9, puis Pixel (facile) : 9 et Lynx (moyen) : 7, puis pirate.

• Une fiche : un dictionnaire qui décrit une chose (un joueur) avec plusieurs informations.
• Une liste de fiches : tous les joueurs.
• Un dictionnaire de listes : les mots rangés par niveau. mots["difficile"][0] se lit de gauche à droite : la liste du niveau difficile, puis son premier mot.

Attention aux guillemets : dans une f-string entre guillemets doubles, on écrit la clé entre guillemets simples (joueur['pseudo']).

« Dessiner ses données avant de les coder »

Rappels : tuples, fiches et dictionnaires de listes (voir épisode 3) ; dictionnaires (voir épisode 1) ; tirage au hasard (voir Pro, épisode 8).

1. Liste ce que le jeu doit retenir : les mots, classés par niveau ; les joueurs, avec leur nombre de parties et leur meilleur score.
2. Pour chaque chose, choisis la boîte : plusieurs du même genre → liste ; une chose décrite par plusieurs informations → fiche (dictionnaire) ; un rangement par étiquette → dictionnaire.
3. Dessine : une boîte par conteneur, les étiquettes écrites sur les compartiments.
4. Code en suivant le dessin, puis affiche pour vérifier.

Les données qui ne changent pas pendant le jeu s'écrivent en majuscules (voir Pro, épisode 13).

import random

MOTS_PAR_NIVEAU = {
    "facile": ["chat", "lune", "robot"],
    "moyen": ["pirate", "python", "fusee"],
    "difficile": ["dinosaure", "astronaute", "labyrinthe"],
}
JOUEURS = [
    {"pseudo": "Pixel", "parties": 5, "meilleur": 9},
    {"pseudo": "Lynx", "parties": 8, "meilleur": 7},
    {"pseudo": "Comete", "parties": 2, "meilleur": 4},
]

niveau = input("Niveau (facile, moyen, difficile) ? ").strip().lower()
if niveau in MOTS_PAR_NIVEAU:
    mot = random.choice(MOTS_PAR_NIVEAU[niveau])
    print(f"Mot tiré : {mot} ({len(mot)} lettres)")
else:
    print("Ce niveau n'existe pas.")
print(f"{len(JOUEURS)} joueurs inscrits.")

Essai réel avec moyen (le mot change à chaque lancement) :

Avec ␣␣Facile␣, le niveau est reconnu grâce à .strip().lower() ; avec expert, le programme répond Ce niveau n'existe pas. au lieu de s'arrêter sur une KeyError, grâce au test in.

Le dessin oblige à choisir chaque boîte avant d'écrire une ligne : on voit tout de suite qu'un joueur a plusieurs informations (une fiche) et qu'il y a plusieurs joueurs (une liste de fiches). Les erreurs de structure se corrigent sur papier, gratuitement. Le test in avant de lire une clé évite l'arrêt du programme quand le joueur tape un niveau qui n'existe pas.

Bon réflexe ou piège ?

Trois recherches à connaître par cœur

Chercher dans des données, c'est toujours la même idée : parcourir (avec for, voir Pro, épisode 1) et comparer. Trois recherches reviennent sans arrêt.

1. Chercher un élément : on s'arrête dès qu'on l'a trouvé.

def chercher_joueur(fiches, pseudo):
    """Renvoie la fiche du pseudo, ou None s'il n'existe pas."""
    for fiche in fiches:
        if fiche["pseudo"] == pseudo:
            return fiche
    return None

return sort de la fonction dès que la fiche est trouvée (voir Pro, épisode 11). Si la boucle va jusqu'au bout sans rien trouver, la fonction renvoie None.

2. Chercher le plus grand : on garde le meilleur vu jusqu'ici.

def meilleur_score(fiches):
    """Renvoie le plus grand score de la liste, ou None si elle est vide."""
    if len(fiches) == 0:
        return None
    meilleur = fiches[0]["meilleur"]
    for fiche in fiches:
        if fiche["meilleur"] > meilleur:
            meilleur = fiche["meilleur"]
    return meilleur

On part du premier score, puis on le remplace à chaque fois qu'on rencontre plus grand. Une liste vide n'a pas de plus grand élément : on le prévoit avant la boucle.

3. Compter : on ajoute 1 à chaque élément qui vérifie la condition.

def compter_actifs(fiches, minimum):
    """Compte les joueurs qui ont joué au moins `minimum` parties."""
    nombre = 0
    for fiche in fiches:
        if fiche["parties"] >= minimum:
            nombre = nombre + 1
    return nombre

Avec les trois joueurs de l'épisode 4 : chercher_joueur(JOUEURS, "Lynx") renvoie la fiche de Lynx, chercher_joueur(JOUEURS, "Nova") renvoie None, meilleur_score(JOUEURS) renvoie 9, meilleur_score([]) renvoie None et compter_actifs(JOUEURS, 5) renvoie 2 (sorties vérifiées).

Les raccourcis de Python. Pour une simple liste de nombres, Python a déjà ces outils : max, min et sum.

scores = [9, 7, 4]
print(max(scores), min(scores), sum(scores))

Affiche 9 4 20. Mais max([]) sur une liste vide s'arrête avec ValueError: max() iterable argument is empty. Savoir écrire la recherche toi-même te permet de chercher dans des fiches, de choisir ce qu'on renvoie quand c'est vide, et de comprendre ce que fait max.

« Une recherche, trois questions »

Rappel en une phrase : chercher, c'est parcourir et comparer ; on trouve un élément, le plus grand, ou on compte (voir épisode 5).

Avant d'écrire une recherche, réponds à trois questions :

1. Que cherche-t-on ? (un élément, le plus grand, un nombre)
2. Que garde-t-on en mémoire pendant le parcours ? (le meilleur vu jusqu'ici, un compteur)
3. Que renvoie-t-on si la liste est vide ou si rien n'est trouvé ? (None, 0…)

def mot_plus_long(mots):
    """Renvoie le mot le plus long (le premier en cas d'égalité), ou None."""
    if len(mots) == 0:
        return None
    plus_long = mots[0]
    for mot in mots:
        if len(mot) > len(plus_long):
            plus_long = mot
    return plus_long


def plus_actif(fiches):
    """Renvoie le pseudo qui a joué le plus de parties, ou None."""
    if len(fiches) == 0:
        return None
    meilleure = fiches[0]
    for fiche in fiches:
        if fiche["parties"] > meilleure["parties"]:
            meilleure = fiche
    return meilleure["pseudo"]


def compter_gagnees(resultats):
    """Compte les parties gagnées dans une liste de résultats."""
    nombre = 0
    for resultat in resultats:
        if resultat == "gagné":
            nombre = nombre + 1
    return nombre

Tests réels :

• mot_plus_long(["chat", "pirate", "python", "lune"]) → pirate (à égalité avec « python », le premier rencontré est gardé, car on compare avec >).
• mot_plus_long([]) → None.
• plus_actif(...) avec Pixel (5 parties) et Lynx (8 parties) → Lynx ; avec une liste vide → None.
• compter_gagnees(["gagné", "perdu", "gagné", "gagné"]) → 3 ; avec une liste vide → 0.

Dans plus_actif, on garde la fiche entière en mémoire, pour pouvoir renvoyer son pseudo à la fin.

La troisième question vise le cas qu'on oublie toujours : la liste vide, ou l'élément introuvable. C'est le premier cas de ton plan de test (voir Pro, épisode 19). Et le choix entre > et >= décide de qui gagne en cas d'égalité : avec >, le premier rencontré reste ; avec >=, ce serait le dernier. La documentation de max fait le même choix : en cas d'égalité, le premier rencontré [1].

Bon réflexe ou piège ?

Trier

Le tri par sélection, à la main. Pour ranger du plus petit au plus grand :

1. cherche le plus petit élément de la partie pas encore rangée ;
2. échange-le avec le premier élément de cette partie ;
3. la partie rangée a grandi d'une case : recommence sur le reste.

Avec 7, 3, 9, 1, 6, 4 (étapes réelles) :

En Python, c'est une recherche du plus petit (voir épisode 5) répétée :

def tri_selection(liste):
    """Renvoie une copie de la liste, triée du plus petit au plus grand."""
    nombres = list(liste)
    for debut in range(len(nombres)):
        position_min = debut
        for i in range(debut + 1, len(nombres)):
            if nombres[i] < nombres[position_min]:
                position_min = i
        nombres[debut], nombres[position_min] = nombres[position_min], nombres[debut]
    return nombres


scores = [7, 3, 9, 1, 6, 4]
print(tri_selection(scores))
print(scores)

Affiche [1, 3, 4, 6, 7, 9], puis [7, 3, 9, 1, 6, 4] : la liste d'origine n'a pas bougé, car on a travaillé sur une copie (list(liste)). La ligne de l'échange utilise le déballage de tuples (voir épisode 3) : les deux valeurs sont lues, puis rangées à la place l'une de l'autre.

Trier avec Python. Dans tes programmes, tu utiliseras l'outil tout prêt :

print(sorted(scores))
print(sorted(scores, reverse=True))

Affiche [1, 3, 4, 6, 7, 9], puis [9, 7, 6, 4, 3, 1]. reverse=True trie du plus grand au plus petit.

sorted ou .sort() ?

scores = [7, 3, 9]
resultat = scores.sort()
print(resultat)
print(scores)

Affiche None, puis [3, 7, 9]. sorted(liste) renvoie une nouvelle liste et ne touche pas l'originale ; liste.sort() modifie la liste et ne renvoie rien. Écrire resultat = scores.sort() est donc un piège.

Trier des tuples. Python compare deux tuples élément par élément : d'abord le premier, et seulement en cas d'égalité, le suivant.

resultats = [(7, "Lynx"), (9, "Pixel"), (4, "Comete"), (9, "Nova")]
print(sorted(resultats, reverse=True))

Affiche [(9, 'Pixel'), (9, 'Nova'), (7, 'Lynx'), (4, 'Comete')]. Les scores sont bien classés. Pour les deux 9, Python compare les pseudos, et comme on trie à l'envers, « Pixel » passe avant « Nova » (P vient après N dans l'alphabet). Mettre le score en premier dans le tuple, c'est ce qui fait trier par score.

« Liste, dictionnaire ou tuple ? »

🎨 Carrousel récapitulatif — Arc 1

La classe et ses objets

Une classe est un plan : elle décrit ce qu'aura chaque objet fabriqué à partir d'elle. Un objet est un exemplaire fabriqué d'après ce plan. Comme les clones d'un lutin dans Scratch : même modèle, mais chacun sa position.

class Robot:
    def __init__(self, x):
        self.x = x
        self.vies = 3
        self.score = 0


robot1 = Robot(40)
robot2 = Robot(100)
robot1.x = robot1.x + 5
robot2.vies = robot2.vies - 1
print(robot1.x, robot1.vies)
print(robot2.x, robot2.vies)

Affiche 45 3, puis 100 2.

• class Robot: commence la définition de la classe. Le nom d'une classe s'écrit avec une majuscule à chaque mot (Robot, JeuDeLettres), contrairement aux fonctions et aux variables (voir Pro, épisode 13).
• __init__ (deux tirets bas de chaque côté) est une fonction spéciale de la classe : Python l'appelle automatiquement à chaque fois qu'on fabrique un objet. C'est là qu'on donne à l'objet ses valeurs de départ.
• self désigne l'objet en train d'être fabriqué. self.x = x veut dire : « range la valeur reçue dans l'attribut x de cet objet ».
• Robot(40) fabrique un objet : Python appelle __init__ avec x = 40. Les parenthèses fonctionnent comme un appel de fonction (voir Pro, épisode 11).
• robot1.x se lit « l'attribut x de robot1 ». Chaque objet a ses propres attributs : modifier robot1.x ne change pas robot2.x.

Le piège du self oublié.

class Robot:
    def __init__(self, x):
        x = x
        self.vies = 3


robot = Robot(40)
print(robot.x)

Python s'arrête avec : AttributeError: 'Robot' object has no attribute 'x'. La ligne x = x range la valeur dans une variable locale de __init__ (voir Pro, épisode 11), qui disparaît à la fin de l'appel : l'objet, lui, n'a jamais reçu d'attribut x. Attribute = attribut.

« De la fiche à la classe »

Rappel en une phrase : une classe est un plan, __init__ donne à chaque objet ses attributs self.… (voir épisode 9).

1. Écris la fiche de l'objet, comme à l'arc 1 : quelles étiquettes ?
2. Chaque étiquette devient un attribut dans __init__. Ce qui change d'un objet à l'autre devient un paramètre ; ce qui est pareil pour tous au départ reçoit une valeur fixe.
3. Fabrique les objets et range-les, si besoin, dans une liste.
4. Affiche leurs attributs pour vérifier.

import random

LARGEUR = 160
ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"


class Robot:
    def __init__(self, x):
        self.x = x
        self.y = 108
        self.largeur = 16
        self.hauteur = 8
        self.vies = 3
        self.score = 0


class Lettre:
    def __init__(self, caractere, x, y, vitesse):
        self.caractere = caractere
        self.x = x
        self.y = y
        self.vitesse = vitesse


robot = Robot(72)
lettres = []
for i in range(5):
    caractere = random.choice(ALPHABET)
    x = random.randint(0, LARGEUR - 4)
    lettres.append(Lettre(caractere, x, 0, random.randint(1, 3)))
print(f"Robot en x = {robot.x}, {robot.vies} vies")
for lettre in lettres:
    print(f"{lettre.caractere} en ({lettre.x}, {lettre.y}), vitesse {lettre.vitesse}")

Essai réel (les lettres changent à chaque lancement) :

Le robot a 6 attributs mais un seul paramètre, x : ses vies, son score et sa taille sont les mêmes au départ pour tous les robots. random.choice marche aussi sur une chaîne : il tire un de ses caractères (voir Pro, épisode 8).

Une fiche et un objet décrivent la même chose : un ensemble d'informations sur une seule chose. Mais l'objet pourra aussi, dès la semaine prochaine, faire des choses (se déplacer, tomber), ce qu'une fiche ne sait pas. Le tutoriel officiel le dit : les attributs d'un objet lui sont propres et existent dès qu'on leur donne une valeur [1]. Partir de ta fiche évite d'oublier un attribut.

Bon réflexe ou piège ?

Les méthodes

Une méthode est une fonction rangée dans la classe. Elle travaille sur l'objet qui l'exécute, grâce à self.

LARGEUR = 160
HAUTEUR = 120


class Robot:
    def __init__(self, x):
        self.x = x
        self.largeur = 16

    def deplacer(self, dx):
        """Déplace le robot de dx pixels, sans sortir de l'écran."""
        self.x = self.x + dx
        if self.x < 0:
            self.x = 0
        if self.x > LARGEUR - self.largeur:
            self.x = LARGEUR - self.largeur


class Lettre:
    def __init__(self, caractere, x, vitesse):
        self.caractere = caractere
        self.x = x
        self.y = 0
        self.vitesse = vitesse

    def tomber(self):
        """Fait descendre la lettre de sa vitesse."""
        self.y = self.y + self.vitesse

    def est_tombee(self):
        """Renvoie True si la lettre est sortie par le bas de l'écran."""
        return self.y > HAUTEUR


robot = Robot(140)
robot.deplacer(10)
print(robot.x)
robot.deplacer(-50)
print(robot.x)
lettre = Lettre("A", 30, 50)
lettre.tomber()
lettre.tomber()
print(lettre.y, lettre.est_tombee())
lettre.tomber()
print(lettre.y, lettre.est_tombee())

Affiche 144, puis 94, puis 100 False, puis 150 True.

• Une méthode se définit avec def, décalée dans la classe, et son premier paramètre est self.
• On l'appelle avec un point : robot.deplacer(10). Python donne tout seul l'objet robot comme self ; on ne fournit que les autres paramètres (dx = 10).
• Une méthode peut modifier l'objet (deplacer, tomber) ou renvoyer une valeur (est_tombee), comme une fonction (voir Pro, épisode 11).
• Dans deplacer, le robot part de 140 et avance de 10 : il serait à 150, mais l'écran fait 160 pixels et le robot 16 de large, donc il s'arrête à 144. C'est l'objet qui veille lui-même à ne pas sortir de l'écran.

« Tester un objet seul »

Rappel en une phrase : une méthode est une fonction de la classe, appelée avec un point (voir épisode 11).

1. Fabrique un seul objet, avec des valeurs faciles à suivre (ici, une vitesse de 40 pour voir la lettre sortir vite).
2. Appelle ses méthodes dans une boucle, comme le fera le jeu.
3. Affiche ses attributs à chaque tour (c'est le « tester chaque fonction seule » du Pro, voir Pro, épisode 12).
4. Compare avec ce que tu attendais.

import random

HAUTEUR = 120
LARGEUR = 160


class Lettre:
    def __init__(self, caractere, x, vitesse):
        self.caractere = caractere
        self.x = x
        self.y = 0
        self.vitesse = vitesse

    def tomber(self):
        """Fait descendre la lettre de sa vitesse."""
        self.y = self.y + self.vitesse

    def est_tombee(self):
        """Renvoie True si la lettre est sortie par le bas de l'écran."""
        return self.y > HAUTEUR

    def repartir(self, caractere):
        """Remet la lettre en haut, à une place au hasard, avec un nouveau caractère."""
        self.caractere = caractere
        self.x = random.randint(0, LARGEUR - 4)
        self.y = 0


lettre = Lettre("A", 30, 40)
for tour in range(1, 11):
    lettre.tomber()
    if lettre.est_tombee():
        lettre.repartir("B")
    print(f"tour {tour} : {lettre.caractere} en y = {lettre.y}")

Affiche (sortie réelle) :

Au tour 3, la lettre est à 120 : elle touche le bord sans être sortie (> et non >=). Au tour 4, elle descend à 160, sort, et repart aussitôt en haut avec le caractère « B ».

Dans un jeu, l'écran se redessine environ 30 fois par seconde : une erreur de position passe inaperçue. Dans la console, chaque tour s'affiche sur sa ligne, et on peut vérifier les valeurs une par une, comme avec le débogueur (voir Pro, épisode 18). Un objet qui marche seul marchera dans le jeu.

Bon réflexe ou piège ?

Pyxel et la boucle de jeu

Pyxel est une bibliothèque de jeu pour Python : un module qui sait ouvrir une fenêtre, dessiner, lire le clavier et jouer des sons. Il imite les vieilles consoles : petit écran, 16 couleurs.

Où l'utiliser ? Sans rien installer toi-même :

• au collège, dans l'activité Pyxel Studio de Capytale, si ton professeur la propose (accès par l'ENT) ;
• à la maison, dans Thonny, si un adulte installe Pyxel (menu Outils → Gérer les paquets ; Tools → Manage packages dans la version anglaise).

L'écran en pixels. L'écran d'Attrape-lettres mesure 160 pixels de large et 120 de haut. Chaque point a des coordonnées (x, y) :

• x va de 0 (à gauche) à 159 (à droite) ;
• y va de 0 (en haut) à 119 (en bas). Attention : y grandit vers le bas, contrairement aux repères de maths.

La boucle de jeu. Un jeu vidéo n'est pas un film : environ 30 fois par seconde, il recalcule tout (update), puis redessine tout (draw). Ce qui bouge, c'est un objet dont les attributs changent un peu à chaque image.

Le premier programme, écrit avec une classe Jeu, comme les exemples officiels de Pyxel :

import pyxel


class Jeu:
    def __init__(self):
        pyxel.init(160, 120, title="Attrape-lettres")
        self.robot_x = 72
        pyxel.run(self.update, self.draw)

    def update(self):
        pass

    def draw(self):
        pyxel.cls(pyxel.COLOR_NAVY)
        pyxel.rect(self.robot_x, 108, 16, 8, pyxel.COLOR_LIME)
        pyxel.text(40, 20, "A", pyxel.COLOR_YELLOW)
        pyxel.text(5, 5, "Attrape-lettres", pyxel.COLOR_WHITE)


Jeu()

• pass veut dire « ne rien faire » : update n'a encore rien à calculer.
• self.update est donné sans parenthèses à pyxel.run : on ne l'appelle pas, on dit à Pyxel quelle méthode appeler à chaque image.
• La police de Pyxel n'a pas d'accents : « é » ne s'affiche pas (testé). Dans le jeu, on écrit « GAGNE » et « C'etait ».
• Pourquoi une classe Jeu ? Les objets du jeu (le robot, les lettres) deviennent ses attributs (self.robot), et update et draw peuvent tous les utiliser.

« Calculer dans update, dessiner dans draw »

Rappels : la classe Robot et sa méthode deplacer (voir épisode 11) ; la boucle update / draw (voir épisode 13).

1. Dans __init__ du jeu : fabrique les objets (self.robot = Robot(72)), avant pyxel.run.
2. Dans update : lis le clavier et change les attributs. pyxel.btn(pyxel.KEY_LEFT) vaut True tant que la flèche gauche est enfoncée.
3. Dans draw : efface, puis demande à chaque objet de se dessiner (une méthode dessiner).
4. Teste : maintiens une flèche jusqu'au bord de l'écran ; le robot doit s'arrêter.

import pyxel

LARGEUR = 160
HAUTEUR = 120


class Robot:
    def __init__(self, x):
        self.x = x
        self.y = 108
        self.largeur = 16
        self.hauteur = 8

    def deplacer(self, dx):
        """Déplace le robot de dx pixels, sans sortir de l'écran."""
        self.x = self.x + dx
        if self.x < 0:
            self.x = 0
        if self.x > LARGEUR - self.largeur:
            self.x = LARGEUR - self.largeur

    def dessiner(self):
        """Dessine le robot à sa position."""
        pyxel.rect(self.x, self.y, self.largeur, self.hauteur, pyxel.COLOR_LIME)


class Jeu:
    def __init__(self):
        pyxel.init(LARGEUR, HAUTEUR, title="Attrape-lettres")
        self.robot = Robot(72)
        pyxel.run(self.update, self.draw)

    def update(self):
        if pyxel.btn(pyxel.KEY_LEFT):
            self.robot.deplacer(-2)
        if pyxel.btn(pyxel.KEY_RIGHT):
            self.robot.deplacer(2)

    def draw(self):
        pyxel.cls(pyxel.COLOR_NAVY)
        self.robot.dessiner()


Jeu()

Vérifié en simulant le clavier (Pyxel sans fenêtre) : flèche droite pendant 21 images puis flèche gauche pendant 30 images → le robot passe de 72 à 114, puis à 54. Flèche droite maintenue 200 images → il s'arrête à 144, au bord droit (160 − 16).

À 30 images par seconde, 2 pixels par image font 60 pixels par seconde : le robot traverse l'écran en un peu moins de 3 secondes.

Séparer « calculer » et « dessiner » garde chaque méthode simple : update ne dessine rien, draw ne change rien. Si le robot est mal placé, l'erreur est dans update ; s'il est bien placé mais mal dessiné, elle est dans draw. Et comme le robot sait lui-même se déplacer et se dessiner, le jeu se contente de lui demander. C'est la structure de tous les exemples officiels de Pyxel [1].

Bon réflexe ou piège ?

Les collisions et les règles du jeu

Deux rectangles se touchent-ils ? Le robot et chaque lettre occupent un rectangle (position du coin en haut à gauche, largeur, hauteur). Deux rectangles se chevauchent si, en même temps :

• le bord gauche de chacun est avant le bord droit de l'autre (sur l'axe des x) ;
• le bord du haut de chacun est avant le bord du bas de l'autre (sur l'axe des y).

def touche(a, b):
    """Renvoie True si les rectangles des objets a et b se chevauchent."""
    return (a.x < b.x + b.largeur and b.x < a.x + a.largeur
            and a.y < b.y + b.hauteur and b.y < a.y + a.hauteur)

and veut dire « et » : les quatre conditions doivent être vraies. Une longue condition peut être coupée sur deux lignes à l'intérieur des parenthèses. Comme touche lit seulement les attributs x, y, largeur et hauteur, elle marche pour le robot comme pour une lettre : il suffit que la lettre ait aussi self.largeur = 4 et self.hauteur = 6 (la taille d'un caractère).

Tests réels avec un robot en (70, 108) de 16 × 8, et une lettre de 4 × 6 :

Les règles d'Attrape-lettres, écrites dans update :

1. chaque lettre tombe ;
2. si elle touche le robot : bonne lettre du mot → elle est ajoutée aux lettres trouvées et le score augmente ; mauvaise lettre → une vie en moins ; dans les deux cas, elle repart en haut avec un nouveau caractère ;
3. si elle sort par le bas sans être attrapée : elle repart en haut ;
4. fin de partie : toutes les lettres du mot trouvées → gagné ; plus de vie → perdu. Un attribut self.etat ("jeu", "gagné", "perdu") le retient, et update ne fait plus rien quand la partie est finie.

Le nouveau caractère est tiré au hasard (voir Pro, épisode 8) : une fois sur deux, une lettre utile du mot, sinon n'importe quelle lettre. Les fonctions afficher_mot et mot_trouve du mot mystère resservent telles quelles (voir Pro, épisode 14).

Pour aller plus loin : la carte micro:bit. Si ton collège a des cartes micro:bit, tu peux programmer de petits jeux en MicroPython (une version de Python pour les cartes électroniques) avec l'éditeur officiel de la carte, dans le navigateur. Avec un adulte ou ton professeur.

« Où mettre ce code ? »

🎨 Carrousel récapitulatif — Arc 2

Les modules, ce sont aussi tes fichiers

Tu sais importer un module fourni avec Python, comme random (voir Pro, épisode 8). Bonne nouvelle : chaque fichier .py que tu écris est aussi un module. Son nom de module est le nom du fichier, sans .py.

Étape 1 : un fichier personnages.py, dans le même dossier que le jeu. On y déplace les classes Robot et Lettre et la fonction touche, sans rien changer.

import random

import pyxel

LARGEUR = 160
HAUTEUR = 120


class Robot:
    ...  # la classe Robot, copiée telle quelle depuis le jeu


class Lettre:
    ...  # la classe Lettre, copiée telle quelle


def touche(a, b):
    ...  # la fonction touche, copiée telle quelle

(Les ... remplacent ici le code déjà écrit à l'arc 2 : dans ton fichier, tu colles le vrai code.)

Étape 2 : l'utiliser. Deux façons d'importer :

import personnages

robot = personnages.Robot(140)
robot.deplacer(10)
print(robot.x)

Affiche 144. Avec import personnages, on écrit le nom du module, un point, puis ce qu'on veut : personnages.Robot, comme random.randint.

from personnages import Robot, Lettre

robot = Robot(72)
lettre = Lettre("A", 50, 40)
for tour in range(4):
    lettre.tomber()
print(robot.x, lettre.y, lettre.est_tombee())

Affiche 72 160 True. Avec from personnages import Robot, Lettre, on choisit les noms à importer, et on les écrit ensuite sans le nom du module.

Le piège : mélanger les deux.

import personnages

robot = Robot(72)

Python s'arrête avec : NameError: name 'Robot' is not defined. Avec import personnages, seul le nom personnages est connu : il faut écrire personnages.Robot.

Le début de jeu.py devient :

import random

import pyxel

from personnages import LARGEUR, HAUTEUR, Robot, Lettre, touche

ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOTS = ["CHAT", "LUNE", "ROBOT", "PIRATE"]

Le reste de jeu.py (les fonctions du mot mystère et la classe Jeu) ne change pas.

L'ordre des imports, en haut du fichier : d'abord les modules fournis avec Python (random), puis les bibliothèques ajoutées (pyxel), puis tes propres modules (personnages), avec une ligne vide entre chaque groupe.

Trois règles à retenir :

• les fichiers à importer sont dans le même dossier que le fichier que tu lances : c'est là que Python cherche en premier ;
• import n'est pas un copier-coller : le code reste dans personnages.py, et Python va le chercher. Si tu corriges une classe, tu la corriges à un seul endroit ;
• jamais un fichier qui porte le nom d'un module existant : un fichier random.py ou pyxel.py dans ton dossier serait importé à la place du vrai (voir Pro, épisode 8).

« Un module, un rôle »

Rappels : importer ses propres modules (voir épisode 17) ; la classe Jeu (voir épisode 13).

1. Liste les rôles : les données qu'on règle (taille, mots, couleurs), les personnages (classes et collision), la partie (règles, update, draw).
2. Un fichier par rôle : donnees.py, personnages.py, jeu.py.
3. Chaque fichier importe ce dont il a besoin, et rien de plus.
4. Relance après chaque déplacement : si le jeu ne marche plus, l'erreur vient du dernier morceau déplacé.

donnees.py (complet) :

import pyxel

LARGEUR = 160
HAUTEUR = 120
ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOTS = ["CHAT", "LUNE", "ROBOT", "PIRATE"]

COULEUR_FOND = pyxel.COLOR_NAVY
COULEUR_ROBOT = pyxel.COLOR_LIME
COULEUR_LETTRE = pyxel.COLOR_YELLOW

personnages.py : le début devient

import random

import pyxel

from donnees import LARGEUR, HAUTEUR, COULEUR_ROBOT, COULEUR_LETTRE

et, dans les deux méthodes dessiner, pyxel.COLOR_LIME devient COULEUR_ROBOT, pyxel.COLOR_YELLOW devient COULEUR_LETTRE.

jeu.py : le début devient

import random

import pyxel

from donnees import LARGEUR, HAUTEUR, ALPHABET, MOTS, COULEUR_FOND
from personnages import Robot, Lettre, touche

et, dans draw, pyxel.cls(pyxel.COLOR_NAVY) devient pyxel.cls(COULEUR_FOND). Tout le reste est inchangé.

Vérifié : la version en trois fichiers a joué les mêmes 9 parties que la première version (même tirage au hasard) : à la fin de chaque partie, toutes les positions, les lettres, les vies et les scores sont identiques, et les images à l'écran sont identiques au pixel près (Pyxel 2.9.9, Python 3.12.13 et 3.15.0).

Quand chaque fichier a un seul rôle, on sait où chercher : une couleur, c'est dans donnees.py ; un robot qui traverse le mur, c'est dans personnages.py ; une vie mal comptée, c'est dans jeu.py. Et chaque réglage n'existe qu'à un seul endroit : on ne risque plus d'en changer un et d'oublier sa copie. Le jeu, lui, ne voit aucune différence : Python va chercher chaque nom dans son module.

Bon réflexe ou piège ?

Le dossier d'un projet

1. Un dossier par projet, qui ne contient que ce projet :

2. Un seul fichier à lancer : le point d'entrée. C'est lui qui fabrique le Jeu et lance la boucle. Les autres fichiers ne font que définir des choses : lancer personnages.py tout seul n'affiche rien et n'ouvre aucune fenêtre (testé). On donne au point d'entrée un nom qu'on reconnaît (jeu.py), et on le dit dans le mode d'emploi.

3. Des noms de fichiers clairs : courts, en minuscules, qui disent ce que contient le fichier. Pour un fichier Python, ni espace ni tiret : son nom devient un nom de module, et

import mes-objets

s'arrête avec SyntaxError: invalid syntax (Python lit « mes moins objets »). Écris mes_objets.py. Le dossier, lui, peut s'appeler attrape-lettres : on ne l'importe pas.

4. Pas d'anciennes versions dans le dossier. jeu_v2_final_VRAI.py sème le doute. Les anciennes versions vont dans un dossier à part, à côté du projet (par exemple archives-attrape-lettres/), ou disparaissent.

5. Les ressources dans un sous-dossier : les captures dans images/. Ce qui n'est pas du code ne se mélange pas au code.

Pour aller plus loin (un repère, pas une obligation). Dans des projets écrits par d'autres, tu verras peut-être, à la fin du fichier à lancer :

if __name__ == "__main__":
    Jeu()

Cela veut dire : « lance le jeu seulement si ce fichier est le fichier lancé, pas s'il est importé ». Dans ce livre, on n'en a pas besoin : seul jeu.py lance quelque chose.

« Ranger, relancer, rejouer »

Rappels : lire une erreur en 3 questions (voir Boost, épisode 2) ; le plan de test (voir Pro, épisode 19).

1. Ranger : déplace ou renomme un fichier à la fois.
2. Relancer : lance jeu.py tout de suite. Si une erreur apparaît, elle vient du dernier changement.
3. Lire l'erreur d'import : dernière ligne, type d'erreur, nom en cause.
4. Rejouer le plan de test en entier quand tout est rangé : gagner, perdre, attraper deux fois la même bonne lettre, rester collé à un bord.

Les deux erreurs d'import les plus fréquentes (messages réels) :

Module not found = module introuvable. Python ne trouve pas personnages.py dans le dossier du fichier lancé : il a été déplacé, renommé, ou il manque une lettre au nom.

Cannot import name = impossible d'importer ce nom. Le fichier est trouvé, mais il ne contient rien qui s'appelle lettre : la classe s'appelle Lettre, avec une majuscule. Python propose même la correction. (Dans le vrai message, les … sont remplacés par le chemin complet du fichier sur ton ordinateur.)

Un rangement change des chemins et des noms, pas la logique du jeu. Les erreurs qu'il provoque sont donc presque toujours des erreurs d'import, et elles apparaissent dès le lancement : en relançant après chaque déplacement, on sait tout de suite lequel a posé problème. Le plan de test, lui, vérifie ce qu'une erreur d'import ne montre pas : que le jeu se joue toujours comme avant.

Bon réflexe ou piège ?

Deux lecteurs, un mode d'emploi

Un projet se partage avec un mode d'emploi : un fichier texte, à la racine du dossier, qu'on lit avant tout le reste. On l'appelle souvent README (« lis-moi » en anglais) ; en français, LISEZMOI. Il s'adresse à deux lecteurs :

Exemple : LISEZMOI.txt d'Attrape-lettres

Phrases courtes, une information par ligne, des exemples. Seulement un pseudo : jamais ton nom, ton collège ou ton adresse dans un fichier qu'on partage.

Dans le code lui-même, la documentation, ce sont les docstrings (voir Pro, épisode 13). Une docstring peut aussi se placer tout en haut d'un fichier : elle dit alors à quoi sert le module.

"""Personnages d'Attrape-lettres : le robot, les lettres et la collision."""

import random

La docstring du module vient en premier, avant les imports.

« Le test du lecteur muet »

Rappel : le mode d'emploi en deux parties (voir épisode 21).

1. Prépare : le dossier rangé, le LISEZMOI.txt, et une feuille d'observation.
2. Donne seulement le dossier à un camarade qui ne connaît pas ton jeu.
3. Tais-toi et observe : où il hésite, ce qu'il relit, ce qu'il demande, ce qu'il fait de travers.
4. Note sans corriger : chaque blocage est une phrase qui manque ou qui est mal dite.
5. Améliore le mode d'emploi, puis refais le test avec quelqu'un d'autre.

Feuille d'observation

Toi, tu connais ton jeu par cœur : tu ne vois plus ce qui manque, parce que ton cerveau complète tout seul. Ton camarade, lui, ne peut s'appuyer que sur ce qui est écrit. En te taisant, tu vois exactement ce que vivra un visiteur du stand, quand tu ne seras pas là pour expliquer. C'est la même idée que le plan de test : on joue comme quelqu'un d'autre pour trouver ce qu'on ne voit pas soi-même.

Bon réflexe ou piège ?

Lire avant de lancer

Les assistants d'IA ne sont pas faits pour toi, seul. Leurs conditions d'utilisation fixent un âge minimum (vérifiées le 29/10/2026) :

À l'école, le cadre du ministère de l'Éducation nationale (juin 2025) prévoit : pas de manipulation d'IA générative par les élèves avant la 4e ; à partir de la 4e, une utilisation encadrée par l'enseignant, en classe ; et aucun élève ne doit avoir à créer un compte personnel sur un service d'IA grand public.

Dans ce livre, tu n'utilises aucune IA. Tu fais ce qui sert à tout le monde, à tout âge : lire un code qu'on n'a pas écrit soi-même, qu'il vienne d'une IA, d'un site ou d'un camarade.

Le code de la feuille (écrit pour ce livre, à la manière de ce qu'un assistant peut proposer) :

import os


def podium(parties):
    """Renvoie les 3 meilleures parties, de la meilleure à la moins bonne."""
    os.system("cls")
    parties.sort()
    return [parties[-1], parties[-2], parties[-3]]

Une partie est un tuple (score, pseudo), comme à l'arc 1.

La grille de lecture, en 4 questions :

1. Est-ce que je comprends chaque ligne ? Si une ligne m'est inconnue, je cherche ce qu'elle fait avant de lancer. Ici : os.system("cls"). Le module os permet à Python d'agir sur l'ordinateur ; os.system exécute une commande du système (ici cls, qui efface l'écran sous Windows). Tu n'as pas à savoir tout cela : tu dois remarquer que tu ne le comprends pas. Une ligne inconnue qui agit sur l'ordinateur, sur des fichiers ou sur Internet → on ne lance pas ; on la montre à un adulte. Ici, elle n'a rien à faire dans un podium : on la retire, avec import os.
2. Que fait le code aux données qu'on lui donne ? parties.sort() modifie la liste de la personne qui appelle la fonction (voir épisode 7). Après l'appel, l'ordre des parties jouées est perdu.
3. Et dans les cas limites ? Avec moins de 3 parties, parties[-3] n'existe pas (voir Pro, épisode 6).
4. Mes propres tests confirment-ils ce que j'ai lu ? Sans la ligne os.system, on teste avec une liste de 5 parties, puis de 2 :

parties = [(7, "Lynx"), (12, "Pixel"), (5, "Comete"), (9, "Nova"), (11, "Lynx")]
print(podium(parties))
print(parties)
print(podium([(8, "Pixel"), (6, "Nova")]))

Sortie réelle (le traceback est abrégé) :

Le podium est juste sur l'exemple : c'est pour cela que « ça marche ». Mais la liste d'origine a été triée, et avec 2 parties le programme s'arrête.

La version corrigée, avec ce que tu connais :

def podium(parties):
    """Renvoie les 3 meilleures parties (ou moins), de la meilleure à la moins bonne."""
    classement = sorted(parties, reverse=True)
    resultat = []
    for partie in classement:
        if len(resultat) < 3:
            resultat.append(partie)
    return resultat

Avec les mêmes tests : le même podium, la liste d'origine intacte, [(8, 'Pixel'), (6, 'Nova')] pour 2 parties, et [] pour une liste vide (sorties vérifiées). À égalité de score, sorted(…, reverse=True) range les pseudos dans l'ordre alphabétique inverse : (9, 'Pixel') avant (9, 'Nova'). Est-ce ce que tu veux pour ton podium ? C'est à toi de décider, et de le tester.

Dernière règle : dire d'où vient le code. Si tu gardes un code que tu n'as pas écrit, tu l'écris dans un commentaire ou dans le mode d'emploi (« fonction podium : idée proposée par un assistant d'IA à un adulte, relue et corrigée par Pixel »).

« Avant de lancer un code que je n'ai pas écrit »

🎨 Carrousel récapitulatif — Arc 3

La documentation, mode d'emploi des outils

1. Où la trouver. Chaque outil sérieux a une documentation officielle, écrite par ceux qui le fabriquent :

• Python : docs.python.org, avec une version en français (traduite en partie seulement : certains titres restent en anglais). En haut de la page, un menu permet de choisir la version de Python : prends celle que tu utilises.
• Pyxel : la page du projet (github.com/kitao/pyxel) renvoie vers un guide en ligne (User Guide) ; Pyxel est aussi livré avec des exemples officiels, de vrais programmes à lancer (par exemple 04_sound_api.py pour le son).

2. Comment elle est rangée. La page d'accueil de la documentation de Python propose notamment :

3. Lire une fiche de fonction. Voici la fiche de random.choice, dans la documentation en français :

4. Tester l'exemple tel quel, puis adapter.

import random

print(random.choice(["CHAT", "LUNE", "ROBOT"]))
print(random.choice([]))

La première ligne affiche un des trois mots (ici LUNE) ; la deuxième s'arrête avec IndexError: Cannot choose from an empty sequence, exactement comme la fiche l'annonce.

5. La documentation est aussi dans Python. Dans la console, help(random.choice) affiche la docstring de la fonction (en anglais) : Choose a random element from a non-empty sequence. C'est le même help que pour tes propres fonctions (voir Pro, épisode 13).

6. Se méfier des copies. Beaucoup de sites recopient ou résument la documentation, parfois pour une ancienne version, parfois avec des erreurs ou de la publicité. Vérifie l'adresse : docs.python.org pour Python, la page du projet pour Pyxel.

Pour la fiche de Pyxel, la même méthode marche en anglais : play(ch, snd) — Play the sound snd on channel ch (0-3) : « joue le son snd sur le canal ch (de 0 à 3) ». Les mots à connaître : play (jouer), sound (son), channel (canal), returns (renvoie), default (valeur par défaut).

« Chercher, essayer l'exemple, adapter, tester »

Rappel : lire une fiche de fonction (voir épisode 25).

1. Chercher : dans la documentation et l'exemple, deux outils : pyxel.sounds[0].set(…) prépare le son n° 0 ; pyxel.play(0, 0) le joue sur le canal 0.
2. Essayer l'exemple à part, dans un petit programme, avant de toucher au jeu.
3. Adapter : garder seulement ce qu'il faut, et le mettre au bon endroit (épisode 16 : préparer dans __init__, réagir dans update).
4. Tester : le jeu doit se jouer exactement comme avant, avec du son en plus.

Lire set dans la documentation : set(notes, tones, volumes, effects, speed).

Si les timbres, volumes ou effets sont plus courts que les notes, ils se répètent : "7" vaut pour les quatre notes.

Le jeu avec deux sons (dans jeu.py, trois ajouts) :

    def __init__(self):
        pyxel.init(LARGEUR, HAUTEUR, title="Attrape-lettres")
        pyxel.sounds[0].set("c3e3g3c4", "p", "7", "n", 5)  # bonne lettre
        pyxel.sounds[1].set("f2c2", "n", "7", "f", 10)  # mauvaise lettre
        # … la suite de __init__ ne change pas

et, dans update :

            if touche(self.robot, lettre):
                if lettre.caractere in self.mot:
                    if lettre.caractere not in self.trouvees:
                        self.trouvees.append(lettre.caractere)
                        self.robot.score = self.robot.score + 1
                        pyxel.play(0, 0)
                else:
                    self.robot.vies = self.robot.vies - 1
                    pyxel.play(0, 1)

Vérifié :

• les notes enregistrées sont [36, 40, 43, 48] (do, mi, sol, do) ; chaque son dure 0,167 seconde ;
• le son n° 0, enregistré dans un fichier audio et analysé, contient bien quatre notes montantes (environ 523, 659, 784 et 1 045 Hz) ;
• sur 9 parties, le jeu avec sons a exactement le même état final que la version de l'arc 3 ; sur une partie gagnée, pyxel.play(0, 0) a été appelé 4 fois (une par lettre du mot) ; sur une partie perdue, pyxel.play(0, 1) a été appelé 3 fois (une par vie perdue).

Un exemple officiel est un programme qui marche, mais il en fait souvent beaucoup plus que ce que tu cherches. En l'essayant à part, tu vois ce que fait chaque ligne ; en n'en gardant que deux, tu sais exactement ce que tu ajoutes à ton jeu. Et comme les sons sont préparés une seule fois dans __init__ puis joués dans update, ils suivent la même règle que tout le reste du jeu : préparer d'abord, réagir ensuite.

Bon réflexe ou piège ?

Chercher, réduire, demander

1. Avant de demander, chercher. Relis le message d'erreur s'il y en a un (voir Boost, épisode 2) ; s'il n'y en a pas, c'est un bug silencieux : reproduis-le et affiche les valeurs (voir Pro, épisode 16). Souvent, la réponse apparaît à ce moment-là.

2. Réduire à un exemple minimal. Un exemple minimal est un programme le plus court possible qui montre encore le problème. On enlève tout ce qui n'y est pour rien : Pyxel, le robot, les vies… Pour le bug de Malik :

mot = "lune"
trouvees = []
caractere = "L"
if caractere in mot:
    trouvees.append(caractere)
print(trouvees)

Affiche [] : la lettre « L » n'est jamais trouvée. En réduisant, on voit la cause : "L" (majuscule) n'est pas dans "lune" (minuscules). Les lettres qui tombent sont tirées dans ALPHABET, en majuscules ; le mot doit donc être écrit en majuscules dans donnees.py, comme le dit le mode d'emploi (épisode 21). Six lignes suffisent, et souvent, en écrivant l'exemple minimal, on trouve soi-même la réponse.

3. Poser la question en 4 parties.

Le message d'erreur, quand il y en a un, se copie en entier, sans le résumer.

4. À qui demander. À ton professeur, à l'animatrice ou à l'animateur du club, à un camarade, à un adulte. Ne publie pas ta question sur un forum ou un réseau sans un adulte, et ne mets jamais dans une question ton nom, ton collège ou une photo.

« Aider sans faire à la place »

Rappels : la chasse aux bugs (voir Pro, épisode 16) ; la bonne question (voir épisode 27).

1. Faire décrire : « Qu'est-ce que tu attendais ? Qu'est-ce qui se passe ? »
2. Faire reproduire : « Peux-tu me le montrer ? Ça arrive à chaque fois ? »
3. Faire afficher : « Que vaut y à ce moment-là ? Comment le savoir ? »
4. Faire chercher l'endroit : « Quelle ligne décide que la lettre est tombée ? Que compare-t-elle ? »
5. Laisser corriger : la personne aidée tape la correction elle-même, et la teste.

Le bug de Nova, réduit à un test en console :

from personnages import Lettre

lettre = Lettre("A", 50, 40)
for tour in range(1, 6):
    lettre.tomber()
    print(tour, lettre.y, lettre.est_tombee())

Sortie réelle avec le personnages.py de Nova :

Avec le bon fichier, la ligne 4 affiche 4 160 True. La lettre de Nova repart un tour trop tard, parce que sa méthode est_tombee compare y à la largeur de l'écran (160) au lieu de sa hauteur (120) : return self.y > LARGEUR. Avec une vitesse plus lente, ce tour de trop devient un long moment sans lettre.

Quand quelqu'un trouve lui-même la ligne fautive, il comprend pourquoi elle était fausse, et il saura chercher la prochaine fois. Si tu donnes la réponse, le bug est corrigé, mais la méthode n'est pas apprise. Les questions suivent les étapes de la chasse aux bugs : décrire, reproduire, afficher, isoler, corriger. En les posant, tu montres la méthode sans la réciter.

Bon réflexe ou piège ?

Expliquer, du quoi au comment

1. Montrer avant d'expliquer. Commence par jouer 20 secondes. Ton public comprend le but sans un mot.

2. Le « quoi » : ce que fait le jeu, en une phrase, sans aucun mot de code : « Un robot attrape les lettres d'un mot caché ; une mauvaise lettre fait perdre une vie. »

3. Le « comment » : les grandes pièces, avec un schéma :

« Le robot et les lettres sont des objets : chacun sait se déplacer et se dessiner. Trente fois par seconde, le jeu les fait bouger, vérifie s'ils se touchent, puis redessine l'écran. »

4. Un détail choisi, pas tous : par exemple la collision (deux rectangles qui se chevauchent, quatre comparaisons). Un seul détail bien expliqué vaut mieux que dix survolés.

5. Adapter les mots au public.

Le plan des 3 minutes

« Deux essais, deux retours »

Rappel : le plan des 3 minutes (voir épisode 29).

1. Premier essai devant deux camarades, chronométré.
2. Deux retours par personne, toujours dans cet ordre : une chose qui marche (« J'ai compris quand… ») et une chose à améliorer (« Je me suis perdu quand… »).
3. Choisir : tu n'es pas obligé de tout changer ; garde les retours qui reviennent deux fois et ceux qui touchent au temps.
4. Deuxième essai, chronométré, avec les changements.
5. Comparer : temps, retours, ce qui a changé.

Grille de retour

Pendant qu'on parle, on ne peut pas s'écouter soi-même : on ne voit pas le moment où le public décroche. Les camarades, eux, le voient. Commencer par ce qui marche dit ce qu'il faut garder, et rend plus facile d'entendre ce qui est à améliorer. Et le deuxième essai montre si le changement a vraiment aidé : c'est un plan de test, appliqué à une présentation.

Bon réflexe ou piège ?

Faire faire, pas montrer

1. Un objectif simple et visible. À la fin de l'atelier, chaque enfant a changé quelque chose dans le jeu et vu le résultat : un mot à lui dans la liste, une couleur, une vitesse. Un objectif qu'on peut montrer à ses parents en sortant.

2. Un déroulé en 4 temps (30 minutes).

3. Aider sans prendre le clavier (la méthode de l'épisode 28) : montrer du doigt, poser une question, laisser taper. Les mains restent dans tes poches.

4. Prévoir les blocages.

5. Blocs ou Python ? Pour les CM2, le défi se fait dans donnees.py : quelques lignes de données, pas de logique. Pour des plus jeunes ou pour un enfant bloqué, un détour par les blocs (Scratch) suffit à expliquer l'idée : « une liste de mots », « une couleur », c'est la même chose.