python-online

crahCourse

Deutsch English Français

COURS ACCÉLÉRÉ DE PYTHON

TU APPRENDRAS ICI...

les notions essentielles de la programmation en Python à l'aide d'exemples simples mettant en scène un petit insecte lumineux (Glowbug), que tu peux déplacer sur l'écran du micro:bit avec les commandes forward(), left(), right() et back(). Si tu as déjà étudié le chapitre consacré au graphisme avec la tortue en Python ou si tu possèdes des connaissances de base équivalentes en Python, tu peux sauter ce chapitre et passer directement au point suivant du menu.

STRUCTURE D'UN PROGRAMME : SÉQUENCE

Un programme informatique est constitué d'une suite d'instructions exécutées les unes après les autres, dans un ordre précis (séquence). Pour pouvoir utiliser les commandes de l'insecte, tu dois importer le module mbglow avec from mbglow import *.

La commande makeGlow() crée un insecte visible au centre de l'écran. Il s'agit simplement d'une LED allumée. Lorsque l'insecte se déplace, les LED correspondant aux positions parcourues s'allument. Il laisse donc une sorte de trace derrière lui.

Tes commandes sont exécutées après le transfert du programme sur le micro:bit.

Les commandes sont généralement écrites en anglais et se terminent toujours par des parenthèses. Celles-ci peuvent contenir des paramètres supplémentaires. Tu dois respecter exactement les majuscules et les minuscules.

Avec forward(), l'insecte avance d'un pas dans sa direction actuelle. Au démarrage du programme, il est orienté vers le haut. Avec left(90), il tourne de 90 degrés vers la gauche et avec right(90), de 90 degrés vers la droite. Toutefois, ce changement de direction ne devient visible qu'à la prochaine commande forward().

on programme dessine la trace représentée sur la figure ci-contre.

Programme:

from mbglow import *

makeGlow()

forward()
left(90)
forward()
right(90)
forward()

►Copy to clipboard

En cliquant sur le bouton « WebTigerPython », le programme est chargé dans WebTigerPython et peut être exécuté immédiatement. Si WebTigerPython est déjà ouvert, clique sur « Copier dans le presse-papiers », puis insère le programme dans la fenêtre de l'éditeur avec Ctrl+V.

RÉPÉTITION AVEC REPEAT

Pour parcourir un carré, l'insecte doit exécuter quatre fois les commandes forward() et left(90). Tu peux éviter beaucoup de travail de saisie en utilisant une boucle de répétition.

Il te suffit d'écrire repeat 4: (les deux-points sont importants). Toutes les commandes à répéter doivent avoir la même indentation. Pour cela, tu utilises quatre espaces ou la touche de tabulation.

Programme:

from mbglow import *

makeGlow()

repeat 4:
    forward()
    left(90)

►Copy to clipboard

Tu souhaites maintenant dessiner un carré aussi grand que possible. Pour cela, tu places l'insecte dans le coin inférieur gauche avec setPos(-2, -2).. La commande setPos(x, y),permet donc de placer l'insecte à une nouvelle position quelconque. Pour qu'il reste visible, tu dois choisir pour x et y les valeurs -2, -1, 0, 1 ou 2..

Pour dessiner un côté du carré, tu fais avancer l'insecte quatre fois. Tu peux également utiliser une boucle repeat pour ces quatre pas. Ton programme contient donc deux boucles repeat imbriquées.

Veille à respecter correctement l'indentation !

Programme:

from mbglow import *

makeGlow()

setPos(-2, -2)
repeat 4:
    repeat 4:
        forward()
    right(90)

►Copy to clipboard

FONCTIONS (BLOCS DE PROGRAMME NOMMÉS)

Les blocs de programme nommés, appelés fonctions en Python, rendent tes programmes plus clairs. De plus, tu peux appeler une fonction plusieurs fois. L'utilisation des fonctions est très importante, car elle permet d'éviter d'écrire plusieurs fois le même code dans un programme (duplication de code) et de décomposer un problème en plusieurs problèmes plus petits.

Dans ton exemple, tu définis une fonction square() qui fait déplacer l'insecte le long d'un carré.

La définition d'une fonctioncommence par le mot-clé def. Viennent ensuite le nom de la fonction, des parenthèses et deux-points. Les instructions du corps de la fonction doivent être indentées. Remarque que les instructions ne sont exécutées que lorsque la fonction est appelée . Les définitions des fonctions se trouvent généralement dans la partie supérieure du programme.

Choisis un nom de fonction qui indique ce que fait la fonction. Tu ne dois pas utiliser de caractères spéciaux (espaces, trémas, accents, signes de ponctuation, etc.). Commence toujours le nom par une lettre minuscule. Dans le programme suivant, tu définis une fonction square() qui dessine un carré, puis tu l'exécutes.

Programme:

from mbglow import *

makeGlow()

def square():
    repeat 4:
        forward()
        forward()
        left(90)

square()

►Copy to clipboard

En définissant square(), tu as en quelque sorte créé une nouvelle commande que tu peux maintenant utiliser autant de fois que tu le souhaites. Pour obtenir la figure ci-contre, tu appelles la fonction square() quatre fois.
Avec la commande setSpeed(80), l'insecte se déplace plus rapidement. La valeur par défaut est 50 et les valeurs autorisées sont comprises entre 0 et 100.

Programme:

from mbglow import *

makeGlow()

def square():
    repeat 4:
        forward()
        forward()
        left(90)

setSpeed(80)
repeat 4:
    square()
    right(90)

►Copy to clipboard

VARIABLES

En informatique, les variables sont des emplacements qui contiennent des valeurs pouvant changer pendant l'exécution d'un programme. Une variable possède donc un nom et une valeur. La variable v représente la vitesse de l'insecte.

Avec v = 30 , tu attribues à v la valeur initiale 30. Cette instruction est appelée une affectation. Après chaque carré parcouru, la valeur de v augmente de 20.

our cela, tu utilises l'instruction v = v + 20 , qui ressemble à première vue à une équation absurde. Elle indique cependant à l'ordinateur de prendre la valeur actuelle de v, d'y ajouter 20, puis d'enregistrer le résultat dans v. La commande showTrace(False) empêche l'insecte de laisser une trace derrière lui.

Programme:

from mbglow import *

makeGlow()

def square():
    repeat 4:
        forward()
        forward()
        right(90)
    
v = 30
showTrace(False)
setPos(-1, -1)

repeat 4:
    setSpeed(v)
    square()
    v = v + 20

►Copy to clipboard

RÉPÉTITION AVEC WHILE

La boucle while est l'une des structures de programmation les plus importantes. Elle peut être utilisée pour toutes sortes de répétitions et existe dans pratiquement tous les langages de programmation. Une boucle whilecommence par le mot-clé while, suivi d'une condition et de deux-points. Tant que la condition est remplie, les instructions du bloc suivant sont répétées. Dans le langage courant, on pourrait exprimer cela ainsi : Tant que la condition est vraie, exécute... Dans les conditions, on utilise généralement les opérateurs de comparaison suivants :

Opérateur	Signification
<	inférieur à
<=	inférieur ou égal à
>	supérieur à
>=	supérieur ou égal à
==	égal à
!=	différent de

Remarque que le signe égal est doublé lorsqu'on teste une égalité, afin de ne pas le confondre avec une affectation.

IDans ton exemple, l'insecte avance d'abord de deux pas, recule ensuite de deux pas, tourne de 45°, puis avance à nouveau de deux pas, et ainsi de suite, jusqu'à ce qu'il soit de nouveau orienté vers le nord. Tu enregistres l'angle total de rotation dans la variable a. Tu commences avec a = 0 et tu ajoutes 45 après chaque passage dans la boucle. Tant que la condition a <= 360 iest vraie, les instructions indentées sont exécutées.

Programme:

from mbglow import *

makeGlow()

setSpeed(90)
showTrace(False)
a = 0
while a <= 360:
    forward()
    forward()
    back()
    back()
    left(45)    
    a = a + 45

►Copy to clipboard

En robotique, on utilise souvent une boucle while dite infinie. Elle commence par while True:Comme True est toujours vrai, la boucle est exécutée jusqu'à ce que tu arrêtes le programme en cliquant sur le symbole de connexion ou en coupant l'alimentation électrique du micro:bit. La commande. clear()éteint toutes les LED.

Programme:

from mbglow  import *

makeGlow()

def square():
    repeat 4:
        forward()
        forward()
        left(90)

clear()
setSpeed(90)
showTrace(False)
setPos(2, 0)
left(45)
while True:
    square()

►Copy to clipboard

RÉPÉTITION AVEC FOR IN RANGE

Dans une boucle de répétition, tu as souvent besoin d'une variable entière qui augmente de un à chaque passage. Tu peux bien sûr résoudre ce problème avec une boucle while, mais il est plus simple d'utiliser une boucle for, dans laquelle le compteur est modifié automatiquement.
for i in range(n) parcourt les nombres entiers de 0 à n-1.
for i in range(a, b) parcourt les nombres entiers de a à b-1.

Remarque que la valeur finale n ou b n'est jamais incluse.

Avec for x in range(-2, 3) ,la variable x prend donc successivement les valeurs -2, -1, 0, 1 et 2. Les LED de la rangée supérieure s'allument alors les unes après les autres. Avec sleep(500), tu peux interrompre l'exécution du programme pendant 500 millisecondes afin de mieux observer son déroulement.

Programme:

from mbglow import *

makeGlow()

clear()
for x in range(-2, 3):
    setPos(x, 2)
    sleep(500)

►Copy to clipboard

STRUCTURE IF - ELSE (SÉLECTION)

La sélection permet d'exécuter certains blocs de programme uniquement lorsque des conditions particulières sont remplies. Elle commence par le mot-clé if, suivi d'une condition. Les instructions du bloc if ne sont exécutées que si la condition est vraie. Sinon, les instructions qui suivent else sont exécutées. Dans une condition if, on utilise généralement les opérateurs de comparaison >, >=, <, <=, == et !=. Les instructions des blocs if et else doivent être indentées. La partie else peut également être omise.

Dans cet exemple, l'insecte se déplace vers la droite. Lorsqu'il atteint le bord droit, il revient au bord gauche et répète indéfiniment ce déplacement de gauche à droite. Tu fais donc avancer l'insecte vers la droite avec forward() et tu vérifies sa coordonnée x après chaque pas. Si celle-ci vaut 3,l'insecte est replacé au bord gauche (x = -2).

Programme:

from mbglow import *

makeGlow()

right(90)
x = 0
showTrace(False) 

while True:
    forward()
    x = x + 1  
    if x == 3:
        setPos(-2, 0)        
        x = -2

►Copy to clipboard

Dans le programme suivant, l'insecte doit avancer de deux pas ou reculer de deux pas de manière aléatoire, puis s'arrêter brièvement, effacer sa trace et revenir à sa position initiale. Il doit répéter ce mouvement 10 fois.

Tu utilises des nombres aléatoires. La fonction randint(a, b) du module random génère un nombre entier aléatoire compris entre a et b, bornes incluses.

La fonction randint(0, 1)renvoie donc aléatoirement 0 ou 1. Si la valeur est 1, Sinon, lorsque la valeur est 0, il recule de deux pas.

Programme:

from mbglow import *
from random import randint

makeGlow()
setSpeed(80)
repeat 10:    
    r = randint(0, 1)
    if r == 1:
        forward()
        forward()
    else:
        back()
        back()     
    sleep(300)
    clear()
    setPos(0, 0)

►Copy to clipboard

À RETENIR...

Les structures fondamentales de la programmation sont la séquence, la répétition et la sélection. Dans une séquence, les instructions sont exécutées les unes après les autres.

Une répétition permet d'exécuter plusieurs fois un bloc de programme. Dans TigerJython, tu peux utiliser pour cela les boucles repeat, while ou for.

La sélection avec if et else permet d'exécuter certaines instructions uniquement lorsque des conditions particulières sont remplies. La partie else est facultative.

Les fonctions sont importantes pour la programmation structurée. Elles permettent d'éviter la duplication du code et de décomposer les problèmes en sous-problèmes plus petits. On parle également de modularisation.

EXERCICES À RÉSOUDRE

Écris un programme utilisant une structure de répétition repeat, de manière à ce que l'insecte lumineux dessine un signe plus (+).

2a.

Place d'abord l'insecte dans le coin inférieur gauche de l'écran avec setPos(-2, -2). Il doit ensuite monter un escalier de quatre marches.

2b.

Résous le même exercice à l'aide d'une fonction step() qui dessine une seule marche, puis appelle cette fonction quatre fois avec une boucle repeat..

Écris un programme qui allume les LED des deux diagonales, de manière à dessiner une croix (X).

Comme dans le premier exemple consacré à if-else, l'insecte se déplace de gauche à droite. Cette fois, il ne doit cependant pas parcourir une seule rangée, mais toutes les rangées.

L'insecte commence donc dans le coin inférieur gauche et se déplace vers la droite. Lorsqu'il atteint le bord droit, il revient au bord gauche et poursuit son déplacement sur la deuxième rangée. Sa coordonnée y augmente donc de 1.

Pour parcourir toutes les LED de l'écran, tu peux également utiliser deux boucles for et allumer les LED avec setPos(x, y)

for y in range(-2, 3):
    for x in range (-2, 3):
        setPos(x, y)

Ton programme doit parcourir toutes les LED, mais n'allumer que celles qui correspondent à la figure ci-contre.

Ton programme doit allumer les LED selon le motif en « damier » représenté sur la figure ci-contre. Comme tu peux facilement le constater, les LED allumées remplissent la condition suivante : la somme de leurs coordonnées x et y est un nombre pair. Pour vérifier si un nombre est pair ou impair, on utilise généralement l'opérateur modulo a % b, qui renvoie le reste de la division entière de a par b. Un nombre a est donc pair si a % 2 == 0.