Programmation en BlocklyScratch
BlocklyScratch permet de créer des
programmes à partir de blocs.
Par exemple, un bloc avancer vers la droite peut faire déplacer un robot d'une
case vers la droite.
Un programme formé de blocs les uns en dessous des autres, exécute ces instructions l'une après l'autre.
 |
Le programme ci-contre fait déplacer le robot vers la droite, puis vers le haut, puis de nouveau
vers la droite.
|
Programmation en Python
Python permet de créer des programmes à partir d'instructions.
Par exemple, l'instruction droite() peut faire déplacer un robot d'une case vers la droite.
Un programme formé d'instructions les unes en dessous des autres, exécute ces instructions l'une après
l'autre.
|
from robot import *
droite()
haut()
droite()
|
Le programme ci-contre fait déplacer le robot vers la droite, puis vers le haut, puis de nouveau
vers la droite.
|
Boucle de répétition
Pour exécuter plusieurs fois la même instruction, on peut utiliser
le bloc « répéter »l'instruction
for loop in range(...).
Par exemple, plutôt que de mettre 5 fois le même bloc :
On peut utiliser un bloc « répéter 5 fois » :
Pour changer le nombre de répétitions, cliquer sur ce nombre et taper la nouvelle valeur au clavier.
Par exemple, plutôt que de mettre 5 fois la même instruction :
droite()
droite()
droite()
droite()
droite()
On peut écrire la boucle suivante :
for loop in range(5):
droite()
On peut aussi mettre plusieurs instructions dans une boucle :
for loop in range(5):
droite()
haut()
L'instruction pass apparaît lorsqu'on choisit le mot-clé for dans les blocs
disponibles.
Elle sert seulement à éviter les erreurs lors de l'implémentation de boucles.
En effet, les boucles doivent contenir au moins une instruction. Cela permet d'exécuter le script sans
rencontrer d'erreur si jamais on souhaite tester le code en-dessous. En général, dans le programme finalisé on ne retrouvera jamais de pass.
Boucles imbriquées
Il est possible d'utiliser des boucles imbriquées, c'est-à-dire que l'on peut mettre des
blocs « répéter »boucles
for,
à l'intérieur d'autres
blocs « répéter »boucles
for.
Par exemple :
for loop in range(5):
droite()
for loop_2 in range(3):
haut()
droite()
|
Ce programme répétera 5 fois un déplacement d'1 case vers la droite, 3 cases vers le haut et 1 case
vers la droite.
|
Il est d'usage dans les boucles imbriquées de changer la variable d'incrémentation (loop et
loop_2 dans l'exemple au-dessus) pour ne pas avoir d'effets de bord. Ce sont des effets indésirables dus aux variables qui ont le même nom.
Le bloc « si »L'instruction
if
Avec
le bloc « si »,
l'instruction if,
on peut exécuter une instruction uniquement dans certaines conditions.
if caseMarquee():
peindre()
|
Par exemple, le programme ci-contre teste le contenu de la case du robot, et ne la peint que si elle
est marquée.
|
On peut aussi placer plusieurs instructions dans
un bloc « si »,
une instruction if,
comme illustré ci-dessous :
if caseMarquee():
peindre()
droite()
Le bloc « si / sinon »l'instruction
if / else
On peut utiliser
un bloc « si / sinon »,
une instruction if / else,
pour effectuer des opérations différentes selon la situation. Par exemple :
|
if caseMarquee():
peindre()
else:
haut()
|
Dans le programme ci-contre, si la case du robot est marquée, le robot la peint, sinon il ne la peint
pas mais se déplace vers le haut.
|
Le mot-clé elif sert à ajouter autant de conditions précises souhaitées. Il se place entre les
mots-clés if et else au même niveau d'indentation.
if colonne() == 1:
peindre()
elif colonne() == 4:
droite()
else:
gauche()
Le bloc « répéter indéfiniment »
La boucle infinie
On peut utiliser
un bloc « répéter indéfiniment »
l'instruction while True:
pour répéter sans fin une séquence d'instructions, comme dans l'exemple ci-dessous, qui allume et éteint une
LED toutes les 500 millisecondes :
while True:
allumerLED()
attendre(1000)
eteindreLED()
attendre(1000)
L'instruction « while True: » exécute en boucle les instructions placées en dessous, indentées vers la droite,
sans s'arrêter, jusqu'à ce que l'on interrompe l'exécution du programme.
Ce type de boucle est utile pour les programmes qui ne doivent jamais s'arrêter, par exemple le programme d'un
système d'alarme, qui doit être actif en permanence.
Le bloc « répéter tant que »
Le bloc « répéter jusqu'à »
l'instruction while
On peut utiliser
un bloc « répéter tant que », ou
un bloc « répéter jusqu'à »,
une instruction while,
comme dans l'exemple ci-dessous.
ou
Le bloc « répéter tant que » exécute en boucle les instructions placées à l'intérieur, tant que la condition
est vraie. Si la condition est fausse dès le départ, les instructions ne sont jamais exécutées.
Le bloc « répéter jusqu'à » exécute en boucle les instructions placées à l'intérieur, jusqu'à-ce que la
condition devienne vraie. Si la condition est vraie dès le départ, les instructions ne sont jamais exécutées.
while not surTrou():
droite()
L'instruction « while » exécute en boucle les instructions placés en dessous, indentées vers la droite, tant
que la condition est vraie. Si la condition est fausse dès le départ, les instructions ne sont jamais
exécutées.
Ce type de boucle est utile lorsque l'on ne connaît pas à l'avance le nombre de répétitions.
Par exemple dans un cas comme ci-dessous, où l'on ne connaît pas le nombre de cases entre la bille et le trou
où il faut la déposer.
Les opérateurs logiques (booléens)
On peut tester deux conditions, et exécuter des instructions si l'une des deux est vraie, grâce à l'opérateur
logique or.
if ((colonne() < 0) or (colonne() > 8)):
peindre()
L'instruction au sein du bloc sera exécutée soit si la colonne est inférieure à 0, soit si elle est supérieure
à 8.
Si l'on ne veut exécuter des instructions que si deux conditions sont vraies, on peut utiliser l'opérateur
logique and.
if ((colonne() > 0) and (colonne() < 8)):
peindre()
L'instruction au sein du bloc sera exécutée si la colonne est supérieure à 0 et si elle est inférieure
à 8.
Si on veut le contraire, on peut utiliser l'opérateur logique not.
if not (((colonne() > 0) and (colonne() < 8))):
peindre()
L'instruction au sein du bloc ne sera pas exécutée si la colonne est supérieure à 0 et si elle est inférieure
à 8.
Les conditions
Les conditions permettent à l'ordinateur de prendre des décisions suivant le résultat de la condition.
Ce résultat peut être soit vrai (True), soit faux (False), ces deux éléments étant des booléens.
Une condition peut être plusieurs choses, par exemple :
- Un résultat de fonction
if surTrou():
- Une comparaison
while colonne() < 0:
- Une combinaison de tout ceci avec des opérateurs logiques
if ((colonne() < 0) or surTrou():
et elle peut se trouver dans un
if ou dans un
while.
Pour les comparaisons, il y a différents comparateurs. Les comparaisons qui permettent de déterminer un ordre
(<, >, >=, <=) et celles qui permettent de déterminer une différence (== signifiant "égal à" et
!= signifiant "différent de")
Fonctions avec arguments
Pour certaines instructions, tu dois fournir à TOBOR des détails que l'on appelle « arguments ».
Par exemple, pour l'instruction « déplacer », tu as besoin de deux arguments, la position de départ et la
position d'arrivée.
En Blockly, il suffit de remplir les deux cases d'arguments :
En Python, il faut mettre les deux arguments à l'intérieur des parenthèses :
deplacer(1, 3)
Cette instruction demande à TOBOR de déplacer une pierre de la position 1 à la position 3.
Variables
Pour enregistrer une valeur à un moment du programme et l'utiliser plus tard, on utilise une « variable ». Il
s'agit d'une
zone dans mémoire de l'ordinateur, à laquelle on donne un nom, et dans laquelle on peut peut stocker une
information pour l'utiliser
plus tard.
On peut penser à une variable comme une boîte avec une étiquette, le nom de la variable.
Avant de l’utiliser, on crée d’abord la boîte en lui donnant un nom : on déclare la variable.
Lorsqu’on stocke une information à l’intérieur de la boîte, on dit qu’on affecte une valeur à
la variable. Des lettres en majuscules ou minuscules, des entiers et des underscores (_)
peuvent composer un nom de variable. Par contre, il ne peut pas commencer par un entier, ni contenir des
caractères avec accents. La casse est aussi prise en compte pour les noms de variable (maVariable et MaVariable sont différentes).
Pour stocker une valeur dans cette variable, par exemple le nombre inscrit sur la case du robot, on fait comme
ceci :
memoireRobot = nombreSurCase()
Plus tard, pour utiliser la valeur stockée dans cette variable, et par exemple l'écrire sur la case du robot,
on fait comme ceci :
ecrireNombre(memoireRobot)
Après avoir enregistré une valeur dans une variable, on peut la modifier, par exemple, en lui ajoutant un
nombre :
memoireRobot = memoireRobot + nombreSurCase()
Listes
Une liste est une variable contenant plusieurs cases numérotées. On peut stocker une valeur dans chacune de ces
cases.
Pour créer une liste, on peut indiquer combien de cases elle doit contenir, et la valeur initiale de chaque
case :
exempleListe = [0]*5
Cette liste contient alors 5 cases, numérotées de 1 à 50 à 4, chacune ayant comme valeur initiale 0.
Une fois la liste créée, on peut enregistrer une valeur dans l'une de ses cases, en indiquant le numéro de la
case (l'indice) :
exempleListe[2] = 3
On peut aussi lire la valeur stockée dans une case :
nombre = exempleListe[2]
Fonctions
Lorsque vous avez besoin de faire la même chose à plusieurs endroits de votre programme, plutôt que de réécrire
plusieurs fois le
même bout de programme, vous pouvez l'écrire une seule fois et lui donner un nom, qui pourra être utilisé comme
une nouvelle instruction.
C'est ce que l'on appelle créer une fonction.
Voici un exemple de fonction, qui peint deux cases l'une au dessus de l'autre puis revient à sa position de
départ :
def cactus():
peindre()
haut()
peindre()
bas()
Et voici un exemple de programme qui utilise cette fonction, et son résultat :
droite()
cactus()
droite()
droite()
cactus()
Si vous voulez que votre fonction fasse quelque-chose de différent selon la valeur d'une variable, vous pouvez
lui ajouter un (ou plusieurs) paramètres.
Pour ajouter un paramètre d'entrée à une fonction, cliquez sur l'icone d'engrenage en haut à gauche du bloc.
Glissez alors des entrées de la partie gauche vers l'intérieur du bloc de la partie droite, puis choisissez le
nom du paramètre. Voici un exemple d'une fonction qui prend un nombre d'étapes en paramètre d'entrée et déplace
le robot de ce nombre de cases vers la droite :
Pour ajouter des paramètres d'entrée à une fonction, mettez le nom de ces paramètres entre les parenthèses,
séparés par des virgules. Voici un exemple de fonction qui prend deux paramètres nbEtapesBas et nbEtapesDroite,
et effectue le déplacement correspondant. L'exemple d'appel entraîne un déplacement de 3 cases vers le bas puis
5 cases vers la droite :
from robot import *
def deplacementBasDroite(nbEtapesBas, nbEtapesDroite):
for loop in range(nbEtapesBas):
bas()
for loop in range(nbEtapesDroite):
droite()
deplacementBasDroite(3, 5)
Affichage de texte
Pour que ton robot affiche du texte, il faut accrocher les deux blocs suivants :
Avec ton clavier, tape le texte que tu veux afficher entre les guillemets.
En python, pour afficher du texte, on utilise le mot clé print ( )
A l’intérieur des parenthèses, on place le texte à afficher entre guillemets.
Exemple :
print("Texte à afficher")
Affichage de texte consécutif
Lors des programmes précédents, TOBOR affichait chaque texte que tu lui demandais sur une ligne différente.
Mais si tu souhaites afficher plusieurs caractères à la suite, sans aller à la ligne à chaque fois, il te
faut utiliser une instruction différente.
En Blockly, tu peux utiliser le bloc « afficher », comme ceci :
En Python, tu peux utiliser l'instruction print("Texte", end=""), comme ceci :
print("Bonjour ", end="")
print("Camthalion !", end="")
print("") // Retourne à la ligne
print("Je m'appelle ", end="")
print("TOBOR !") // Retourne à la ligne aussi
Cela affichera :
Bonjour Camthalion !
Je m'appelle TOBOR !
Lecture de l'entrée
Ce bloc permet de demander une information à l’utilisateur.
On stocke l’’information dans une variable. Il faut choisir la variable dans le menu, parmi les variables
déjà crées.
Pour demander une information à l’utilisateur d’un programme, on utilise le mot-clé input.
On stocke l’information que l’utilisateur nous donne dans une variable. Tu dois aussi indiquer dans ton
programme le type de donnée que tu vas demander.
Le type indique quelle sorte d’information tu vas stocker dans la variable. Pour l’instant, tu vas
stocker des nombres entiers : c’est le type int.
Exemple :
age=int (input())
print(age)
Si l'utilisateur entre 12, le programme affichera 12. S'il entre 15, le programme affichera 15.
Chaîne de caractères
Le langage python permet de manipuler du texte, sous une forme que l'on appelle chaîne de
caractères.
Une chaîne de caractères est une suite de caractères, où chaque caractère peut être une lettre de
l'alphabet accuentuée ou non, un chifre, une espace, ou toutes sortes de caractères spéciaux comme $, @,
etc. ainsi que des caractères de contrôle comme le retour à la ligne, la tabulation, etc. Les caractères
peuvent aussi être des caractères de toutes sortes de langues, comme par exemple des caractères chinoix.
On peut créer une chaîne de caractères python en mettant du texte entre guillemets. Voici quelques
exemples de chaînes :
"Exemple de chaîne"
"$224#%(]}"
"\n\r"
"你好"
Une chaîne peut être stockée dans une variable, transmise en paramètres à une fonction, etc.
Comparaison de chaînes
Pour comparer deux chaines de caractères, on peut utiliser les comparateurs >=, >, ==, !=,
qui permettent de les comparer suivant l'ordre alphabétique.
Longueur d'une chaîne
Pour connaître le nombre de caractères contenus dans une chaîne, on peut utiliser la fonction
len() en lui passant la chaîne en paramètre.
Par exemple, len("coucou") retournera 6.
Concaténer deux chaînes
Il est possible de former une chaîne de caractères, en mettant bout à bout deux chaînes de caractères. On
utilise pour cela l'opérateur +. Par exemple :
texte = "bonjour " + "monde"
texte += " !"
À la fin de ce programme, la variable texte contiendra la chaîne "bonjour monde !"
Extraire un caractère d'une chaîne
Il est possible d'obtenir la valeur d'un caractère particulier d'une chaîne. On utilise pour cela des
crochets, en mettant entre les crochets, l'indice du caractère que l'on souhaite obtenir au sein de la
chaîne. Le premier caractère a pour indice 0, le suivant pour indice 1, etc.
Voici un exemple où l'on obtient la première et la dernière lettre d'une chaîne :
texte = "bonjour monde !"
premiereLettre = texte[0]
derniereLettre = texte[len(texte) - 1]