Scratch 3ème

Ce cours sur Scratch 3ème vous explique comment écrire, tester et corriger un programme avec le logiciel de programmation par blocs Scratch, comme le demande le programme de mathématiques du collège. Vous verrez les déplacements du lutin, les boucles, les variables, les conditions et les événements, avec des exemples de scripts proches de ceux du brevet. Pour bien comprendre ce chapitre, revoyez le calcul littéral en 3ème (une variable joue le rôle d'une lettre).

Dans ce chapitre, nous allons apprendre à :
  • Repérer le lutin sur la scène et utiliser les blocs de mouvement
  • Écrire une séquence d'instructions et utiliser le stylo
  • Utiliser les boucles pour tracer des polygones réguliers
  • Utiliser des variables, des conditions et des événements
  • Créer des blocs personnalisés
  • Lire un script, le tester et le corriger

1. Découvrir Scratch et le repère de la scène

❧ Définition 1 : Algorithme, programme et Scratch

Un algorithme est une suite d'instructions qui permet de résoudre un problème. Un programme est la traduction d'un algorithme dans un langage informatique.

Scratch est un langage de programmation par blocs : on assemble des blocs pour former un script. Le script est exécuté par un lutin, c'est-à-dire le personnage ou l'objet que l'on programme.

L'écran de Scratch comporte quatre zones :
  • la palette de blocs, où les blocs sont rangés par catégories ;
  • la zone de scripts, où l'on assemble les blocs ;
  • la scène, où le lutin se déplace et dessine ;
  • la liste des lutins.
Éditeur de programmes par blocsPalette de blocsMouvementApparenceSonÉvénementsContrôleCapteursOpérateursVariablesZone de scriptsles blocs sontassemblés iciScènele lutin se déplace iciLutinsLutin1

Chaque catégorie de blocs a sa couleur, ce qui aide à les retrouver :

MouvementApparenceSonÉvénementsContrôleCapteursOpérateursVariablesMes blocsStylo

Pour tracer des figures, il faut ajouter l'extension Stylo (bouton en bas à gauche de l'écran).

❧ Définition 2 : Le repère de la scène

La scène est un repère de centre (0 ; 0). L'abscisse x varie de −240 à 240 et l'ordonnée y de −180 à 180. La position du lutin est donnée par ses coordonnées (x ; y).

La direction du lutin est un angle en degrés :
  • 90 : vers la droite ;
  • −90 : vers la gauche ;
  • 0 : vers le haut ;
  • 180 : vers le bas.
direction 90(droite)direction −90(gauche)direction 0(haut)direction 180(bas)(0 ; 0)(−240 ; 180)(240 ; 180)(−240 ; −180)(240 ; −180)

Remarque : dans Scratch, les longueurs se mesurent en pas (1 pas = 1 unité du repère), et non en centimètres.

☛ Exemples : Le lutin est au point (−120 ; 60).

ajouter 30 à x

La position devient (−90 ; 60).

ajouter −40 à y

La position devient (−120 ; 20).

aller à x : 50 y : −80

La position devient (50 ; −80).

2. Séquences d'instructions et déplacements

❦ Propriété 1 : Ordre des instructions

Un script s'exécute de haut en bas, une instruction après l'autre. L'ordre des blocs change le résultat : on ne peut pas les échanger sans changer le dessin obtenu.

Voici les principaux blocs de mouvement :

avancer de10pastourner ↻ de15degréstourner ↺ de15degréss'orienter à90aller à x:0y:0ajouter10à xmettre x à0ajouter10à ymettre y à0
  • avancer de n pas : déplace le lutin dans sa direction actuelle ;
  • tourner ↻ de n degrés : tourne vers la droite (sens des aiguilles d'une montre) ;
  • tourner ↺ de n degrés : tourne vers la gauche ;
  • s'orienter à n : impose la direction n ;
  • aller à x y : place le lutin au point (x ; y) ;
  • ajouter n à x ou à y : décale le lutin horizontalement ou verticalement.

Attention : tourner de 90 degrés ajoute 90° à la direction actuelle (mouvement relatif), alors que s'orienter à 90 impose la direction 90 quelle que soit la direction actuelle (mouvement absolu).

Mouvement relatif et mouvement absolu

☛ Exemples : Le lutin est dirigé vers la droite (direction 90).

tourner ↻ de 90

Nouvelle direction : 90 + 90 = 180 (vers le bas).

tourner ↺ de 90

Nouvelle direction : 90 − 90 = 0 (vers le haut).

tourner ↻ de 180

Nouvelle direction : 90 + 180 = 270, soit −90 (vers la gauche).

s'orienter à 0

Nouvelle direction : 0 (vers le haut), quelle que soit la direction avant.

Pour laisser une trace, on utilise les blocs de l'extension Stylo :
  • stylo en position d'écriture : le lutin dessine en se déplaçant ;
  • relever le stylo : le lutin se déplace sans dessiner ;
  • effacer tout : efface les tracés précédents.

☛ Exemple : Tracer un carré de côté 100, sans boucle.

quandest cliquéeffacer toutaller à x:0y:0s'orienter à90stylo en position d’écritureavancer de100pastourner ↻ de90degrésavancer de100pastourner ↻ de90degrésavancer de100pastourner ↻ de90degrésavancer de100pastourner ↻ de90degrésrelever le stylo
(0 ; 0)(100 ; 0)(100 ; −100)(0 ; −100)1234

Le lutin part de (0 ; 0), dirigé vers la droite. Il avance de 100 pas, tourne à droite de 90° (il est alors dirigé vers le bas), avance de 100 pas, et ainsi de suite. Après quatre côtés, il est revenu au point de départ. Ce script répète quatre fois les mêmes blocs : une boucle va permettre de l'écrire plus simplement.

Lire un script pas à pas

☛ Exemple : Quelle figure ce script trace-t-il ?

quandest cliquéaller à x:0y:0s'orienter à90stylo en position d’écritureavancer de50pastourner ↺ de90degrésavancer de50pastourner ↺ de90degrésavancer de50pas
(0 ; 0)(50 ; 0)(50 ; 50)(0 ; 50)

Correction : on suit le lutin pas à pas.

  1. Il part de (0 ; 0), direction 90.
  2. Il avance de 50 pas : il est en (50 ; 0).
  3. Il tourne à gauche de 90° : direction 90 − 90 = 0 (vers le haut).
  4. Il avance de 50 pas : il est en (50 ; 50).
  5. Il tourne à gauche de 90° : direction −90 (vers la gauche).
  6. Il avance de 50 pas : il est en (0 ; 50).

Le script trace trois côtés d'un carré de côté 50. Le carré n'est pas fermé : il manque le côté de (0 ; 50) à (0 ; 0).

3. Les boucles : répéter des instructions

❧ Définition 3 : Boucle

Une boucle répète plusieurs fois les mêmes instructions. Scratch propose trois blocs :

  • répéter n fois : le nombre de répétitions est connu à l'avance ;
  • répéter indéfiniment : la boucle ne s'arrête que lorsqu'on arrête le programme ;
  • répéter jusqu'à ce que (condition) : on répète tant que la condition n'est pas vraie.

☛ Exemple : Tracer un carré avec une boucle.

quandest cliquéeffacer toutaller à x:0y:0s'orienter à90stylo en position d’écriturerépéter4foisavancer de100pastourner ↻ de90degrés

Le script est beaucoup plus court : les deux blocs avancer et tourner sont répétés 4 fois.

❦ Propriété 2 : Polygone régulier

Pour tracer un polygone régulier à n côtés de côté c, on répète n fois : avancer de c pas, puis tourner de 360 ÷ n degrés.

En effet, après n rotations égales, le lutin a fait un tour complet (360°). L'angle dont tourne le lutin est l'angle extérieur du polygone. L'angle intérieur vaut 180 − 360 ÷ n.

☛ Exemples : Angle de rotation du lutin selon le nombre de côtés.

n = 3

Triangle équilatéral : 360 ÷ 3 = 120° (angle intérieur 60°).

n = 4

Carré : 360 ÷ 4 = 90° (angle intérieur 90°).

n = 5

Pentagone : 360 ÷ 5 = 72° (angle intérieur 108°).

n = 6

Hexagone : 360 ÷ 6 = 60° (angle intérieur 120°).

n = 8

Octogone : 360 ÷ 8 = 45° (angle intérieur 135°).

n = 10

Décagone : 360 ÷ 10 = 36° (angle intérieur 144°).

Attention : pour un triangle équilatéral, le lutin ne tourne pas de 60° (angle intérieur) mais de 120° (angle extérieur).

Tracer un triangle équilatéral et une rosace

☛ Exemple : Tracer un triangle équilatéral de côté 80.

quandest cliquéeffacer toutaller à x:0y:0s'orienter à90stylo en position d’écriturerépéter3foisavancer de80pastourner ↻ de120degrés
départ120°808080

À chaque sommet, le lutin tourne de 360 ÷ 3 = 120°. Après 3 côtés de 80 pas, il revient au point de départ. Le périmètre du triangle est 3 × 80 = 240 pas.

Une boucle peut contenir une autre boucle : on parle de boucles imbriquées.

☛ Exemple : Tracer une rosace de carrés.

quandest cliquéeffacer toutaller à x:0y:0s'orienter à90stylo en position d’écriturerépéter36foisrépéter4foisavancer de60pastourner ↻ de90degréstourner ↻ de10degrés

La boucle intérieure trace un carré de côté 60. La boucle extérieure répète ce carré 36 fois en tournant de 10° à chaque fois. Comme 36 × 10 = 360, le lutin a fait un tour complet à la fin du script.

4. Les variables

❧ Définition 4 : Variable

Une variable est une « boîte » qui porte un nom et qui contient une valeur (un nombre ou un texte). Cette valeur peut changer pendant l'exécution du programme.

  • mettre [v] à n : donne la valeur n à la variable v (on parle d'initialisation) ;
  • ajouter à [v] n : ajoute n à la valeur actuelle de v (la variable devient v + n) ;
  • on utilise la valeur d'une variable en glissant son nom (pastille orange) dans un autre bloc.

Remarque : il faut toujours initialiser une variable au début du script. Sinon, elle garde la valeur de l'exécution précédente et le résultat peut être faux.

☛ Exemple : Quelle est la valeur de score à la fin du script ?

quandest cliquémettrescore▾à0répéter5foisajouter àscore▾2
Au départ, score = 0. À chaque tour de boucle, on ajoute 2 :
  • après le tour 1 : score = 2 ;
  • après le tour 2 : score = 4 ;
  • après le tour 3 : score = 6 ;
  • après le tour 4 : score = 8 ;
  • après le tour 5 : score = 10.

À la fin du script, score = 10 (5 × 2).

Utiliser une variable dans une figure

☛ Exemple : Tracer un carré dont la taille est une variable.

quandest cliquémettrecôté▾à60effacer toutaller à x:0y:0s'orienter à90stylo en position d’écriturerépéter4foisavancer decôtépastourner ↻ de90degrés

En changeant seulement la valeur de la variable côté (60, 120…), on change la taille du carré. Si on double le côté, le périmètre est multiplié par 2 et l'aire est multipliée par 2² = 4 (voir le chapitre Triangles semblables, agrandissement et réduction 3ème).

☛ Exemple : Une spirale carrée : la variable longueur augmente à chaque tour.

quandest cliquéeffacer toutaller à x:0y:0s'orienter à90stylo en position d’écrituremettrelongueur▾à10répéter6foisavancer delongueurpastourner ↻ de90degrésajouter àlongueur▾10
départ102030405060

À chaque tour, la variable longueur augmente de 10 : les côtés mesurent 10, 20, 30, 40, 50 et 60 pas. La longueur totale du tracé est 10 + 20 + 30 + 40 + 50 + 60 = 210 pas.

5. Les instructions conditionnelles

❧ Définition 5 : Instruction conditionnelle

Une instruction conditionnelle exécute des instructions seulement si une condition est vraie :

  • si … alors : les instructions ne sont exécutées que si la condition est vraie ;
  • si … alors … sinon : un premier groupe d'instructions est exécuté si la condition est vraie, un second groupe sinon.

Une condition est un test qui est soit vrai, soit faux. On la construit avec :

  • des comparaisons : <, > et = ;
  • des opérateurs logiques : et (les deux conditions sont vraies), ou (au moins une condition est vraie), non (contraire de la condition) ;
  • le bloc reste de … divisé par …, pour tester la divisibilité.

Attention : Scratch n'a pas de bloc « ≥ » ni « ≤ ». Pour tester n ≥ 10, on écrit « n > 10 ou n = 10 ». De plus, les comparaisons sont strictes : 18 < 18 est faux.

Tester une condition

☛ Exemple : Un nombre est-il pair ou impair ?

quandest cliquédemanderEntrez un nombreet attendresireste deréponsedivisé par2=0alorsdirepairsinondireimpair

Si l'utilisateur entre 14, le reste de 14 ÷ 2 est 0 : le lutin dit « pair ». S'il entre 7, le reste est 1 : le lutin dit « impair ».

☛ Exemple : Une remise de 10 % à partir de 100 €.

quandest cliquédemanderPrix de l’achat en euros ?et attendresiréponse<100alorsmettreprix final▾àréponsesinonmettreprix final▾àréponse*0,9direprix final

En Scratch, la multiplication se note * et la division /. Le lutin applique la remise seulement si le prix n'est pas inférieur à 100.

Prix entré : 80

80 < 100 est vrai, donc prix final = 80.

Prix entré : 150

150 < 100 est faux, donc prix final = 150 × 0,9 = 135.

☛ Exemple : Combiner deux conditions avec « et ».

sin>10etn<20alorsdireentre 10 et 20
n = 15

15 > 10 et 15 < 20 : la condition est vraie, le lutin dit « entre 10 et 20 ».

n = 20

20 < 20 est faux : la condition est fausse, le lutin ne dit rien.

Répéter jusqu'à une condition

☛ Exemple : Répéter jusqu'à ce qu'une condition soit vraie.

quandest cliquémettren▾à1répéter jusqu’à ce quen>100mettren▾àn*2diren

La variable n vaut d'abord 1, puis 2, 4, 8, 16, 32, 64 et enfin 128. La boucle s'arrête dès que n > 100, donc après 7 tours : le lutin dit 128.

6. Les événements et les scripts en parallèle

❧ Définition 6 : Événement et scripts en parallèle

Un événement déclenche l'exécution d'un script : clic sur le drapeau vert, appui sur une touche, clic sur le lutin, réception d'un message… Chaque script commence par un bloc d'événement (en jaune).

Plusieurs scripts peuvent s'exécuter en même temps : on parle de scripts en parallèle. Les blocs envoyer à tous et quand je reçois permettent de faire communiquer deux scripts ou deux lutins.

☛ Exemple : Déplacer le lutin avec les flèches du clavier.

quand la toucheflèche droite▾est presséeajouter10à x
quand la toucheflèche gauche▾est presséeajouter−10à x
quand la toucheflèche haut▾est presséeajouter10à y
quand la toucheflèche bas▾est presséeajouter−10à y

Chaque appui sur une flèche déclenche son propre script : le lutin se déplace de 10 pas dans la direction choisie.

☛ Exemple : Un jeu : attraper le lutin avec la souris.

quandest cliquémettrescore▾à0aller à x:0y:0
quand ce lutin est cliquéajouter àscore▾1mettre x ànombre aléatoire entre−200et200mettre y ànombre aléatoire entre−150et150

Le premier script prépare le jeu. Le second se déclenche à chaque clic sur le lutin : le score augmente de 1 et le lutin se place ailleurs, avec des coordonnées choisies au hasard. Les deux scripts sont indépendants.

7. Interagir avec l'utilisateur

Un programme peut dialoguer avec l'utilisateur :
  • demander … et attendre : affiche une question ; ce que l'utilisateur tape est stocké dans le bloc réponse ;
  • nombre aléatoire entre a et b : choisit un nombre au hasard ;
  • dire … : affiche un message ou la valeur d'une variable.

☛ Exemple : Calculer l'aire d'un rectangle.

quandest cliquédemanderLongueur ?et attendremettrelongueur▾àréponsedemanderLargeur ?et attendremettrelargeur▾àréponsemettreaire▾àlongueur*largeurdireaire

Avec longueur = 8 et largeur = 5, le lutin dit 40. On a stocké chaque réponse dans une variable pour pouvoir les multiplier.

☛ Exemple : Le jeu du nombre mystère.

quandest cliquémettresecret▾ànombre aléatoire entre1et100demanderDevinez le nombreet attendrerépéter jusqu’à ce queréponse=secretsiréponse<secretalorsdireTrop petitsinondireTrop granddemanderEssayez encoreet attendredireBravo !

Ce programme utilise tout ce que vous avez vu : une variable (secret), un nombre aléatoire, une boucle « répéter jusqu'à ce que », une condition « si … sinon » et une interaction avec l'utilisateur. À chaque essai, le lutin indique si le nombre proposé est trop petit ou trop grand.

8. Les blocs personnalisés

❧ Définition 7 : Bloc personnalisé

Un bloc personnalisé (catégorie « Mes blocs ») regroupe une suite d'instructions sous un nom. On le définit une seule fois, puis on l'utilise autant de fois que nécessaire.

Il peut avoir un paramètre, par exemple la longueur du côté. Les blocs personnalisés permettent de décomposer un problème en sous-problèmes plus simples et de rendre un script plus lisible.

☛ Exemple : Un bloc carré avec un paramètre côté.

définir carrécôtérépéter4foisavancer decôtépastourner ↻ de90degrés
quandest cliquéeffacer toutaller à x:0y:0s'orienter à90stylo en position d’écriturecarré50carré100
départ50100

Le bloc carré 50 trace un carré de côté 50, le bloc carré 100 un carré de côté 100. Les deux carrés partent du même sommet. L'aire du grand carré est 4 fois celle du petit : 100² = 4 × 50².

☛ Exemple : La rosace, écrite avec le bloc carré.

quandest cliquéeffacer toutaller à x:0y:0s'orienter à90stylo en position d’écriturerépéter36foiscarré60tourner ↻ de10degrés

Le script est plus lisible : on répète 36 fois « carré 60 » puis « tourner de 10° ». Il trace la même rosace qu'avec les boucles imbriquées.

9. Lire, tester et corriger un programme

❧ Définition 8 : Méthode pour lire, tester et corriger un script

  1. Lire le script de haut en bas en repérant les variables et leurs valeurs initiales.
  2. Suivre l'exécution pas à pas, avec un tableau de suivi (position, direction, valeur des variables).
  3. Prévoir le résultat, puis tester le programme avec plusieurs valeurs.
  4. Corriger le script si le résultat n'est pas celui attendu.
Erreurs fréquentes :
  • confondre l'angle intérieur (60° pour un triangle équilatéral) et l'angle dont tourne le lutin (120°) ;
  • oublier d'initialiser une variable ;
  • confondre s'orienter à (absolu) et tourner (relatif), ou la droite ↻ et la gauche ↺ ;
  • oublier le bloc stylo en position d'écriture ou effacer tout ;
  • placer un bloc à l'intérieur de la boucle alors qu'il devrait être avant ou après ;
  • oublier que les comparaisons sont strictes (18 < 18 est faux).

☛ Exercice 1 : Quelle figure trace ce script ?

quandest cliquéeffacer toutaller à x:-100y:0s'orienter à90stylo en position d’écriturerépéter3foisavancer de100pastourner ↺ de120degrés
  1. Quelle figure le script trace-t-il ?
  2. Quelle est la longueur totale du tracé ?
  3. On remplace 3 par 6 et 120 par 60. Quelle figure obtient-on ?

Correction :

  1. Le lutin tourne de 120° à gauche, 3 fois : 3 × 120 = 360, il revient au départ. Le script trace un triangle équilatéral de côté 100, dont le premier côté va de (−100 ; 0) à (0 ; 0) et qui se situe au-dessus de ce côté.
  2. La longueur totale est 3 × 100 = 300 pas.
  3. Avec 6 répétitions et 60° (360 ÷ 6 = 60), le script trace un hexagone régulier de côté 100, de longueur totale 6 × 100 = 600 pas.

Reconnaître et écrire un script

☛ Exercice 2 : Écrire un script qui trace un rectangle de longueur 150 et de largeur 80.

Correction : un rectangle a deux longueurs et deux largeurs. On répète 2 fois : avancer de 150, tourner de 90°, avancer de 80, tourner de 90°.

quandest cliquéeffacer toutaller à x:0y:0s'orienter à90stylo en position d’écriturerépéter2foisavancer de150pastourner ↻ de90degrésavancer de80pastourner ↻ de90degrés

Le périmètre du rectangle est 2 × (150 + 80) = 460 pas.

☛ Exercice 3 : Quelle valeur le lutin dit-il à la fin de ce script ?

quandest cliquémettren▾à0mettres▾à0répéter5foisajouter àn▾1ajouter às▾ndires

Correction : on suit les valeurs de n et de s à chaque tour.

Tour 1

n = 1 et s = 0 + 1 = 1.

Tour 2

n = 2 et s = 1 + 2 = 3.

Tour 3

n = 3 et s = 3 + 3 = 6.

Tour 4

n = 4 et s = 6 + 4 = 10.

Tour 5

n = 5 et s = 10 + 5 = 15.

Le lutin dit 15 : c'est la somme 1 + 2 + 3 + 4 + 5.

Conditions et polygones réguliers

☛ Exercice 4 : Que dit le lutin si l'utilisateur entre 15, puis 18, puis 45 ?

quandest cliquédemanderQuel est votre âge ?et attendresiréponse<18alorsdireTarif réduitsinondirePlein tarif

Correction :

Réponse : 15

15 < 18 est vrai : le lutin dit « Tarif réduit ».

Réponse : 18

18 < 18 est faux : le lutin dit « Plein tarif ».

Réponse : 45

45 < 18 est faux : le lutin dit « Plein tarif ».

Pour que 18 ans donne le tarif réduit, il faudrait tester « réponse < 18 ou réponse = 18 ».

☛ Exercice 5 : Écrire un script qui trace un pentagone régulier de côté 70.

Correction : un pentagone a 5 côtés, donc le lutin tourne de 360 ÷ 5 = 72° à chaque sommet (l'angle intérieur du pentagone vaut 180 − 72 = 108°).

quandest cliquéeffacer toutaller à x:0y:0s'orienter à90stylo en position d’écriturerépéter5foisavancer de70pastourner ↻ de72degrés

Le périmètre du pentagone est 5 × 70 = 350 pas.

❦ À retenir

  • Un script s'exécute de haut en bas ; la scène est un repère de centre (0 ; 0), la direction 90 est vers la droite.
  • Polygone régulier à n côtés : répéter n fois « avancer, tourner de 360 ÷ n degrés ».
  • Une variable se crée, s'initialise (mettre à) et se modifie (ajouter à).
  • Une condition est vraie ou fausse ; on l'utilise avec si … alors … sinon ou répéter jusqu'à ce que.
  • Un événement déclenche un script ; plusieurs scripts peuvent s'exécuter en parallèle.
  • Un bloc personnalisé décompose un problème en sous-problèmes.

Pour plus de vidéos, découvrez la chaîne YouTube FormaMaths.

Ce chapitre sur Scratch 3ème vous a permis de comprendre comment écrire, tester et corriger un programme avec des boucles, des variables, des conditions et des événements.

Grâce à ce chapitre, vous savez tracer des polygones réguliers, suivre l'exécution d'un script pas à pas et réutiliser vos instructions avec des blocs personnalisés.

Prochaines étapes

La pratique régulière est essentielle pour maîtriser la programmation. Pour progresser :

N'hésitez pas à utiliser les ressources complémentaires sur la chaîne YouTube FormaMaths pour des explications visuelles, ou bien à prendre des cours particuliers. Vous pouvez essayer dès maintenant, gratuitement et sans condition, nos cours particuliers.