Chapitre 2. Bases de la programmation

Pourquoi est-il important d’apprendre la programmation ? Regardez cette vidéo pour comprendre en deux minutes chrono !

Séance 1. Notions d’algoritme et de programme, boucle for

Pendant cette séance :

Nous avons revisé la notion d’algorithme.
Nous avons revisé la programmation par bloc avec Angry Birds dans Studio Code (Niveaux 1 à 10). Nous avons notamment revu le bloc répéter qui permet de répéter une instruction un nombre défini de fois.
Nous nous sommes initié à la programmation textuelle avec le langage Python dans Py-Rates (Niveau 1). Nous avons utilisé l’équivalent Python du bloc répéter : la boucle for.

Voici la correction du niveau 1. de Py-Rates :

avancer()
droite()
avancer()
gauche()
avancer()
droite()
for _ in range(16): #(1)!
    avancer() #(2)!
ouvrir() #(3)!

Le nombre 16 indique que l’instruction avancer() contenue dans la boucle for sera exécutée 16 fois. Cela permet d’économiser 14 lignes de code !
L’instruction avancer() est décallée vers la droite d’une indentation. Cela signifie que cette instruction est contenue dans la boucle for. Cette instruction sera donc répétée 16 fois.
L’instruction ouvrir() permettant d’ouvrir le coffre ne doit être exécutée qu’une seule fois à la fin du trajet lorsque le personnage se trouve devant le coffre. On a donc pris soin de ne pas mettre d’indentation avant l’instruction ouvrir() afin que cette instruction soit exclue de la boucle.

Astuces.

Cliquez sur les plus pour afficher les explications.
Cliquez sur le coin haut droit du cadre de code pour copier le programme.

Séance 2. Boucle for (suite), affectation de variable

Pendant cette séance nous avons continué la programmation textuelle dans Py-Rates.

Nous avons retravaillé la boucle for (Niveau 2.).
Nous avons découvert la notion de variable (Niveau 3.). Créer une variable permet de conserver en mémoire une valeur (par exemple un nombre) au cours de l’exécution d’un programme. Cette valeur peut ensuite être utilisée dans les instructions suivantes du programme. L’affectation de variable est l’instruction qui permet de créer une variable en lui attribuant un nom et une valeur initiale.

Voici la correction des niveaux 2. et 3. de Py-Rates :

Niveau 2. Boucle for (suite)
for _ in range(6): #(1)!
    sauter() #(2)!
    avancer()
avancer() #(3)!
gauche()
avancer()
avancer()
for _ in range(9): #(4)!
    coup() #(5)!
    avancer()
avancer() #(6)!
ouvrir()

Le nombre 6 indique que les instructions sauter() et avancer() contenues dans la boucle for seront exécutées 6 fois. Cela permet d’économiser 9 lignes de code !
Les instructions sauter() et avancer() sont décallées vers la droite d’une indentation. Cela signifie que ces deux instructions sont contenues dans la boucle for. Ces deux instructions seront donc répétées 6 fois. Ainsi, le personnage peut atteindre la clé !
Les instructions avancer(), gauche(), avancer(), avancer() permettent de passer au niveau inférieur. Cette série d’instructions ne doit être exécutée qu’une seule fois. On a donc pris soin de ne pas mettre d’indentation avant chacune de ces quatre instructions afin que ces instructions soient exclues de la boucle précédente.
Le nombre 9 indique que les instructions coup() et avancer() contenues dans la boucle for seront exécutées 9 fois. Cela permet d’économiser 15 lignes de code !
Les instructions coup() et avancer() sont décallées vers la droite d’une indentation. Cela signifie que ces deux instructions sont contenues dans la boucle for. Ces deux instructions seront donc répétées 9 fois. Ainsi, le personnage peut traverser le tunnel en cassant au fur et à mesure les pots en terre cuite !
Les instructions avancer() et ouvrir() permettant d’atteindre puis d’ouvrir le coffre ne doivent être exécutée qu’une seule fois à la fin du trajet lorsque le personnage se trouve proche du coffre. On a donc pris soin de ne pas mettre d’indentation avant les instructions avancer() et ouvrir() afin que ces instructions soient exclues de la boucle précédente.

Niveau 3. Découverte de la notion de variable
sauter_hauteur(4) #(1)!
avancer()
sauter_hauteur(3)
for _ in range(4): #(2)!
    avancer()
    avancer()
    nbre_caisses = lire_nombre() #(3)!
    avancer()
    sauter_hauteur(nbre_caisses) #(4)!
avancer()
ouvrir()

L’instruction sauter_hauteur(4) permet au personnage de sauter d’une hauteur de quatre unités.
Le nombre 4 indique que la suite d’instructions suivantes sera répétée 4 fois :
```
avancer()
avancer()
nbre_caisses = lire_nombre()
avancer()
sauter_hauteur(nbre_caisses)
```
Cela permet d’économiser 14 lignes de code !
Cette instruction est une affectation de variable. Ici, on crée une variable dont le nom est nbre_caisses. Cette variable prend comme valeur initiale le nombre lu sur le message de la bouteille avec l’instruction lire_nombre(). Voici un exemple d’exécution qui peut se produire (il faut lire cette ligne de droite à gauche) :
1. Tout d’abord l’expression lire_nombre() est évaluée : le nombre est lu sur le message de la bouteille (par exemple, ce nombre peut être 3). Ainsi l’instruction devient dans cet exemple nbre_caisses = 3.
2. Ensuite, l’affectation de variable a lieu : le nom nbre_caisses est stocké en mémoire et est associé à la valeur 3.
Dans cette instruction, on utilise la valeur stockée précédemment dans la variable nbre_caisses. Par exemple cette valeur peut être le nombre 3. Ainsi, l’instruction devient sauter_hauteur(3) et le personnage saute d’une hauteur de trois caisses.

Séance 3. Types et valeurs de base en Python

Dans cette séance, nous avons :

découvert l’utilisation de la console Python avec le logiciel Thonny ;
découvert les 4 types Python de base permettant de représenter les données élémentaires :
- Le type int (de l’anglais integer, “entier” en français) permet de représenter les nombres entiers positifs et négatifs (Exemples : 3, -5) ;
- Le type float (de l’anglais floating point number, “nombre à virgule flottante” en français ou plus simplement “flottant”) permet de représenter des nombres décimaux (Exemples : 3.5, -0.5, 4.0). Attention ! Le séparateur décimal en Python est le point (et non la virgule) !
- Le type str (de l’anglais string, “chaîne de caractère” en français ou plus simplement “chaîne”.) permet de représenter du texte c’est-à-dire un simple caractère (lettre, espace etc.), un mot, une phrase voir une texte (Exemples : 'a', 'chat', "Boujour !"). Remarque. Une chaîne de caractère est bordée par des guillemets simples ou doubles.
- Le type bool (de l’anglais boolean, “booléen” en français) permet de représenter une valeur booléenne c’est-à-dire True (vrai) ou False (faux).

Séance 4. Affectation de variable et affichage, utilisation d’un IDE

Dans cette séance, avec l’aide de Thonny, nous avons :

approfondi la notion d’affectation de variable ;
écrit, enregistré et exécuté des programmes à l’aide de l’IDE Thonny.

Voici les deux programmes travaillés pendant cette séance :

Activité 2. Agriculteur (programme à recopier)
prix_baguette = 0.9
nbre_baguette = 3
total = prix_baguette * nbre_baguette
message = "Prix total :"
print(message)
print(total)

Activité 3. Baguettes (programme à compléter)
prix_pommes = 2.5
masse_pommes = 180
prix_poires = 3
masse_poires = 150
total = prix_pommes * masse_pommes + prix_poires * masse_poires
message = "Recette totale :"
print(message)
print(total, "Euros")

Séance 5. Branchements conditionnels

Dans cette séance :

Nous avons revisé la programmation par bloc avec Angry Birds dans Studio Code (Niveaux 11 à 20). Nous avons notamment revu les blocs jusqu’à, si et si sinon.
- Le bloc jusqu’à permet de répéter des instructions un nombre NON défini de fois. La répétition des instructions s’arrête lorsque la condition ciblée est réalisée (par exemple atteindre un personnage).
- Le bloc si permet d’exécuter des instructions si une condition est vraie (par exemple tourner à gauche si un chemin est détecté à gauche).
- Le bloc si sinon permet d’exécuter des instructions si une condition est vraie et d’autres instructions sinon (si la condition est fausse) (par exemple avancer si un chemin est détecté devant, sinon tourner à gauche).
Nous avons découvert les équivalents Python des blocs précédents. On utilise pour cela les mots-clés Python suivant :
- if (si)
- else (sinon)
- elif (abbréviation de l’anglais else if qui signifie “sinon si”).

Voici la correction des niveaux 4. et 5. de Py-Rates :

Niveau 4. Conditionnelle à deux branches
for _ in range(5): #(1)!
    avancer()
    direction = lire_chaine() #(2)!
    if direction == "gau": #(3)!
        gauche()
    else: #(4)!
        droite()
    avancer() #(5)!
avancer() #(6)!
ouvrir()

Le nombre 5 indique que les instructions décalées vers la droite (lignes 2 à 8) c’est-à-dire les instructions contenues dans la boucle for seront exécutées 5 fois. Cela permet d’économiser 27 lignes de code !
Cette instruction est une affectation de variable. Ici, on crée une variable dont le nom est direction. Cette variable prend comme valeur initiale la chaîne de caractère lue sur le message de la bouteille rencontrée avec l’instruction lire_chaine(). Voici un exemple d’exécution qui peut se produire (il faut lire cette ligne de droite à gauche) :
1. Tout d’abord l’expression lire_chaine() est évaluée : la chaîne est lue sur le message de la bouteille (par exemple, cette chaîne peut être "gau"). Ainsi l’instruction devient dans cet exemple direction = "gau".
2. Ensuite, l’affectation de variable a lieu : le nom direction est stocké en mémoire et est associé à la valeur "gau".
1er cas. Si la variable direction est égale à "gau" (condition), on oriente le personnage vers la gauche avec l’instruction gauche(). Remarque. Attention, le test d’égalité direction == "gau" utilise l’opérateur double égal !
2nd cas. Sinon, on oriente le personnage vers la droite. Remarquez que le mot clé else n’est pas suivi d’une condition.
Après avoir choisi la direction vers laquelle orienter le personnage, on doit dans les deux cas avancer. Il faut donc penser à décaler vers la gauche l’instruction avancer(). Si on conserve l’alignement avec l’instruction précédente, le personnage n’avancera que dans le second cas c’est-à-dire lorsque la direction choisie est la droite.
Les instructions avancer() et ouvrir() ne doivent être exécutées qu’une seule fois en fin de programme. On a donc pris soin de ne pas mettre d’indentation avant chacune de ces deux instructions afin que ces instructions soient exclues de la boucle for précédente.

Niveau 5. Conditionnelle à trois branches
avancer()
sauter_haut()
for _ in range(5): #(1)!
    hauteur = mesurer_hauteur() #(2)!
    if hauteur == 2: #(3)!
        sauter_haut()
    elif hauteur == 1: #(4)!
        sauter()
    else: #(5)!
        avancer()
    avancer() #(6)!
    avancer()
ouvrir() #(7)!

Le nombre 5 indique que les instructions décalées vers la droite (lignes 4 à 12) c’est-à-dire les instructions contenues dans la boucle for seront exécutées 5 fois. Cela permet d’économiser 35 lignes de code !
Cette instruction est une affectation de variable. Ici, on crée une variable dont le nom est hauteur. Cette variable prend comme valeur initiale la hauteur que le personnage doit sauter avec l’instruction mesurer_hauteur(). Voici un exemple d’exécution qui peut se produire (il faut lire cette ligne de droite à gauche) :
1. Tout d’abord l’expression mesurer_hauteur() est évaluée à 0, 1 ou 2 selon la situation. Dans cet exemple, supposons que la valeur obtenue est 1. Ainsi l’instruction devient dans cet exemple hauteur = 1.
2. Ensuite, l’affectation de variable a lieu : le nom hauteur est stocké en mémoire et est associé à la valeur 1.
1er cas. Si la variable hauteur est égale à 2 (condition), on saute d’une hauteur de 2 avec l’instruction sauter_haut(). Remarque. Attention, le test d’égalité hauteur == 2 utilise l’opérateur double égal !
2nd cas. Sinon si la variable hauteur est égale à 1, on saute d’une hauteur de 1 avec l’instruction sauter(). Remarquez que le mot clé elif est suivi d’une condition !
3ème cas. Sinon (si hauteur vaut 0), on avance simplement ave l’instruction avancer().
Après avoir passé l’obstacle, on doit dans les trois cas avancer deux fois. Il faut donc penser à décaler vers la gauche les instructions avancer(). Si on conserve l’alignement avec l’instruction précédente, le personnage n’avancera que dans le 3ième cas c’est-à-dire lorsque hauteur vaut 0.
L’instruction ouvrir() ne doit être exécutées qu’une seule fois en fin de programme. On a donc pris soin de ne pas mettre d’indentation avant cette dernière instruction afin qu’elle soit exclue de la boucle for précédente.