Guide pédagogique

Présentation


L’application Pyrates (https://py-rates.fr) a été conçue pour accompagner la transition du collège au lycée dans l’apprentissage de la programmation informatique. Une attention particulière a été donnée au passage de la programmation par blocs à la programmation en ligne de code.

Cette application est destinée à des élèves de seconde ou de première et vise une première approche de la programmation en Python. Les élèves peuvent l'utiliser en relative autonomie, un effort ayant été fait en ce sens au niveau des contenus et de la progression pédagogique.

L'application est, de plus, conforme au RGPD : aucune inscription n’est nécessaire, aucune donnée personnelle n’est collectée. L’élève reçoit un code unique généré aléatoirement pour retrouver sa partie lorsqu'il quitte le jeu.

Ainsi Pyrates propose :
  • un « Guide de démarrage » (bouton vert) permettant de découvrir le fonctionnement de l'application en autonomie ;
  • un réinvestissement en Python des notions algorithmiques abordées au collège (variable, boucles et conditionnelles) facilité par un « Mémo programmation » (partie bleue) présentant ces notions en s’appuyant sur une comparaison avec les blocs de Scratch ;
  • l’intégration d’un analyseur syntaxique issu de la recherche (Kohn, 2017) produisant des messages d’erreur en français dont la formulation est adaptée aux débutants ;
  • un environnement de développement simple et tout intégré se rapprochant de ce que les élèves connaissent avec Scratch ;
  • des activités ludiques sous la forme d’un jeu de plateforme favorisant l’engagement et la motivation des élèves.

Notons que l'application Pyrates introduit les appels de fonction dans leurs différentes configurations (retours et paramètres) mais n’aborde pas leurs définitions.

Au cours du jeu, les notions algorithmiques sont mises en jeu dans les différents niveaux sur le modèle des situations adidactiques (Brousseau, 1998). C’est-à-dire que les élèves doivent agir de leur propre mouvement, guidés uniquement par la logique interne des situations et non pour répondre aux intentions affichées de l’enseignant. Cette approche doit permettre de donner du sens aux apprentissages. Ainsi, dans chaque niveau du jeu, la situation ludique proposée doit amener les élèves à mettre en œuvre certaines notions algorithmiques sans pour autant que cela soit explicite. Ils peuvent pour cela s’appuyer sur les éléments présents dans l’environnement, en particulier le « Mémo programmation » Python qu’ils ont à disposition.

Mise en œuvre conseillée


Niveaux et disciplines

  • L'application peut être utilisée en classe de seconde en cours de SNT ou de mathématiques dans une optique d'initiation à la programmation Python.
  • Il est également possible de l'employer en classe de première NSI afin de reprendre les bases de la programmation en Python.

Temps

Un volume horaire de trois heures est nécessaire afin de donner la chance aux élèves de finir le jeu et d’appréhender l’ensemble des concepts.

Matériel

  • Ordinateur fixe ou portable. Important : Ce jeu utilise des ressources matérielles importantes, si les ordinateurs qu'utilisent vos élèves sont vétustes, mieux vaut tester le jeu au préalable, en particulier les niveaux 2, 3 et 5 pour lesquels les sauts peuvent poser problème.
  • Navigateur Internet (Firefox ou Chrome conseillés)
  • Connexion Internet

Dispositif

Elève seul ou en binôme sur un poste.

Déroulé

  1. L’enseignant peut, dans un premier temps, présenter rapidement l’application au groupe classe (par exemple en vidéo-projetant l’interface). Il s’agit içi d’exposer le contenu du « Guide de démarrage » : le fonctionnement général du jeu, les différentes zones de l’interface ainsi que leur fonction.
  2. Demander aux élèves de lire la partie « Notions de base » du « Mémo programmation ». Les autres parties pouvant être consultés à la demande lorsque le besoin s'en fait sentir.
  3. Laisser les élèves jouer en tentant de résoudre successivement les différents niveaux.
  4. Il est intéressant, dans la mesure du possible, de ne pas indiquer aux élèves les notions à utiliser dans les niveaux en les laissant les trouver par eux mêmes.
  5. Un fonctionnement possible est d’intervenir auprès des élèves à leur demande ou lorsqu’ils sont engagés dans la résolution d’un niveau depuis un certain temps.
  6. Une pastille de couleur est accolée au numéro de niveau. Elle permet à l’enseignant d’avoir une idée du temps passé sur le niveau courant. Pastille verte : 0 à 10 minutes, pastille orange : 10 à 15 minutes, pastille rouge : 15 minutes et plus.
  7. Dans un premier temps (vert), il est conseillé de répondre aux élèves sur des éléments relatifs à la syntaxe Python, ou au fonctionnement du jeu, mais de les renvoyer à la lecture du « Mémo programmation » s’il leur manque une notion algorithmique afin de progresser dans le niveau. Si un élève est bloqué dans un même niveau depuis un certain temps (orange), il est possible d’aller un peu plus loin dans les éléments d’aide. Si l’indicateur est rouge, il faudra sans doute accompagner l’élève explicitement jusqu’à la résolution du niveau pour éviter qu'il ne se décourage.
  8. Après la dernière séance ou entre les séances, une étape de mise en commun et de retour sur les notions (« institutionnalistation ») peut être réalisée avec le groupe classe.

Niveaux


Niveau 1


  • Objectif : Ramasser la clé puis ouvrir le coffre.
  • Fonctions de contrôle : avancer(), droite(), gauche(), ouvrir()
  • Contraintes : Le programme ne doit pas dépasser 10 lignes.

Notions en jeu

Notions algorithmiques en jeu et éléments d’aide pour leur mise en œuvre :
xx = notion introduite dans ce niveau / xx = notion facultative
Notions algorithmiques
Éléments d'aide
Utiliser une fonction sans retour et sans argument (avancer, droite, gauche, ouvrir)
Exemple de code pré-écrit dans l’éditeur pour le premier niveau : avancer()
Utiliser une boucle bornée (for) sans variable de boucle (une seule instruction dans le corps de la boucle)
Mémo Python > Boucle for > Répétition simple

Solution attendue

Description et programme de la solution attendue :
Description
Programme

Ramasser la clé en enchainant séquentiellement les instructions de déplacements élémentaires.

Parcourir la ligne droite de 16 blocs à l’aide d’une boucle bornée (for) jusqu’au coffre.

Ouvrir le coffre.

1
2
3
4
5
6
7
8
9
avancer()
droite()
avancer()
gauche()
avancer()
droite()
for _ in range(16):
    avancer()
ouvrir()

Niveau 2


  • Objectif : Ramasser la clé puis ouvrir le coffre.
  • Fonctions de contrôle : avancer(), droite(), gauche(), sauter(), coup(), ouvrir()
  • Contraintes : Le programme ne doit pas dépasser 14 lignes.

Notions en jeu

Notions algorithmiques en jeu et éléments d’aide pour leur mise en œuvre :
xx = notion introduite dans ce niveau / xx = notion facultative
Notions algorithmiques
Éléments d'aide
Utiliser une fonction sans retour et sans argument (avancer, droite, gauche, sauter, coup, ouvrir)
Utiliser une boucle bornée (for) sans variable de boucle (plusieurs instructions dans le corps de la boucle)
Mémo Python > Boucle for > Répétition simple

Solution attendue

Description et programme de la solution attendue :
Description
Programme

Sauter par-dessus chacun des 6 tonneaux à l’aide d’une boucle bornée (for).

Descendre sur la plateforme inférieure.

Détruire les 9 pots à l’aide d’une boucle bornée (for).

Approcher puis ouvrir le coffre.

1
2
3
4
5
6
7
8
9
10
11
12
for _ in range(6):
    sauter()
    avancer()
avancer()
gauche()
avancer()
avancer()
for _ in range(9):
    coup()
    avancer()
avancer()
ouvrir()

Niveau 3


  • Objectif : Ramasser la clé puis ouvrir le coffre. La hauteur des piles de caisses est aléatoire et change à chaque exécution. Il faut donc lire le message dans la bouteille avant chaque pile qui indique sa hauteur.
  • Fonctions de contrôle : avancer(), sauter_hauteur(hauteur), lire_nombre(), ouvrir()
  • Contraintes : Le programme ne doit pas dépasser 14 lignes.

Notions en jeu

Notions algorithmiques en jeu et éléments d’aide pour leur mise en œuvre :
xx = notion introduite dans ce niveau / xx = notion facultative
Notions algorithmiques
Éléments d'aide
Utiliser une fonction sans retour et sans argument (avancer, ouvrir)
Utiliser une fonction sans retour et avec argument (sauter_hauteur)
Exemple d’utilisation de la fonction : sauter_hauteur(3)
Utiliser une fonction avec retour et sans argument (lire_nombre)
Exemple d’utilisation de la fonction : message = lire_nombre()
Créer, utiliser, modifier une variable
Mémo Python > Variable
Manipuler une variable de type entier
Mémo Python > Variable > Type
Utiliser une boucle bornée (for) sans variable de boucle (plusieurs instructions dans le corps de la boucle)
Mémo Python > Boucle for > Répétition simple

Solution attendue

Description et programme de la solution attendue :
Description
Programme

Sauter les deux piles de tonneaux avec l’aide de la fonction sauter_hauteur.

Utiliser une boucle bornée (for) pour répéter quatre fois les instructions :

  • Lire dans la bouteille la hauteur des caisses à la l’aide de la fonction lire_nombre et affecter une variable du retour de cette fonction.
  • Se rapprocher de la pile puis sauter à la hauteur indiquée dans la variable.
  • Se rapprocher de la bouteille suivante.

Ouvrir le coffre.

1
2
3
4
5
6
7
8
9
10
11
12
sauter_hauteur(4)
avancer()
sauter_hauteur(3)
avancer()
avancer()
for _ in range(4):
    message = lire_nombre()
    avancer()
    sauter_hauteur(message)
    avancer()
    avancer()
ouvrir()

Niveau 4


  • Objectif : Ramasser la clé puis ouvrir le coffre. L'emplacement du coffre et de la clé sont aléatoires et changent à chaque exécution. Il faut donc lire les messages dans les bouteilles qui indiquent le chemin à suivre (gauche ou droite) à chaque étage. Le fait de tomber dans les piques fait perdre puis recommencer le niveau.
  • Fonctions de contrôle : avancer(), gauche(), droite(), lire_chaine(), ouvrir()
  • Contraintes : Le programme ne doit pas dépasser 14 lignes.

Notions en jeu

Notions algorithmiques en jeu et éléments d’aide pour leur mise en œuvre :
xx = notion introduite dans ce niveau / xx = notion facultative
Notions algorithmiques
Éléments d'aide
Utiliser une fonction sans retour et sans argument (avancer, guauche, droite, ouvrir)
Utiliser une fonction avec retour et sans argument (lire_chaine)
Exemple d’utilisation de la fonction : message = lire_chaine()
Créer, utiliser, modifier une variable
Mémo Python > Variable
Manipuler une variable de type chaîne de caractères
Mémo Python > Variable > Type
Utiliser une structure conditionnelle à deux branches
Mémo Python > Conditionnelle > Conditionnelle à deux branches
Tester une égalité
Mémo Python > Conditionnelle > Conditionnelle à une branche
Utiliser une boucle bornée (for) sans variable de boucle (imbrication d’une autre structure)
Mémo Python > Boucle for > Répétition simple

Solution attendue

Description et programme de la solution attendue :
Description
Programme

Avancer d’un bloc afin de se positionner sur la bouteille.

Utiliser une boucle bornée (for) pour répéter cinq fois les instructions :

  • Appeler la fonction lire_chaine et affecter une variable du retour de cette fonction.
  • Réaliser un test sur cette variable à l’aide d’une structure conditionnelle if-else permettant d’aller à gauche ou à droite.
  • Avancer de deux blocs pour descendre d’un étage.

Ouvrir le coffre.

1
2
3
4
5
6
7
8
9
10
avancer()
for _ in range(5):
    message = lire_chaine()
    if message == "gau":
        gauche()
    else:
        droite()
    avancer()
    avancer()
ouvrir()

Niveau 5


  • Objectif : Ramasser la clé puis ouvrir le coffre. Sur la plateforme supérieure, la hauteur des caisses est aléatoire et change à chaque exécution. Le fait de tomber dans les piques fait perdre puis recommencer le niveau.
  • Fonctions de contrôle : avancer(), sauter(), sauter_haut(), mesurer_hauteur(), ouvrir()
  • Contraintes : Le programme ne doit pas dépasser 18 lignes.

Notions en jeu

Notions algorithmiques en jeu et éléments d’aide pour leur mise en œuvre :
xx = notion introduite dans ce niveau / xx = notion facultative
Notions algorithmiques
Éléments d'aide
Utiliser une fonction sans retour et sans argument (avancer, sauter, sauter_haut, ouvrir)
Utiliser une fonction avec retour et sans argument (mesurer_hauteur)
Exemple d’utilisation de la fonction : hauteur = mesurer_hauteur()
Créer, utiliser, modifier une variable
Mémo Python > Variable
Manipuler une variable de type entier
Mémo Python > Variable > Type
Utiliser une structure conditionnelle à trois branches
Mémo Python > Conditionnelle > Conditionnelle à trois branches
Tester une égalité
Mémo Python > Conditionnelle > Conditionnelle à une branche
Utiliser une boucle bornée (for) sans variable de boucle (imbrication d’une autre structure)
Mémo Python > Boucle for > Répétition simple

Solution attendue

Description et programme de la solution attendue :
Description
Programme

Ramasser la clé sur la plateforme inférieure, puis monter à l’aide d’un saut haut.

Utiliser une boucle bornée (for) pour répéter cinq fois les instructions :

  • Mesurer la hauteur des caisses se situant devant soi à l’aide de la fonction mesurer_hauteur puis affecter une variable à l’aide de cette valeur.
  • Utiliser une structure conditionnelle if-elif-else afin d’effectuer l’action adéquate en fonction de la hauteur des caisses (avancer, sauter ou sauter_haut).
  • Avancer deux fois jusqu’aux prochaines caisses.

Avancer pour descendre sur la plateforme inférieure puis ouvrir le coffre.

1
2
3
4
5
6
7
8
9
10
11
12
13
avancer()
sauter_haut()
for _ in range(5):
    hauteur = mesurer_hauteur()
    if hauteur == 0:
        avancer()
    elif hauteur == 1:
        sauter()
    else:
        sauter_haut()
    avancer()
    avancer()
ouvrir()

Niveau 6


  • Objectif : Ramasser la clé puis ouvrir le coffre.
  • Fonctions de contrôle : avancer(), sauter_hauteur(hauteur), ouvrir()
  • Contraintes : Le programme ne doit pas dépasser 4 lignes.

Notions en jeu

Notions algorithmiques en jeu et éléments d’aide pour leur mise en œuvre :
xx = notion introduite dans ce niveau / xx = notion facultative
Notions algorithmiques
Éléments d'aide
Utiliser une fonction sans retour et sans argument (avancer, ouvrir)
Utiliser une fonction sans retour et avec argument (sauter_hauteur)
Exemple d’utilisation de la fonction : sauter_hauteur(3)
Utiliser une variable (variable de boucle)
Mémo Python > Variable > Utilisation
Utiliser une boucle bornée (for) avec variable de boucle (commence à zéro)
Mémo Python > Boucle for > Répétition avec compteur (commence à zéro)

Solution attendue

Description et programme de la solution attendue :
Description
Programme

Gravir les piliers à l’aide d’une boucle bornée (for) en utilisant la variable de boucle afin de sauter à la bonne hauteur.

Ouvrir le coffre.

1
2
3
4
for compteur in range(6):
    sauter_hauteur(compteur)
    avancer()
ouvrir()

Niveau 7


  • Objectif : Tirer sur toutes les noix de coco puis sur le coffre sans jamais atteindre l'autre pirate. Les noix de coco apparaissent par séries alternativement à droite puis à gauche, leur nombre augmente à chaque fois. L’autre pirate se place toujours derrière la dernière. Le fait de tirer sur ce pirate fait perdre puis recommencer le niveau.
  • Fonctions de contrôle : tourner(), tirer(distance)
  • Contraintes : Le programme ne doit pas dépasser 5 lignes.

Notions en jeu

Notions algorithmiques en jeu et éléments d’aide pour leur mise en œuvre :
xx = notion introduite dans ce niveau / xx = notion facultative
Notions algorithmiques
Éléments d'aide
Utiliser une fonction sans retour et sans argument (tourner)
Utiliser une fonction sans retour et avec argument (tirer)
Exemple d’utilisation de la fonction : tirer(3)
Utiliser une variable (variable de boucle)
Mémo Python > Variable > Utilisation
Utiliser une boucle bornée (for) avec variable de boucle ( ne commence pas à zéro)
Mémo Python > Boucle for > Répétition avec compteur (ne commence pas à zéro)

Solution attendue

Description et programme de la solution attendue :
Description
Programme

Tirer alternativement à droite puis à gauche et de plus en plus loin sur les différentes séries de noix de coco à l’aide d’une boucle bornée (for) et de sa variable de boucle initialisée à 2 et prenant 8 pour dernière valeur.

Tirer sur le coffre.

1
2
3
4
for compteur in range(2,9):
    tirer(compteur)
    tourner()
tirer(3)

Niveau 8


  • Objectif : Ramasser la clé puis ouvrir le coffre. La solidité du tonneau (nombre dans le cercle), le nombre de pots ainsi que l'emplacement du coffre sont aléatoires et changent à chaque exécution. Un fois le tonneau détruit, de la dynamite apparait à sa place. Il ne faut pas donner de coup dans cette dynamite sous peine d’une explosion qui fait perdre puis recommencer le niveau.
  • Fonctions de contrôle : avancer(), gauche(), droite(), coup(), detecter_obstacle(), ouvrir()
  • Contraintes : Aucunes

Notions en jeu

Notions algorithmiques en jeu et éléments d’aide pour leur mise en œuvre :
xx = notion introduite dans ce niveau / xx = notion facultative
Notions algorithmiques
Éléments d'aide
Utiliser une fonction sans retour et sans argument (avancer, gauche, droite, coup, ouvrir)
Utiliser une fonction avec retour et sans argument (detecter_obstacle)
Exemple d’utilisation de la fonction : obstacle = detecter_obstacle()
Créer, utiliser, modifier une variable
Mémo Python > Variable
Manipuler une variable de type booléen
Mémo Python > Variable > Type
Utiliser une boucle bornée (for) sans variable de boucle
Mémo Python > Boucle for > Répétition simple
Utiliser une boucle non-bornée (while)
Mémo Python > Boucle while > Répétition tant que…

Solution attendue

Description et programme de la solution attendue :
Description
Programme

Avancer jusqu’au tonneau.

Utiliser une boucle non-bornée (while) afin de donner des coups de sabre tant qu’un obstacle (le tonneau) se trouve devant soi.

Avancer de trois blocs jusqu’à la clé.

Se retourner puis avancer de 5 blocs jusqu’au premier pot.

Utiliser une boucle non-bornée (while) afin de porter un coup de sabre et d’avancer tant qu’un obstacle (un pot) se trouve devant nous.

Ouvrir le coffre.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
avancer()
obstacle = detecter_obstacle()
while obstacle == True:
    coup()
    obstacle = detecter_obstacle()
for _ in range(3):
    avancer()
droite()
for _ in range(5):
    avancer()
obstacle = detecter_obstacle()
while obstacle == True:
    coup()
    avancer()
    obstacle = detecter_obstacle()
ouvrir()

A propos du projet


  • Cette application est issue d'une thèse en didactique de l'informatique portant sur l'enseignement-apprentissage de la programmation informatique dans l'enseignement secondaire.
  • Cette thèse est co-financée par la Région Bretagne et l' Université de Bretagne Occidentale .
  • Vous pouvez contacter l'auteur à l'adresse suivante : matthieu.branthome AT etudiant.univ-brest.fr