PYTHON FORGE — Jour 2 : Structures de données

>_ JOUR 2 / 4 · LES STRUCTURES DE DONNÉES

PYTHON FORGE

PILIER #2 — DONNER DE LA MÉMOIRE À TES PROGRAMMES

Hier, tu as appris à organiser ton code en fonctions. Aujourd’hui, tu vas apprendre à organiser tes données.

Une liste stocke une séquence ordonnée (une suite de coups, une file d’attente). Un dictionnaire associe des clés à des valeurs (un annuaire, une table de traduction). Ce sont les deux outils les plus utilisés de tout le Python — tu vas les forger sur deux jeux.

📚 // Rappel : les structures qu’on va utiliser

LIS CES FICHES — QUE TU CONNAISSES DÉJÀ OU NON

📋 La liste [ ] CONCEPT DU JOUR

Une liste stocke plusieurs valeurs dans un ordre précis. On accède à chaque élément par sa position (qui commence à 0 !).

C’est une file d’attente : les gens sont rangés dans l’ordre. Le premier est en position 0, le deuxième en position 1, etc.

exemple.py

# Une liste de coups dans un jeu
coups = ["A", "B", "A"]

print(coups[0])      # affiche "A"  (le 1er, position 0)
print(coups[2])      # affiche "A"  (le 3e, position 2)
print(len(coups))   # affiche 3  (combien d'éléments)

➕ Ajouter & parcourir une liste CONCEPT DU JOUR

.append() ajoute un élément à la fin. La boucle for ... in permet de parcourir tous les éléments un par un, sans avoir à connaître leur nombre.

.append, c’est ajouter une personne à la fin de la file. Le for, c’est passer voir chaque personne de la file, l’une après l’autre.

exemple.py

coups = []              # une liste vide au départ
coups.append("A")       # coups vaut maintenant ["A"]
coups.append("B")       # coups vaut ["A", "B"]

# Parcourir chaque élément
for coup in coups:
    print(coup)         # affiche "A" puis "B"

📖 Le dictionnaire { } CONCEPT DU JOUR

Un dictionnaire associe une clé à une valeur. Au lieu d’accéder par position (comme la liste), tu accèdes directement par la clé.

C’est un annuaire : tu ne lis pas toutes les pages, tu cherches directement un nom (la clé) et tu obtiens son numéro (la valeur). Instantané.

exemple.py

# clé : valeur
ages = {"Léa": 16, "Tom": 17}

print(ages["Léa"])    # affiche 16 (la valeur liée à "Léa")

# Une table de traduction lettre → code
morse = {"A": ".-", "B": "-..."}
print(morse["A"])     # affiche ".-"

🔎 Tester une clé avec « in » NIVEAU +1

Accéder à une clé qui n’existe pas fait planter le programme. Pour éviter ça, on vérifie d’abord avec in : “est-ce que cette clé existe dans le dictionnaire ?”

Avant de chercher un nom dans l’annuaire, tu vérifies qu’il y figure. Sinon, tu cherches dans le vide — et le programme se fâche.

exemple.py

morse = {"A": ".-", "B": "-..."}

lettre = "A"
if lettre in morse:        # la clé existe ?
    print(morse[lettre])    # oui → on l'utilise sans risque

# "in" marche aussi sur les listes :
if "A" in ["A", "B"]:    # True
    print("trouvé !")

JOUR 2 · 3H · 2 MISSIONS

⚒️ À la forge !

Deux jeux pour pratiquer les listes et les dictionnaires. Le code te donne la structure — à toi la logique. Bloqué·e ? Lance le chrono : les indices s’ouvriront automatiquement, ou demande le code à l’animateur.

MISSION 3 · LISTES

simon.py — Jeu de mémoire

+150 XP

Le brief : Le classique jeu Simon. Le Micro:bit montre une séquence (A, B, B, A…), le joueur doit la reproduire exactement. À chaque tour réussi, la séquence s’allonge d’une étape. Combien de tours peux-tu tenir ?

🎯 TON OBJECTIF

La liste sequence est la mémoire du jeu. Complète :
• ajouter_etape() — ajoute un coup aléatoire à la liste
• montrer_sequence() — affiche toute la séquence
• tour_du_joueur() — vérifie que le joueur reproduit bien la séquence

listes .append() for … in random.choice()

// COMMENT PROCÉDER

Ouvre python.microbit.org et copie le code

Commence par ajouter_etape() — une seule ligne avec .append()

Puis montrer_sequence() — parcours la liste avec un for

Enfin tour_du_joueur() — compare chaque appui à la lettre attendue

simon.py

from microbit import *
import random

sequence = []           # la mémoire du jeu — grandit à chaque tour
CHOIX = ["A", "B"]      # les deux touches possibles

def ajouter_etape():
    # À TOI : ajoute un élément aléatoire (A ou B) à la liste.
    # Pense à .append() et random.choice()

    .............................................


def montrer_sequence():
    # À TOI : affiche chaque lettre de la séquence, l'une après
    # l'autre. Pense à effacer l'écran entre deux lettres,
    # sinon "AA" ressemble à un seul A !

    .............................................
    .............................................


def lire_bouton():
    # Déjà écrite : attend un appui et renvoie "A" ou "B".
    while True:
        if button_a.was_pressed():
            return "A"
        if button_b.was_pressed():
            return "B"


def tour_du_joueur():
    # À TOI : pour chaque lettre attendue dans la séquence,
    # lis l'appui du joueur. S'il se trompe → renvoie False.
    # S'il réussit toute la séquence → renvoie True.

    .............................................
    .............................................
    .............................................


# ── Boucle de jeu (déjà écrite) ─────────────────────────
score = 0
display.scroll("SIMON", delay=80)

while True:
    sleep(800)
    ajouter_etape()
    montrer_sequence()
    if tour_du_joueur():
        score = score + 1
        display.show(Image.YES)
        sleep(500)
    else:
        display.show(Image.SKULL)
        sleep(1000)
        display.scroll("SCORE: " + str(score))
        sequence = []       # on réinitialise la partie
        score = 0

🔒

INDICES VERROUILLÉS

Lance ton chrono quand tu commences cette mission. Les indices s’ouvriront automatiquement après le délai.

Cherche par toi-même d’abord. Demande le code à l’animateur si tu bloques avant la fin du chrono.

+150

Validé quand le jeu fonctionne. Meilleur score de la salle : +30 XP bonus.

🔮 DÉFI BONUS (+40 XP)

Mode difficile : l’affichage accélère quand la séquence grandit. Remplace sleep(600) par sleep(max(150, 600 - len(sequence) * 50)) — analyse d’abord ce que fait cette formule.

MISSION 4 · DICTIONNAIRES

morse.py — Encodeur Morse

+150 XP

Le brief : Transforme le Micro:bit en transmetteur Morse. Tu écris un mot, le Micro:bit le traduit en points et traits lumineux. Le dictionnaire fait la traduction lettre → code Morse instantanément.

🎯 TON OBJECTIF

Le dictionnaire MORSE est déjà fourni. Complète :
• encoder(texte) — traduit un texte en chaîne Morse (utilise le dictionnaire)
• jouer_morse(code) — joue le code en lumière (point = court, trait = long)

dictionnaires clé in dict .upper() parcours de texte

// COMMENT PROCÉDER

Copie le code (le dictionnaire MORSE est déjà écrit pour toi)

Pour encoder : parcours chaque lettre du texte, va chercher son code dans le dictionnaire

Vérifie que la lettre existe dans MORSE avant de l’utiliser (avec in)

Pour jouer_morse : un symbole à la fois, point = court, trait = long

morse.py

from microbit import *

# Dictionnaire : chaque lettre (clé) → son code Morse (valeur)
MORSE = {
    "A": ".-",   "B": "-...", "C": "-.-.", "D": "-..",
    "E": ".",    "F": "..-.", "G": "--.",  "H": "....",
    "I": "..",   "J": ".---", "K": "-.-",  "L": ".-..",
    "M": "--",   "N": "-.",   "O": "---",  "P": ".--.",
    "Q": "--.-", "R": ".-.",  "S": "...",  "T": "-",
    "U": "..-",  "V": "...-", "W": ".--",  "X": "-..-",
    "Y": "-.--", "Z": "--.."
}

def encoder(texte):
    # À TOI : traduis le texte en Morse. Pour chaque lettre
    # (en MAJUSCULE), si elle existe dans MORSE, ajoute son
    # code suivi d'un espace. Renvoie le résultat.
    resultat = ""

    .............................................
    .............................................
    .............................................


def jouer_morse(code):
    # À TOI : joue le code en lumière.
    # "." → petit carré 200ms  |  "-" → grand carré 600ms
    # " " → pause de 400ms (séparation des lettres)

    .............................................
    .............................................
    .............................................


# ── Programme principal ─────────────────────────────────
MESSAGE = "SOS"     # ← change le message !

while True:
    if button_a.was_pressed():
        display.scroll(encoder(MESSAGE), delay=100)   # version texte
    if button_b.was_pressed():
        jouer_morse(encoder(MESSAGE))                # version lumineuse

🔒

INDICES VERROUILLÉS

Lance ton chrono quand tu commences cette mission. Les indices s’ouvriront automatiquement après le délai.

Cherche par toi-même d’abord. Demande le code à l’animateur si tu bloques avant la fin du chrono.

+150

Validé quand “SOS” s’affiche en Morse lumineux : · · · — — — · · ·

🔮 DÉFI BONUS (+50 XP)

Le décodeur inverse ! Construis MORSE_INVERSE à partir de MORSE.items(), puis écris decoder(code) qui retraduit “.-” en “A”. Envoie un message codé à l’équipe voisine — à elle de le décoder.

🛠️ // Aide-mémoire

AUTORISÉ PENDANT TOUTES LES MISSIONS

ma_liste = [] — créer une liste vide

ma_liste.append(x) — ajouter x à la fin

len(ma_liste) — nombre d’éléments

ma_liste[0] — 1er élément (position 0)

for e in ma_liste: — parcourir la liste

mon_dict = {"A": ".-"} — créer un dictionnaire

mon_dict["A"] — valeur liée à la clé “A”

if cle in mon_dict: — tester si la clé existe

mon_dict.items() — parcourir clés ET valeurs

texte.upper() — passer en majuscules

random.choice(liste) — élément au hasard

!= « différent de » · == « égal à »

Atelier Python Microbit

PYTHON FORGE

📚 // Rappel : les structures qu’on va utiliser

🛠️ // Aide-mémoire

Ne manquez aucune nouveauté ! Inscrivez-vous à notre newsletter dès maintenant !