Logiciel d'entraînement sur les verbes irréguliers anglais dans la console Python

Objectifs

Le but de ce tutoriel est de programmer le "moteur logique" du logiciel d'apprentissage des verbes irréguliers. On ne s'intéresse donc pas du tout à la création d'une interface graphique, mais il sera possible, en fin de tutoriel, d'utiliser le logiciel dans la console Python (c'est-à-dire en mode texte).

1. Mise en place des fichiers du programme

L'éditeur utilisé pour programmer est le logiciel PyCharm (voir la page de mise en place des projets).

Ouvrir PyCharm et créer deux fichiers Python verbes_logique.py et verbes_console.py : le premier contiendra les définitions de fonctions et les constantes qui serviront pour l'utilisation en console et pour l'utilisation en interface graphique ; le second contiendra les instructions spécifiques (entrées, sorties) pour l'utilisation en console.

2. Initialisation de la liste des verbes

Les verbes irréguliers seront enregistrés dans un fichier tiers, nommé verbes.txt, à télécharger et à déposer dans le dossier de travail du projet. Le fichier fourni ne contient que 25 verbes : il pourra être compléter ultérieurement.

Dans le fichier verbes_logique.py, nous allons définir une fonction charge_verbes qui aura pour rôle de lire le fichier verbes.txt et d'en extraire la liste des traductions, la liste des infinitifs, la liste des prétérits et la liste des participes.

1
2
3
4
5
6
7
8
def charge_verbes():
    """Cette fonction lit le fichier des verbes
    et initialise la liste des verbes"""
    fichier = open("verbes.txt", encoding='utf-8',)
    liste = fichier.readlines()
    fichier.close()
    liste_verbes = [[1, ligne.split(":")[0], ligne.split(":")[1], ligne.split(":")[2], ligne.split(":")[3]] for ligne in liste]
    return liste_verbes

Explications

  • Lignes 4, 5 et 6 : on ouvre le fichier verbes.txt, on lit toutes ses lignes : elles sont stockées sous forme de liste dans la variable liste, puis on referme le fichier.
  • Ligne 7 : on créée une listes liste_verbes qui contient des listes formées de la traduction, de l'infinitif, du prétérit et du participe de chaque verbe. Le premier élément de chaque sous-liste est égal à 1 : cet élément servira à coder l'état sélectionné ou non sélectionné du verbe. Pour un verbe non sélectionné (l'utilisateur ne veut pas être interrogé sur ce verbe), cet élément prendra la valeur 0.
  • Ligne 8 : la fonction retourne (renvoie) le liste créée.

Tests

Dans le fichier verbes_console.py, entrer le code suivant :

1
2
3
4
5
6
7
from verbes_logique import *

print("Entrainement sur les verbes irreguliers")

liste = charge_verbes()

print(liste)

Exécuter le programme : les différentes listes sont affichées.

Remarque

En Python, les éléments d'une liste sont numérotés à partir de zéro. Ainsi, pour afficher uniquement le premier verbe de la liste, on écrira print(liste[0]) (tester cette instruction !). Pour afficher la traduction du deuxième verbe, on écrira print(liste[1][1]). Quelle commande pour afficher le participe du cinquième verbe ?

Réponse

Pour afficher le participe du cinquième verbe : le cinquième verbe porte le numéro 4 et le participe est le cinquième élément, il porte donc le numéro 4. On écrit donc : print(liste[4][4])

Mélange de la liste des verbes

L'utilisateur sera interrogé dans un ordre aléatoire : il faut donc mélanger l'ordre des verbes dans la liste. Nous allons pour cela utiliser la fonction shuffle, qui s'applique à une liste. Cette fonction se trouve dans la bibliothèque Python random, il faut donc l'importer en début de programme.

Ajouter la ligne suivante au tout début du fichier verbes_logique.py :

1
from random import *

Ajouter le code suivant dans le fichier verbes_logique.py :

1
2
3
def  melange(liste_verbes):
    """Cette fonction mélange les verbes dans un ordre aléatoire"""
    return shuffle(liste_verbes)

Ensuite, dans le fichier verbes_console.py, tester cette fonction avec le code ci-dessous :

1
2
3
4
5
6
7
8
from verbes_logique import *

print("Entrainement sur les verbes irreguliers")

liste = charge_verbes()
print(liste)
melange(liste)
print(liste)

3. Le mode "apprentissage"

Une partie consiste à répondre à 10 questions au maximum (moins de 10 questions si moins de 10 verbes sont sélectionnés). Il y a deux modes de jeu : un mode "apprentissage" où la traduction est donnée et l'utilisateur doit donner les autres éléments ; un mode "tournoi" où, pour chaque verbe, un élément au hasard est donné (traduction, infinitif, prétérit ou participe) et l'utilisateur doit donner les autres.

3.1. Choix des questions

Ajouter le code suivant dans le fichier verbes_logique.py :

1
2
3
4
5
6
7
8
def genere_questions_apprentissage(liste_verbes, n=2):
    """Cette fonction choisit au maximum 10 verbes
    qui seront demandes a l'utilisateur"""
    if len(liste_verbes) < 10:
        n =  len(liste_verbes)
    melange(liste_verbes)
    questions = liste_verbes[0:n]
    return questions

Explications :

  • Ligne 1 : par défaut, on fixe la valeur du nombre de questions n à 2 pour la phase de tests.
  • Lignes 4 et 5 : si le nombre de verbes sélectionnés est inférieur à 10, on demande tous les verbes.
  • Ligne 7 : les questions sont les n premiers verbes de la liste mélangée.

3.2. Correction

Voici maintenant une fonction qui va vérifier les réponses de l'utilisateur : la correction sera codée sous la forme d'une liste. Un 0 correspond à une mauvaise réponse, un 1 à une bonne réponse.

Ajouter le code suivant dans le fichier verbes_logique.py. Pour chaque question, on code une bonne réponse par 1 et une mauvaise réponse par 0. Au départ, on initialise les réponses à 0 (tout est faux, ligne 6), puis on vérifie les réponses une à une. Compléter les pointillés.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def verifie_reponses(reponses, solutions):
    """cette fonction verifie les reponses donnees
    et retourne pour chaque verbe 0 si faux et 1 si juste"""
    correction = []
    for k in range(len(reponses)):
        cor = [0, 0, 0]
        if reponses[k][2]==solutions[k][2]:
            cor[0] = ...
        if reponses[k][3]==solutions[k][3]:
            cor[1] = ...
        if reponses[k][4]==solutions[k][4]:
            cor[2] = ...
        correction.append(cor)
    return correction
Réponse
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def verifie_reponses(reponses, solutions):
"""cette fonction verifie les reponses donnees
et retourne pour chaque verbe 0 si faux et 1 si juste"""
correction = []
for k in range(len(reponses)):
    cor = [0, 0, 0]
    if reponses[k][2]==solutions[k][2]:
        cor[0] = 1
    if reponses[k][3]==solutions[k][3]:
        cor[1] = 1
    if reponses[k][4]==solutions[k][4]:
        cor[2] = 1
    correction.append(cor)
return correction

3.3. Test du programme en console

Entrer le code suivant dans le fichier verbes_console.py et exécuter le programme. Reprendre ensuite chaque ligne du programme et tenter d'expliquer son rôle.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
from verbes_logique import *

print("Entrainement sur les verbes irreguliers")
liste = charge_verbes()
q = genere_questions_apprentissage(liste)
reponses = []
for verbe in q:
    rep = [1, verbe[1]]
    print(verbe[1])
    rep.append(input("Infinitif : "))
    rep.append(input("Prétérit : "))
    rep.append(input("Participe : "))
    reponses.append(rep)
corr  = verifie_reponses(reponses, q)
print(corr)

4. Le mode "Tournoi"

Dans ce mode, les questions sont présentées de telle sorte qu'un seul élément est donné au joueur, au hasard : soit la traduction, soit l'infinitif, soit le preterit, soit le participe.

4.1. Choix des questions

On écrit une nouvelle fonction, dans le fichier verbes_logique.py. Cette fonction prend deux arguments : liste_verbes est la liste de tous les verbes possibles et n est le nombre de verbes à demander. Par défaut n prend la valeur 2 et sa valeur est limitée à 10. Elle retourne deux listes : la liste des questions et la liste des solutions.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
def genere_questions_tournoi(liste_verbes, n=2):
    """cette fonction retourne une liste de 10 questions au maximum
    avec à chaque fois une donnée et 3 réponses attendues et une liste de solutions"""
    questions = []
    solutions = []
    melange(liste_verbes)
    n = min(len(liste_verbes), 10, n)
    for k in range(n):
        # on choisit au hasard l'élément donné
        i = randint(0,3)
        if i==0:
            questions.append([liste_verbes[k][1], "", "", ""])
        elif i==1:
            questions.append(["", liste_verbes[k][2], "", ""])
        elif i==2:
            questions.append(["", "", liste_verbes[k][3], ""])
        else:
            questions.append(["", "", "", liste_verbes[k][4]])
        solutions.append([liste_verbes[k][1], liste_verbes[k][2], liste_verbes[k][3], liste_verbes[k][4]])
    return questions, solutions

Explications :

  • à la ligne 7, on définit n au minimum de la valeur donnée en argument, de la longueur de la liste de verbes disponibles et de 10 : ainsi le nombre de questions ne peut dépasser 10 et ne peut non plus être supérieur au nombre de verbes disponibles.
  • à la ligne 10, on utilise la commande i = randint(0,3) qui permet d'obtenir un nombre entier au hasard compris entre 0 et 3. Ce nombre correspond à l'élément qui sera donné au joueur : la traduction si i = 0, l'infinitif si i = 1, etc.

4.2. Test dans la console

Le code ci-dessous, qui remplacera le contenu du fichier verbes_console.py, permet de tester le mode tournoi dans la console.

On utilise pour la correction la même fonction verifie_reponses que pour le mode apprentissage, mais en la modifiant un peu pour qu'elle vérifie aussi l'infinitif en français (c'était inutile pour le mode apprentissage).

Question

Comment modifier la fonction verifie_reponses pour qu'elle vérifie aussi la traduction ?

Solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
def verifie_reponses(reponses, solutions):
    """cette fonction verifie les reponses donnees
    et retourne pour chaque verbe 0 si faux et 1 si juste"""
    correction = []
    for k in range(len(reponses)):
        cor = [0, 0, 0, 0]
        if reponses[k][1]==solutions[k][1]:
            cor[0] = 1
        if reponses[k][2]==solutions[k][2]:
            cor[1] = 1
        if reponses[k][3]==solutions[k][3]:
            cor[2] = 1
        if reponses[k][4]==solutions[k][4]:
            cor[3] = 1
        correction.append(cor)
    return correction
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
from verbes_logique import *

print("Entrainement sur les verbes irreguliers")
print("Test du mode tournoi")
liste = charge_verbes()
nb_questions = 2
q, s = genere_questions_tournoi(liste, n=nb_questions)
reponses = []
for question in q:
    rep = [1, '', '', '', '']
    print(question[1:])
    for k in range(1,5):
        if question[k]=='':
            rep[k] = input("Entrer l'élément manquant n°" + str(k) + " : ")
        else:
            rep[k] = question[k]
    reponses.append((rep))
corr  = verifie_reponses(reponses, s)
print(corr)

Le programme doit maintenant fonctionner en mode console.

Question

Essayer d'expliquer précisément le code ci-dessus, et notamment les lignes 9 à 16.