Simulateur Roberto

Explication

Un programme Python s'exécute ligne par ligne, du haut vers le bas, dans l'ordre où tu les as écrites. Chaque instruction se termine avant que la suivante ne commence : il n'y a pas de « en même temps ».

Exemple

clear_display()
display_text("Un", x=10, y=10)
display_text("Deux", x=10, y=30)
display_text("Trois", x=10, y=50)

« Un » est dessiné, puis « Deux » en dessous, puis « Trois » en dessous : toujours dans cet ordre, jamais dans un autre.

Explication

Un commentaire est une ligne que Python ignore complètement : elle sert uniquement à toi, pour expliquer ton code.

Pour écrire un commentaire, on met un # devant le texte. Tout ce qui suit sur la même ligne n'est pas exécuté.

Exemple

# Ce programme affiche "Un"
clear_display()
display_text("Un", x=10, y=10)  # ceci s'affiche en haut de l'écran

Tout ce qui est inscrit après le symbole # n'a aucun effet sur le programme : ici seuls clear_display() et display_text(...) sont réellement exécutés.

Explication

Un programme peut utiliser des fonctions déjà écrites, toutes prêtes à l'emploi — il en existe plein. Par exemple get_time() (elle renvoie l'heure actuelle) ou get_tilt_x() (elle renvoie l'inclinaison de la montre sur un axe, en degrés).

Pourquoi on a besoin de ça : au moment où tu écris ton programme, tu ne sais pas encore quelle heure il sera quand il va s'exécuter — ni quelle heure il sera quand quelqu'un regardera sa montre, plus tard, dans la journée. Tu ne peux donc pas écrire un nombre fixe comme 14:32 directement dans le code : ce serait faux dès la minute suivante. Une fonction comme get_time() permet de dire « va vérifier maintenant », au moment exact où le programme tourne.

C'est là qu'intervient la deuxième idée importante : quand le programme s'exécute, get_time() n'existe plus telle quelle — elle est remplacée par le résultat qu'elle renvoie à cet instant précis.

C'est un peu comme envoyer quelqu'un demander l'heure à ta place : tu écris « demande l'heure », mais ce qui compte à la fin, c'est la réponse qu'on te rapporte — par exemple 14:32 — pas la phrase « demande l'heure » elle-même.

Exemple

display_text(get_time(), x=10, y=10)

Au moment où cette ligne s'exécute :

• get_time() est calculé en premier, et donne par exemple "14:32"
• Tout se passe alors comme si tu avais écrit display_text("14:32", x=10, y=10)
• C'est ça qui s'affiche à l'écran — jamais le texte get_time() lui-même

Explication

Tu sais maintenant qu'une fonction comme get_time() est remplacée par sa valeur. On peut utiliser cette valeur tout de suite, comme on l'a fait jusqu'ici Mais on peut aussi choisir de la ranger dans une boîte, pour la réutiliser plus facilement ensuite.

Cette boîte s'appelle une variable. On lui donne un nom, et on y range un résultat avec le symbole = :

heure = get_time()

Ici, = ne veut pas dire « égal » comme en maths : il veut dire « range ce qui est calculé à droite dans la boîte nommée à gauche ».

Pour vérifier ce que contient une variable, il suffit d'écrire son nom, tout seul. Exactement comme pour une fonction (fiche A), au moment où le programme s'exécute, ce nom est remplacé par ce qu'il y a dans la boîte :

heure = get_time()
display_text(heure, x=10, y=10)

Attention à ne pas confondre une variable et une fonction : une fonction s'appelle toujours avec des parenthèses (get_time(), ça veut dire « va chercher l'information »), alors qu'une variable s'utilise sans parenthèses (heure, ça veut dire « ce qui est déjà rangé dans la boîte »). Oublier ou ajouter des parenthèses par erreur est une source fréquente de bugs !

Exemple

Ces deux programmes font exactement la même chose :

Avec une variable :

heure = get_time()
display_text(heure, x=10, y=10)

Sans variable (fonctions imbriquées) :

display_text(get_time(), x=10, y=10)

Les deux affichent la même chose à l'écran. La différence, c'est la lisibilité : avec la variable, on lit le programme comme une recette, étape par étape (« je range l'heure, puis je l'affiche »), et on peut réutiliser heure plusieurs fois sans avoir à rappeler get_time() à chaque fois.

Attention cependant : heure contient l'heure qu'il était au moment précis où la ligne heure = get_time() s'est exécutée — ça ne bougera plus tant qu'on n'écrira pas à nouveau heure = .... get_time(), lui, donne une réponse différente à chaque fois qu'on l'appelle, puisqu'il va revérifier l'heure en direct. Une variable, c'est une photo prise à un instant donné — pas une caméra qui filme en continu.

Une chose à savoir : en Python, une variable n'a pas besoin d'être annoncée à l'avance — écrire heure = get_time() crée la boîte heure au moment même où cette ligne s'exécute. En revanche, si tu essaies d'utiliser une variable avant de l'avoir remplie au moins une fois (par exemple si tu écris display_text(minute, x=10, y=10) sans avoir jamais fait minute = ... avant), le programme ne comprendra pas ce que représente minute et affichera une erreur. Une variable doit toujours avoir été remplie au moins une fois avant d'être lue.

Explication

Jusqu'ici, tu as manipulé deux sortes de valeurs bien différentes : du texte, comme "14:32" ou "Bonjour" (on dit aussi une chaîne de caractères, ou string), et des nombres, comme 18 ou -3 (on parle d'entier, ou int). Un texte s'écrit toujours entre guillemets ("..."), un nombre jamais.

Cette différence n'est pas qu'une question d'écriture : Python les traite vraiment différemment. Par exemple, + additionne deux nombres (3 + 2 donne 5), mais colle deux textes l'un après l'autre ("a" + "b" donne "ab"). Et on ne peut pas mélanger les deux sans précaution : écrire "score : " + 10 provoque une erreur, parce que Python ne sait pas additionner un texte et un nombre.

C'est aussi pour ça que certaines fonctions attendent un type précis en paramètre, et pas l'autre : display_text(...) attend du texte, alors que time.sleep(...) attend un nombre (une durée en secondes). Sur la vraie montre, donner le mauvais type à l'une de ces fonctions fait planter ton programme. Le simulateur, lui, est plus tolérant avec display_text(...) : il convertit automatiquement ce que tu lui donnes en texte avant de l'afficher, donc ton code peut avoir l'air de marcher même sans str(). Mais comme ce ne sera pas le cas sur la vraie montre, prends dès maintenant l'habitude de toujours convertir un nombre avec str() avant de l'afficher.

Heureusement, on peut transformer une valeur d'un type vers l'autre :

• str(valeur) transforme un nombre en texte
• int(texte) transforme un texte (qui ne contient que des chiffres) en nombre

(Il existe d'autres types de valeurs en Python — tu les découvriras plus tard. Pour l'instant, retiens surtout qu'un nombre et un texte ne sont pas interchangeables.)

Exemple

age = 10
print("J'ai " + str(age) + " ans")  # sans str(), ça provoquerait une erreur

texte = "42"
nombre = int(texte)
print(nombre + 1)  # affiche 43

Sans str(age), la ligne "J'ai " + age + " ans" provoquerait une erreur : on ne peut pas coller directement un texte et un nombre avec +. Et sans int(texte), on ne pourrait pas faire texte + 1, puisque texte serait toujours du texte, pas un nombre.

Explication

Ta carte a des « sens », un peu comme les 5 sens du corps humain. Pour ça, elle est reliée à des capteurs par des fils électriques, un peu comme nos yeux sont reliés à notre cerveau par des nerfs. Dans ces fils passent des messages, qu'on appelle des signaux.

Ta montre a plusieurs capteurs :

• une horloge, qui connaît l'heure actuelle
• un IMU, qui sent l'inclinaison de la montre sur deux axes (est-elle penchée à gauche ou à droite ? vers l'avant ou vers l'arrière ?)
• un capteur de toucher, qui sait si on est en train de toucher l'écran

Pour obtenir une mesure d'un capteur, il faut la demander, grâce à une fonction :

• get_time() : demande l'heure actuelle à l'horloge
• get_tilt_x() : demande à l'IMU l'inclinaison de gauche à droite
• get_tilt_y() : demande à l'IMU l'inclinaison d'avant en arrière
• is_touched() : demande l'état du toucher (True si on a touché l'écran depuis la dernière fois qu'on a posé la question, False sinon)

Quand tu appelles une de ces fonctions, elle active les systèmes électriques de la carte pour échanger des signaux avec le capteur concerné, et en ramener la mesure. Tu n'as pas besoin de savoir comment le capteur est fabriqué ni comment ces signaux circulent réellement, la fonction s'occupe de tout ça à ta place.

Et comme il s'agit d'une fonction, au moment où le programme s'exécute, elle est remplacée par la valeur mesurée par le capteur à cet instant précis.

Pour afficher un résultat à l'écran, on utilise une autre fonction :

• display_text(...) — écrit quelque chose sur l'écran de la montre

Exemple

Deux façons d'afficher l'heure sur ta montre, qui donnent le même résultat :

En une seule ligne (fonctions imbriquées) :

display_text(get_time(), x=10, y=10)

En deux étapes (avec une variable) :

heure = get_time()
display_text(heure, x=10, y=10)

Tu peux aussi tester ces commandes directement dans la console de Thonny. Attention cependant : display_text(...) n'écrit que sur l'écran de la montre, pas dans la console. Pour afficher un résultat dans la console, on utilise une autre fonction, déjà fournie par Python lui-même : print(...).

print(get_time(), x=10, y=10)

Explication

En Python, l'indentation (le nombre d'espaces au début d'une ligne) n'est pas juste une question de présentation : elle fait partie du langage. C'est elle qui indique à Python quelles lignes appartiennent ensemble, à l'intérieur d'un même bloc.

Un bloc commence juste après une ligne qui se termine par : (par exemple après un if, un while, plus tard un for ou une fonction). Toutes les lignes qui suivent, décalées vers la droite du même nombre d'espaces, font partie de ce bloc. Dès qu'une ligne revient au même niveau qu'avant le :, le bloc est terminé.

Dans ce cours, on utilise toujours 4 espaces pour décaler d'un niveau. Thonny (l'éditeur que tu utilises) ajoute généralement ces espaces automatiquement après un :, mais tu peux aussi appuyer sur la touche Tab.

Attention : une indentation incohérente (mélanger des lignes avec des nombres d'espaces différents à l'intérieur du même bloc) provoque une erreur. Python est strict sur ce point, contrairement à d'autres langages où l'indentation n'est qu'une question de style.

Exemple

while True:
    display_text("Salut", x=10, y=10)  # indenté : appartient à la boucle
    bip()                              # indenté : appartient aussi à la boucle

print("fin")                          # pas indenté : ne fait PAS partie de la boucle

Les deux premières lignes sont décalées de 4 espaces : elles font partie du bloc de la boucle while True:, et sont donc rejouées à chaque tour. La ligne print("fin") n'est pas décalée : elle n'appartient pas à la boucle (et ici, elle ne s'exécuterait même jamais, puisque la boucle est infinie).

Explication

La dernière fois, ta montre affichait l'heure une seule fois : figée, comme une photo. Pour qu'elle reste juste, il faudrait refaire cette mesure et cet affichage très souvent.

On pourrait se dire : il suffit d'écrire heure = get_time() puis display_text(heure, x=10, y=10) plein de fois de suite dans le programme. Mais est-ce une bonne idée ? Réfléchis : que se passerait-il si on essayait d'écrire ces deux lignes des milliers de fois dans le même programme ?

• La taille du programme : chaque ligne prend de la place en mémoire, et la puce n'a qu'une mémoire limitée pour stocker le programme.
• Le temps pour l'écrire : recopier les mêmes lignes des milliers de fois prendrait un temps fou.
• Le risque d'erreur : plus on recopie de lignes à la main, plus on risque de faire une faute de frappe quelque part.
• Le temps pour corriger : si un jour tu veux changer quelque chose (par exemple afficher aussi l'inclinaison), il faudrait modifier chacune des milliers de copies, une par une !

La solution : écrire les instructions une seule fois, et demander au programme de les exécuter plusieurs fois de suite. C'est ce qu'on appelle une boucle : à chaque fois que le programme arrive à la fin de ces instructions, il revient au début, comme s'il tournait en rond. Et comme on ne lui dit jamais de s'arrêter, on parle de boucle infinie :

while True:
    # tout ce qui est ici est rejoué, encore et encore, sans jamais s'arrêter
    ...

Exemple

while True:
    heure = get_time()
    display_text(heure, x=10, y=10)

Cette fois, l'heure affichée se met à jour toute seule, sans qu'on ait besoin de relancer quoi que ce soit.

Explication

Une condition, c'est quelque chose qui vaut soit True (vrai), soit False (faux). Rien d'autre.

Par exemple, 10 >= 12 est une condition : elle vaut True si c'est vrai, False sinon.

Attention : pour comparer deux valeurs, on utilise deux signes égal ==, pas un seul. Un seul = sert à autre chose (ranger une valeur dans une variable, fiche B), pas à comparer.

Certaines fonctions, comme is_button_pressed(), renvoient directement True ou False, sans avoir besoin de comparaison.

Exemple

print(10 >= 12)  # est-ce que 10 est plus grand ou égal à 12 ?
print(5 == 5)    # est-ce que 5 est égal à 5 ?
print(is_button_pressed())  # est-ce que le bouton est appuyé ?

La console affiche False, puis True, puis True ou False selon que tu appuies sur le bouton ou non. Une condition, c'est toujours l'un ou l'autre : jamais autre chose.

Explication

if condition: n'exécute le bloc de code indenté en dessous que si condition vaut True. Sinon, ce bloc est simplement ignoré.

Exemple

while True:
    if is_button_pressed():
        print("Bouton pressé !")  # cette ligne est indentée (décalée) par rapport au if : elle ne s'exécute que si la condition est True
    time.sleep(0.1)  # cette ligne est alignée avec le if : elle s'exécute toujours, que la condition soit True ou False

Le programme vérifie sans arrêt si le bouton est pressé grâce à while True:. Le message ne s'affiche dans la console que les fois où c'est le cas : sinon, rien ne se passe.

Explication

Tu connais déjà if condition: : il exécute un bloc seulement si la condition est vraie, et ne fait rien sinon.

else: permet d'ajouter un deuxième bloc, qui s'exécute uniquement quand la condition est fausse. Ton programme fait alors toujours l'un des deux blocs : jamais aucun, jamais les deux.

Exemple

while True:
    clear_display()
    if is_button_pressed():
        display_text("Pressé !", x=10, y=10)
    else:
        display_text("En attente...", x=10, y=10)
    time.sleep(0.05)

L'écran affiche toujours quelque chose : soit « Pressé ! » quand tu appuies sur le bouton, soit « En attente... » sinon. Jamais les deux en même temps, jamais rien du tout.

Explication

La boucle while True: répète pour toujours. for ... in range(n): répète un nombre de fois précis et connu à l'avance : n fois.

range(n) fournit n valeurs, de 0 à n-1. À chaque tour de boucle, la variable qui suit for (ici i) prend la valeur suivante — pratique pour compter les tours, ou numéroter quelque chose.

Exemple

for i in range(5):
    print("Tour n°", i)

Le bloc indenté sous for i in range(5): est répété 5 fois ; i prend successivement les valeurs 0, 1, 2, 3 puis 4.

Explication

Python peut faire des calculs directement, et une variable peut stocker le résultat d'un calcul (pas seulement une valeur fixe) : surface = largeur * hauteur calcule d'abord largeur * hauteur, puis range le résultat dans surface.

Les quatre opérations de base s'écrivent + (addition), - (soustraction), * (multiplication) et / (division). Comme en maths, la multiplication et la division sont calculées avant l'addition et la soustraction — utilise des parenthèses () pour changer l'ordre si besoin.

Pour aller plus loin : from math import sin, cos donne accès au sinus et au cosinus (sin(angle), cos(angle)). Attention, l'angle est en radians, pas en degrés.

Exemple

from math import sin, cos

a = 3 + 4 * 2
b = (3 + 4) * 2
print(a)
print(b)
print(sin(0))
print(cos(0))

a vaut 11 (le 4 * 2 est calculé avant le +), alors que b vaut 14 (les parenthèses forcent à calculer 3 + 4 d'abord). sin(0) vaut 0.0 et cos(0) vaut 1.0.

Explication

En combinant une boucle for avec les fonctions de dessin (draw_circle, draw_rect...), tu peux faire bouger ou évoluer une forme à chaque tour : ça donne l'impression d'une animation.

Le principe : à chaque tour, clear_display() efface l'ancienne image, une forme est dessinée à une position (ou une taille) qui dépend de i, puis une courte pause (time.sleep(...)) laisse le temps de voir l'image avant de passer au tour suivant.

Exemple

import time

for i in range(5):
    clear_display()
    draw_circle(20 + i * 40, 140, 15, fill=True)
    time.sleep(0.3)

À chaque tour, i change (0, 1, 2, 3, 4), donc 20 + i * 40 change aussi : le cercle est redessiné un peu plus à droite à chaque fois. Comme l'écran est effacé avant, ça donne l'impression que le cercle se déplace.

Explication

Dans la fiche précédente, clear_display() efface tout l'écran avant chaque nouveau dessin : l'écran passe un court instant par du noir, ce qui donne un petit scintillement visible.

Un sprite règle ce problème : c'est une mini-image gardée en mémoire, invisible. On dessine dedans avec les fonctions déjà connues (draw_circle, draw_rect...), en ajoutant juste sprite=mon_sprite ; une fois le dessin terminé, draw_sprite l'envoie sur l'écran d'un seul coup. L'écran ne voit donc jamais d'étape intermédiaire : juste l'ancienne image, puis directement la nouvelle.

new_sprite(largeur, hauteur) crée le sprite (une seule fois, avant la boucle) ; clear_sprite l'efface (comme clear_display, mais pour le sprite) à chaque tour, avant de redessiner dedans.

Exemple

import time

mon_sprite = new_sprite(90, 90)

for i in range(8):
    clear_sprite(mon_sprite)
    draw_circle(45, 45, 5 + i * 5, fill=True, sprite=mon_sprite)
    draw_sprite(mon_sprite, 75, 95)
    time.sleep(0.2)

Même cercle qui grossit que dans la fiche précédente, mais cette fois sans aucun scintillement : le cercle est entièrement redessiné dans mon_sprite (invisible) avant d'être envoyé sur l'écran par draw_sprite.