Aller au contenu principal
6e⏱ 4 séances

Découverte de la programmation avec Scratch

Ce que tu vas apprendre

  • Comprendre ce qu'est un algorithme et un programme
  • Repérer les grandes familles de blocs dans Scratch
  • Utiliser le stylo pour tracer ou effacer le déplacement d'un lutin
  • Écrire un script utilisant une séquence d'instructions
  • Utiliser une boucle « répéter » pour simplifier un script
  • Créer et utiliser une variable simple
Notions clésalgorithme, programmescript, bloc, lutinstylo en position d'écriture, relever le stylo, effacer toutboucle « répéter »variable

1. Qu’est-ce qu’un algorithme ?

Définition. Un algorithme est une suite d’instructions précises, données dans un ordre déterminé, qui permet de résoudre un problème ou d’accomplir une tâche.

Exemple. La recette d’un gâteau est un algorithme : « Casser 2 œufs, ajouter 100 g de sucre, mélanger, ajouter la farine, verser dans un moule, cuire 30 minutes. » Si on change l’ordre des étapes, ou si on en oublie une, le résultat n’est plus le même.

Vocabulaire. Quand un algorithme est écrit dans un langage compris par un ordinateur, on parle de programme. Programmer, c’est donc écrire un algorithme dans un langage que la machine peut exécuter.

Un algorithme : une suite d'instructions dans un ordre précis Recette d'un gâteau 1 Casser 2 œufs 2 Ajouter le sucre 3 Mélanger 4 Ajouter la farine, verser dans un moule 5 Cuire 30 minutes Changer l'ordre des étapes change (ou rate) le résultat.
Un algorithme est une suite d'instructions données dans un ordre précis : changer l'ordre des étapes change (ou casse) le résultat.

→ S’entraîner : Exercice 1

2. Découvrir l’interface Scratch

Scratch est un langage de programmation par blocs : au lieu d’écrire du texte, on assemble des blocs colorés comme des pièces de puzzle, ce qui évite les erreurs de syntaxe.

L’interface de Scratch comporte trois grandes zones :

  • la scène, en haut à droite, où s’affiche le résultat du programme ;
  • la liste des lutins (les personnages ou objets que l’on programme) et des arrière-plans ;
  • la zone des blocs, classés par catégories (Mouvement, Apparence, Son, Événements, Contrôle, Capteurs, Opérateurs, Variables, Stylo…), que l’on fait glisser dans la zone centrale pour construire un script.

Vocabulaire. Un lutin est le personnage ou l’objet que l’on programme : c’est lui qui exécute les blocs qui lui sont attribués (un projet peut contenir plusieurs lutins, chacun avec ses propres scripts). Un bloc est une instruction prête à l’emploi, représentée par une pièce de puzzle colorée selon sa catégorie ; on empile plusieurs blocs les uns sous les autres pour construire un script.

Définition. Un script est un empilement de blocs qui forme un petit programme exécuté par un lutin.

L'interface de Scratch : trois grandes zones Palette de blocs Mouvement Événements Contrôle Variables Stylo Zone de scripts quand est cliqué avancer de 10 pas tourner de 90 degrés Scène drapeau stop lutin Lutins et arrière-plans (ajouter / choisir un lutin)
Les trois grandes zones de l'interface Scratch : la palette de blocs, la zone de scripts, et la scène avec le drapeau vert et le bouton stop.
📋 Méthode — Faire démarrer (et arrêter) un script
  1. La plupart des scripts commencent par un bloc événement, par exemple quand [drapeau vert] cliqué.
  2. On empile ensuite, sous ce bloc, les instructions à exécuter dans l’ordre.
  3. On clique sur le drapeau vert, en haut de la scène, pour lancer tous les scripts qui commencent par ce bloc.
  4. On clique sur le bouton rouge, à côté du drapeau vert, pour arrêter immédiatement tous les scripts en cours d’exécution.

→ S’entraîner : Exercice 2

3. Dessiner avec le stylo

Constat. Dans un script où le lutin se déplace, rien ne garantit qu’on voie une trace de son parcours sur la scène : par défaut, un lutin qui avance ne laisse aucun trait derrière lui.

Définition. La catégorie Stylo contient les blocs qui permettent de tracer, ou non, le déplacement d’un lutin :

  • effacer tout efface tous les traits déjà dessinés sur la scène ;
  • stylo en position d'écriture fait en sorte que tout déplacement du lutin laisse une trace visible ;
  • relever le stylo fait en sorte que le lutin puisse se déplacer sans rien dessiner.

Exemple. Pour tracer un trait de 100 pas, puis se déplacer de 50 pas sans rien dessiner :

quand [drapeau vert] cliqué
effacer tout
stylo en position d'écriture
avancer de 100
relever le stylo
avancer de 50

Propriété. Pour qu’un script produise toujours le même dessin, même après l’avoir lancé plusieurs fois de suite, on prend l’habitude de le faire commencer par effacer tout, avant de mettre le stylo en position d’écriture.

Le stylo : tracer ou non le déplacement du lutin Les blocs de la catégorie Stylo effacer tout stylo en position d'écriture relever le stylo départ relever le stylo ici arrivée stylo en position d'écriture avancer de 100 — trait visible stylo relevé avancer de 50 — rien de dessiné Habitude : commencer le script par `effacer tout`, avant de mettre le stylo en position d'écriture. trait visible déplacement invisible
Stylo en position d'écriture, le déplacement laisse une trace (trait plein) ; stylo relevé, le lutin se déplace sans rien dessiner (trait pointillé).

→ S’entraîner : Exercice 3

4. Une séquence d’instructions

Définition. Une séquence d’instructions est une suite de blocs exécutés les uns après les autres, dans l’ordre où ils sont empilés.

Exemple. Pour faire tracer un carré de côté 100 par un lutin :

quand [drapeau vert] cliqué
effacer tout
stylo en position d'écriture
avancer de 100
tourner de 90 degrés
avancer de 100
tourner de 90 degrés
avancer de 100
tourner de 90 degrés
avancer de 100
tourner de 90 degrés

Remarque. Ce script fonctionne, mais il répète quatre fois presque le même couple d’instructions. On peut l’écrire plus simplement grâce à une boucle (voir partie 5).

Tracer un carré : une séquence d'instructions quand [drapeau vert] cliqué — effacer tout — stylo en position d'écriture, puis : Le script (8 blocs empilés) 1 avancer de 100 pas tourner de 90 degrés 2 avancer de 100 pas tourner de 90 degrés 3 avancer de 100 pas tourner de 90 degrés 4 avancer de 100 pas tourner de 90 degrés 1 2 3 4 départ
Le script du carré, instruction par instruction : chaque « avancer / tourner » correspond à un côté du carré tracé.

→ S’entraîner : Exercice 4

5. Répéter des instructions : la boucle « répéter »

Définition. Une boucle permet d’exécuter plusieurs fois la ou les mêmes instructions, sans avoir à les recopier. Le bloc répéter ... fois de la catégorie Contrôle est une boucle : tout ce qui est placé à l’intérieur de son encoche est répété le nombre de fois indiqué.

Exemple. Le script du carré de la partie 4 peut s’écrire avec une boucle :

quand [drapeau vert] cliqué
effacer tout
stylo en position d'écriture
répéter 4 fois
    avancer de 100
    tourner de 90 degrés

Ce script produit exactement le même dessin, mais avec deux fois moins de blocs de déplacement.

Propriété. Utiliser une boucle rend un script plus court, plus lisible, et plus facile à modifier : pour tracer un carré plus grand, il suffit de changer une seule valeur (100), alors que sans boucle il aurait fallu la changer à quatre endroits.

📋 Méthode — Choisir le nombre de répétitions d'un polygone régulier

Pour tracer un polygone régulier à nn côtés avec le bloc répéter, on répète nn fois le couple « avancer, tourner », et l’angle de rotation à chaque étape est toujours 360÷n360 \div n degrés (pour un triangle : 360÷3=120°360 \div 3 = 120° ; pour un carré : 360÷4=90°360 \div 4 = 90° ; pour un hexagone : 360÷6=60°360 \div 6 = 60°).

Sans boucle, avec boucle : le même carré tracé Sans boucle (8 blocs) avancer de 100 pas tourner de 90 degrés ⋮ (même motif répété 4 fois en tout — 8 blocs) Avec boucle (4 blocs) répéter 4 fois avancer de 100 pas tourner de 90 degrés (le bloc « avancer / tourner » est répété 4 fois automatiquement) Même carré tracé, deux fois moins de blocs de déplacement.
Sans boucle, huit blocs empilés ; avec boucle, quatre blocs seulement répétés 4 fois : même carré tracé, script deux fois plus court.

→ S’entraîner : Exercice 5

6. Utiliser une variable

Définition. Une variable est un espace de mémoire, désigné par un nom, dans lequel un programme peut stocker une valeur (un nombre ou du texte) et la modifier au cours de son exécution.

Dans Scratch, on crée une variable dans la catégorie Variables, en cliquant sur « Créer une variable » et en lui donnant un nom (par exemple score).

Exemple. Un petit jeu où l’on clique sur un lutin pour gagner des points :

quand [drapeau vert] cliqué
mettre score à 0

quand ce lutin est cliqué
changer score de 1

Au démarrage du jeu, score est remis à 0. Chaque clic sur le lutin ajoute 1 à la valeur actuelle de score.

Vocabulaire. « Mettre la variable à » donne une valeur précise (on efface l’ancienne). « Changer la variable de » ajoute (ou retire, avec un nombre négatif) une valeur à celle déjà stockée.

La variable score : « mettre à » puis « ajouter à » mettre score ▾ à 0 remet « score » à une valeur précise (efface l'ancienne valeur) ajouter 1 à score ▾ ajoute une valeur à celle déjà stockée (retire, si la valeur est négative) score 0 score 1 score 2 état initial lancement (mettre score à 0) clic clic sur le lutin (ajouter 1 à score)
La variable score, remise à 0 au départ (« mettre à »), puis augmentée de 1 à chaque clic (« changer de »).

→ S’entraîner : Exercice 7