NSI_Creation_QCM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Projet QCM   -   <div id=\"top\">première version</div>\n",
    "1. **<a href=\"#S1\">Préliminaires</a>**\n",
    "2. **<a href=\"#S2\">Quizz</a>**\n",
    "3. **<a href=\"#S3\">Question à choix multiple</a>**\n",
    "4. **<a href=\"#S4\">Questionnaire dans un fichier</a>**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <div id=\"S1\">Préliminaires</div> \n",
    "\n",
    "<div style=\"text-align : right\"><a href=\"#top\">Retour</a></div>\n",
    "\n",
    "En $\\texttt{Python}$, pour ouvrir un fichier texte en écriture, il suffit de faire\n",
    "\n",
    "$\\texttt{f = open('nom_fichier', mode=\"w\")}$\n",
    "\n",
    "On peut ensuite écrire des chaines de caractères dans le fichier en faisant attention à bien mettre le caractère « saut de ligne » ($\\texttt{\"\\n\"}$) lorsque c'est nécessaire ; les données à écrire sont fournies en argument \n",
    "\n",
    "$\\texttt{f.write(‹donnees›)}$\n",
    "\n",
    "\n",
    "Puis on sauvegarde nos écritures en fermant le fichier avec l'instruction :\n",
    "\n",
    "$\\texttt{f.close()}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('QCM_G1.txt', mode=\"w\")\n",
    "f.write(\"Ceci est\")\n",
    "f.write(\" une seule ligne\")\n",
    "f.write(\" dans le fichier.\\n\")\n",
    "f.write(\"Et ceci est la deuxième ligne...\\n\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Question 1  \n",
    "\n",
    "\n",
    "\n",
    "Écrire une **procédure** $\\texttt{sauvegarde_nom_score}$ qui sauvegarde le nom et le score du joueur dans un fichier :\n",
    "\n",
    "* le nom est écrit sur la première ligne,  \n",
    "* le score est écrit sur la deuxième ligne.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sauvegarde_nom_score(nom_fichier, nom, score):\n",
    "    \"\"\"\n",
    "    Hypothese :\n",
    "      - nom_fichier, de type chaine de caractères :\n",
    "        nom du fichier où sauvegarder le score\n",
    "      - nom, de type chaine de caractères : nom du joueur\n",
    "      - score, de type flottant : score du joueur\n",
    "    Effet de Bord : sauvegarde un nom et un score dans un fichier\n",
    "    \"\"\"\n",
    "    f = open(nom_fichier, mode=\"w\")\n",
    "    ...\n",
    "    \n",
    "    \n",
    "    f.close()\n",
    "    \n",
    "\n",
    "sauvegarde_nom_score(\"score.txt\",\"ton NOM\",3.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Question 2   \n",
    "\n",
    "Écrire une fonction $\\texttt{lire_score}$ qui récupère le score dans un fichier :\n",
    "\n",
    "\n",
    "Pour ceci, il faudra ouvrir le fichier en lecture:\n",
    "\n",
    "$\\texttt{f = open(nom_fichier, mode=\"r\")}$\n",
    "\n",
    "et utiliser la méthode $\\texttt{f.readline()}$ qui renvoie les lignes successives du fichier.  \n",
    "*Attention, deux appels successifs à $\\texttt{f.readline()}$ donnent deux résultats différents :  \n",
    "le premier renvoie la première ligne et le second renvoie la deuxième ligne du fichier.*\n",
    "\n",
    "La méthode $\\texttt{f.readline()}$ renvoie une chaine de caractères, qu'il faudra convertir en nombre.  \n",
    "Utilisez donc la fonction $\\texttt{int(...)}$ ou $\\texttt{float(...)}$ pour \"transtyper\" une chaine en nombre entier ou flottant.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def lire_score(nom_fichier):\n",
    "    \"\"\"\n",
    "    str -> float\n",
    "    Hypothese : le score est en 2e ligne du fichier passé en argument\n",
    "    Retourne un flottant indiquant le score\"\"\"\n",
    "    f = open(nom_fichier, mode=\"r\")\n",
    "    ...\n",
    "    \n",
    "    \n",
    "    f.close()\n",
    "    return ...\n",
    "\n",
    "lire_score(\"score.txt\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <div id=\"S2\">Quizz </div> \n",
    "\n",
    "<div style=\"text-align : right\"><a href=\"#top\">Retour</a></div> \n",
    "\n",
    "Dans cette partie, nous allons écrire un petit script de QCM.  \n",
    "Le logiciel pose des questions à l'utilisateur, qui choisit une réponse parmi celles proposées.\n",
    "\n",
    "En $\\texttt{Python}$, les dictionnaires permettent de \"stocker\" des données.  \n",
    "Chaque élément d'un dictionnaire est composé de 2 parties, on parle de pairs \"clé/valeur\".\n",
    "\n",
    "\n",
    "On utilise des accolades $\\texttt{\\{ \\}}$ pour définir le début et la fin du dictionnaire, par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "q_test1 = {'question': \"Quelle est la couleur des bananes ?\",\n",
    "           'correcte': \"jaune\",\n",
    "           'incorrecte': \"bleue\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Question à 2 choix\n",
    "\n",
    "Dans un premier temps, chaque question est représentée par un dictionnaire $\\texttt{q}$ contenant trois cases :\n",
    "\n",
    "* une case 'question' contenant une chaine de caractères qui est la question à poser,\n",
    "* une case 'correcte' contenant une chaine de caractères qui est la bonne réponse à la question,\n",
    "* une case 'incorrecte' contenant une chaine de caractères qui est la mauvaise réponse."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si q est un tel dictionnaire, on peut accéder aux différentes cases avec la notation\n",
    "\n",
    "* $\\texttt{q['question']}$ pour récupérer la question,\n",
    "* $\\texttt{q['correcte']}$ pour récupérer la bonne réponse,\n",
    "* $\\texttt{q['incorrecte']}$ pour récupérer la mauvaise réponse.\n",
    "\n",
    "Avec l'exemple précédent, on aura par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Quelle est la couleur des bananes ?'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_test1['question']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Question 3   \n",
    "\n",
    "Écrire une procédure $\\texttt{question(q)}$ qui prend une question en argument, et qui :\n",
    "\n",
    "* affiche la question,\n",
    "* affiche les deux réponses possibles (correcte et incorrecte),\n",
    "* lit la réponse de l'utilisateur (grâce à la fonction \"$\\texttt{input}$\"),\n",
    "* affiche \"Bonne réponse !\" ou \"Mauvaise réponse !\".\n",
    "\n",
    "Par exemple :\n",
    "\n",
    "$\\texttt{>>> question(q_test2)}$    \n",
    "Quelle est la couleur du cheval blanc d'Henry IV ?  \n",
    "1 -  blanc  \n",
    "2 -  gris  \n",
    "Entrez votre choix: 1  \n",
    "Bonne réponse !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "q_test2 = {'question': \"Quelle est la couleur du cheval blanc d'Henry IV ?\",\n",
    "           'correcte': \"blanc\",\n",
    "           'incorrecte': \"gris\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quelle est la couleur du cheval blanc d'Henry IV ?\n",
      "1 - blanc\n",
      "2 - gris\n",
      "Entrez votre choix:1\n",
      "Bonne réponse !\n"
     ]
    }
   ],
   "source": [
    "def question(q):\n",
    "    \"\"\"\n",
    "    Hypothese :\n",
    "      - q de type dictionnaire :\n",
    "      - les denominations des cles de q sont ici explicites\n",
    "    Effet de Bord : affiche la question, les deux reponses possibles\n",
    "                puis lit la reponse utilisateur \n",
    "                et affiche \"Bonne réponse !\" ou \"Mauvaise réponse !\".\n",
    "    \"\"\"\n",
    "    print(q['question'])\n",
    "    ...\n",
    "    \n",
    "    rep = int(input(\"Entrez votre choix:\"))\n",
    "    ...\n",
    "    \n",
    "    \n",
    "          \n",
    "question(q_test2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Questionnaire\n",
    "\n",
    "Un questionnaire est une liste de plusieurs questions, c'est à dire une liste de dictionnaires.\n",
    "\n",
    "Voici un exemple définissant un tel questionnaire en $\\texttt{Python}$ :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "qs_test = [{'question': \"Quelle est la couleur du cheval blanc d'Henry IV ?\",\n",
    "            'correcte': \"blanc\",\n",
    "            'incorrecte': \"gris\"},\n",
    "           {'question': \"2 + 2 = ?\",\n",
    "            'correcte': \"4\",\n",
    "            'incorrecte': \"42\"},\n",
    "           {'question': \"Un brelan de rois gagne une couleur.\",\n",
    "            'correcte': \"faux\",\n",
    "            'incorrecte': \"vrai\"}]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous pouvons maintenant poser toutes les questions d'un questionnaire grâce à la procédure suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def questionnaire(qs):\n",
    "    \"\"\"\n",
    "    Hypothese :\n",
    "      - qs de type list[dict] : chaque element de qs est un dictionnaire\n",
    "      - les denominations des cles des elements de qs sont explicites\n",
    "    Effet de Bord :\n",
    "        Pose toutes les questions du questionnaire qs passé en argument.\n",
    "    \"\"\"\n",
    "    for i in range(len(qs)):\n",
    "        print(\"Question\", i+1, \":\", end=\"  \")\n",
    "        question(qs[i])\n",
    "        print()\n",
    "    print(\"Fin du questionnaire.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Question 4  \n",
    "\n",
    "Testez la procédure questionnaire ci-dessus. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question 1 :  Quelle est la couleur du cheval blanc d'Henry IV ?\n",
      "1 - blanc\n",
      "2 - gris\n",
      "Entrez votre choix:1\n",
      "Bonne réponse !\n",
      "\n",
      "Question 2 :  2 + 2 = ?\n",
      "1 - 4\n",
      "2 - 42\n",
      "Entrez votre choix:1\n",
      "Bonne réponse !\n",
      "\n",
      "Question 3 :  Un brelan de rois gagne une couleur.\n",
      "1 - faux\n",
      "2 - vrai\n",
      "Entrez votre choix:1\n",
      "Bonne réponse !\n",
      "\n",
      "Fin du questionnaire.\n"
     ]
    }
   ],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#####  Score final   \n",
    "\n",
    "Le score à un questionnaire est calculé de la manière suivante : on compte $1$ point par bonne réponse et $-1$ point par mauvaise réponse. Ceci fait qu'un utilisateur qui répond au hasard aura, en moyenne, un score de $0$.\n",
    "\n",
    "#### Question 5  \n",
    "\n",
    "* Transformez votre procédure \"$\\texttt{question}$\" en une fonction qui renvoie un $+1$ ou $-1$.  \n",
    "* Transformez la procédure \"$\\texttt{questionnaire}$\" en une fonction pour qu'elle calcule le score  \n",
    "  et le renvoie, comme une note sur $100$ : \n",
    "  \n",
    "$\\texttt{>>> score = questionnaire(qs)}$  \n",
    "Question 1 :  Quelle est la couleur du cheval blanc d'Henry IV ?  \n",
    "1 -  gris  \n",
    "2 -  blanc  \n",
    "Entrez votre choix: 2  \n",
    "Bonne réponse !  \n",
    "\n",
    "Question 2 :  2 + 2 = ?  \n",
    "1 -  4  \n",
    "2 -  42  \n",
    "Entrez votre choix: 2  \n",
    "Mauvaise réponse !  \n",
    "\n",
    "Fin du questionnaire.  \n",
    "$\\texttt{>>> print(f\"Votre score est de {score}%.\")}$  \n",
    "Votre score est de 0%."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question 1 :  Quelle est la couleur du cheval blanc d'Henry IV ?\n",
      "1 - blanc\n",
      "2 - gris\n",
      "Entrez votre choix:1\n",
      "\n",
      "Question 2 :  2 + 2 = ?\n",
      "1 - 4\n",
      "2 - 42\n",
      "Entrez votre choix:1\n",
      "\n",
      "Question 3 :  Un brelan de rois gagne une couleur.\n",
      "1 - faux\n",
      "2 - vrai\n",
      "Entrez votre choix:1\n",
      "\n",
      "Fin du questionnaire.\n",
      "𝚅𝚘𝚝𝚛𝚎 𝚜𝚌𝚘𝚛𝚎 𝚎𝚜𝚝 𝚍𝚎 100.0 %.\n"
     ]
    }
   ],
   "source": [
    "def question(q):\n",
    "    \"\"\"\n",
    "    dict -> int\n",
    "    Hypothese :\n",
    "      - q de type dictionnaire :\n",
    "      - les denominations des cles de q sont ici explicites\n",
    "    Effet de Bord : affiche la question, les deux reponses possibles\n",
    "                    et lit la reponse utilisateur \n",
    "    Retourne +1 ou -1 selon la reponse lue.\"\"\"\n",
    "    print(q['question'])\n",
    "    ...\n",
    "    \n",
    "    \n",
    "    ...\n",
    "          \n",
    "def questionnaire(qs):\n",
    "    \"\"\"\n",
    "    list[dict] -> float\n",
    "    Hypothese :\n",
    "      - qs de type list[dict] : chaque element de qs est un dictionnaire\n",
    "      - les denominations des cles des elements de qs sont explicites\n",
    "    Effet de Bord :\n",
    "        Pose toutes les questions du questionnaire qs passé en argument.\n",
    "    \"\"\"\n",
    "    score = 0\n",
    "    for i in range(len(qs)):\n",
    "        print(\"Question\", i+1, \":\", end=\"  \")\n",
    "        score += question(qs[i])\n",
    "        print()\n",
    "    print(\"Fin du questionnaire.\")    \n",
    "    return score/len(qs) *100\n",
    "          \n",
    "𝚜𝚌𝚘𝚛𝚎 = 𝚚𝚞𝚎𝚜𝚝𝚒𝚘𝚗𝚗𝚊𝚒𝚛𝚎(𝚚𝚜_test)\n",
    "print(f\"𝚅𝚘𝚝𝚛𝚎 𝚜𝚌𝚘𝚛𝚎 𝚎𝚜𝚝 𝚍𝚎 {score} %.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questionnaire dans un fichier  \n",
    "\n",
    "Plutôt que d'écrire tout le questionnaire dans votre script $\\texttt{Python}$, il peut être pratique de stocker le questionnaire dans un fichier. Ceci permet d'avoir plusieurs questionnaires : \"culture_generale.qcm\", \"mathematiques.qcm\", \"cinema.qcm\", ...\n",
    "\n",
    "On peut utiliser des fichiers de la forme suivante :\n",
    "\n",
    "* le fichier est composé de questions,\n",
    "* chaque question est sur une seule ligne,\n",
    "* la bonne réponse est sur une seule ligne et la ligne commence par un signe \"+\",\n",
    "* la mauvaise réponse est sur une seule ligne et la ligne commence par un signe \"-\",\n",
    "* il y a une ligne blanche avant la question suivante.\n",
    "\n",
    "Par exemple :\n",
    "\n",
    "Quelle est la couleur du cheval blanc d'Henry IV ?  \n",
    "$+$ blanc  \n",
    "$-$ gris  \n",
    "\n",
    "Combien fait 2 + 2 ?  \n",
    "$-$ 42  \n",
    "$+$ 4  \n",
    "\n",
    "Un brelan de rois gagne une couleur  \n",
    "$-$ vrai  \n",
    "$+$ faux  \n",
    "\n",
    "**Remarque :  vérifiez absolument que votre fichier ne comporte pas de ligne vide à la fin...**  \n",
    "**Rappel : on peut supprimer les deux premiers caractères d'une chaine avec $\\texttt{s = s[2:]}$**\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Question 6 \n",
    "\n",
    "Écrire une fonction \"$\\texttt{lecture_quizz}$\" qui prend un nom de fichier en argument et renvoie le questionnaire (liste de dictionnaires) correspondant.\n",
    "\n",
    "Par exemple, le fichier ci-dessus <a href=\"http://lycee.lagrave.free.fr/nsi/programmation/qcm_test.qcm\" target=\"_blank\">qcm_test.qcm</a> donnera exactement le questionnaire qs donné précédemment.\n",
    "\n",
    "**Remarque :**  \n",
    "Chaque question comporte exactement 4 lignes :\n",
    "\n",
    "* la question,\n",
    "* les deux réponses,\n",
    "* une ligne blanche.\n",
    "\n",
    "**Lorsque la ligne blanche devient vide, cela veut dire qu'on a atteint la fin du fichier.**\n",
    "\n",
    "Il est donc possible de récupérer les questions une par une, dans une boucle $\\texttt{while}$ :  \n",
    "tant qu'on n'a pas trouvé la dernière ligne, on fait quatre $\\texttt{readline}(\\ )$ pour récupérer la question, les deux réponses et la ligne blanche...\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'question': \"Quelle est la couleur du cheval blanc d'Henry IV ?\",\n",
       "  'correcte': 'blanc',\n",
       "  'incorrecte': 'gris'},\n",
       " {'question': 'Combien fait 2 + 2 ?', 'incorrecte': '42', 'correcte': '4'},\n",
       " {'question': 'Un brelan de rois gagne une couleur',\n",
       "  'incorrecte': 'vrai',\n",
       "  'correcte': 'faux'}]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def lecture_quizz(fichier):\n",
    "    \"\"\"\n",
    "    str -> list[dict]\n",
    "    Hypothese : fichier contient les questions du qcm\n",
    "      - chaque question est sur une seule ligne,\n",
    "      - la bonne réponse est sur une seule ligne\n",
    "        commençant par un signe \"+\",\n",
    "      - la mauvaise réponse est sur une seule ligne\n",
    "        commençant par un signe \"-\",\n",
    "      - il y a une ligne blanche avant la question suivante.\n",
    "    Retourne le questionnaire formaté correspondant.\"\"\"\n",
    "    qs = []\n",
    "    f = open(fichier, mode=\"r\")\n",
    "    ligne = f.readline()\n",
    "    while ligne != \"\" :\n",
    "        dico = {'question':ligne.rstrip()}\n",
    "        for rep in range(2) :\n",
    "            ligne = f.readline()\n",
    "            if ligne[0] == '+' :\n",
    "                dico['correcte'] = ligne[2:].rstrip()\n",
    "            else : \n",
    "                dico['incorrecte'] = ligne[2:].rstrip()\n",
    "        ligne = f.readline()\n",
    "        qs += [dico]\n",
    "        ligne = f.readline()\n",
    "    ...\n",
    "    ...\n",
    "\n",
    "lecture_quizz('qcm_test.qcm')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Un peu d'aléatoire ... sur les questions\n",
    "\n",
    "Toujours poser les questions dans le même ordre n'est pas une très bonne idée.  \n",
    "Pour mélanger les questions, vous pouvez utiliser la procédure \"$\\texttt{shuffle}$\" de la bibliothèque \"$\\texttt{random}$\".  \n",
    "Cette procédure permet de mélanger une liste existante :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 5, 6, 4, 3, 2]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from random import shuffle\n",
    "L = [1,2,3,4,5,6]\n",
    "shuffle(L)\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Question 7  \n",
    "\n",
    "Modifier la fonction \"$\\texttt{questionnaire}$\" pour qu'elle affiche les questions dans le désordre. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question 1 :  2 + 2 = ?\n",
      "1 - 4\n",
      "2 - 42\n",
      "Entrez votre choix:1\n",
      "\n",
      "Question 2 :  Quelle est la couleur du cheval blanc d'Henry IV ?\n",
      "1 - blanc\n",
      "2 - gris\n",
      "Entrez votre choix:1\n",
      "\n",
      "Question 3 :  Un brelan de rois gagne une couleur.\n",
      "1 - faux\n",
      "2 - vrai\n",
      "Entrez votre choix:1\n",
      "\n",
      "Fin du questionnaire.\n",
      "𝚅𝚘𝚝𝚛𝚎 𝚜𝚌𝚘𝚛𝚎 𝚎𝚜𝚝 𝚍𝚎 100.0 %.\n"
     ]
    }
   ],
   "source": [
    "from random import shuffle\n",
    "\n",
    "def questionnaire(qs):\n",
    "    \"\"\"\n",
    "    list[dict] -> float\n",
    "    Hypothese :\n",
    "      - qs de type list[dict] : chaque element de qs est un dictionnaire\n",
    "      - les denominations des cles des elements de qs sont explicites\n",
    "    Effet de Bord :\n",
    "        Pose toutes les questions du questionnaire qs passé en argument.\n",
    "    \"\"\"\n",
    "    ...\n",
    "    ...\n",
    "    \n",
    "          \n",
    "𝚜𝚌𝚘𝚛𝚎 = 𝚚𝚞𝚎𝚜𝚝𝚒𝚘𝚗𝚗𝚊𝚒𝚛𝚎(𝚚𝚜_test)\n",
    "print(f\"𝚅𝚘𝚝𝚛𝚎 𝚜𝚌𝚘𝚛𝚎 𝚎𝚜𝚝 𝚍𝚎 {score} %.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Un peu d'aléatoire ... sur les réponses\n",
    "\n",
    "Pour afficher les réponses possibles dans un ordre aléatoire (avec parfois la bonne réponse en premier et parfois la bonne réponse en second), on peut utiliser la fonction \"$\\texttt{randint(0,1)}$\" du module \"$\\texttt{random}$\".  \n",
    "Elle permet de tirer un bit (\"$\\texttt{0}$\" ou \"$\\texttt{1}$\") aléatoirement. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0\n",
      "1\n",
      "1\n",
      "1\n",
      "0\n",
      "1\n",
      "0\n",
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "for i in range(10):\n",
    "    print(randint(0,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Question 8  \n",
    "\n",
    "Modifiez-votre fonction \"$\\texttt{question}$\" pour que l'ordre des réponses possibles soit aléatoire.\n",
    "\n",
    "Vérifiez que le score reste correct...\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question 1 :  Un brelan de rois gagne une couleur.\n",
      "1 - faux\n",
      "2 - vrai\n",
      "Entrez votre choix:1\n",
      "\n",
      "Question 2 :  Quelle est la couleur du cheval blanc d'Henry IV ?\n",
      "1 - blanc\n",
      "2 - gris\n",
      "Entrez votre choix:1\n",
      "\n",
      "Question 3 :  2 + 2 = ?\n",
      "1 - 4\n",
      "2 - 42\n",
      "Entrez votre choix:1\n",
      "\n",
      "Fin du questionnaire.\n",
      "𝚅𝚘𝚝𝚛𝚎 𝚜𝚌𝚘𝚛𝚎 𝚎𝚜𝚝 𝚍𝚎 100.0 %.\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "def question(q):\n",
    "    \"\"\"\n",
    "    dict -> int\n",
    "    Hypothese :\n",
    "      - q de type dictionnaire :\n",
    "      - les denominations des cles de q sont ici explicites\n",
    "    Effet de Bord : affiche la question, les deux reponses possibles\n",
    "                    et lit la reponse utilisateur \n",
    "    Retourne +1 ou -1 selon la reponse lue.\"\"\"\n",
    "    print(q['question'])\n",
    "    ...\n",
    "    ...\n",
    "    \n",
    "    \n",
    "\n",
    "𝚜𝚌𝚘𝚛𝚎 = 𝚚𝚞𝚎𝚜𝚝𝚒𝚘𝚗𝚗𝚊𝚒𝚛𝚎(𝚚𝚜_test)\n",
    "print(f\"𝚅𝚘𝚝𝚛𝚎 𝚜𝚌𝚘𝚛𝚎 𝚎𝚜𝚝 𝚍𝚎 {score} %.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sauvegarde du meilleur score  \n",
    "\n",
    "On peut utiliser un fichier texte \"$\\texttt{score.txt}$\" pour conserver le score et le nom du meilleur joueur.  \n",
    "Lorsqu'un utilisateur obtient un nouveau meilleur score, on met ce fichier à jour.\n",
    "\n",
    "Le plus simple est de mettre le nom du joueur sur la première ligne et le score sur la deuxième ligne.  \n",
    "Par exemple :\n",
    "\n",
    "Tartempion  \n",
    "75.0\n",
    "\n",
    "#### Question 9   \n",
    "\n",
    "En utilisant les fonctions de la partie \"**Préliminaires**\", écrivez une procédure \"$\\texttt{gestion_score(s)}$\" qui prend un score en argument et fait les choses suivantes :\n",
    "\n",
    "* récupère le meilleur score dans le fichier \"$\\texttt{score.txt}$\",\n",
    "* si \"$\\texttt{s}$\" est supérieur au meilleur score, demande le nom du joueur \n",
    "  (avec la fonction $\\texttt{input}$),\n",
    "* écrit le nom du joueur et son score dans le fichier \"$\\texttt{score.txt}$\".\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gestion_score(s):\n",
    "    \"\"\"\n",
    "    Hypothese :\n",
    "      - s de type float : score du joueur\n",
    "      - le meilleur score est sauvegardé dans le fichier score.txt\n",
    "    Effet de Bord :\n",
    "        Si le score passé en argument > au meilleur score :\n",
    "        demande le nom du joueur et met à jour le fichier score.txt\n",
    "    \"\"\"\n",
    "    ...\n",
    "    ...\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fonction principale  \n",
    "\n",
    "#### Question 10   \n",
    "\n",
    "Incorporez vos fonctions dans une unique procédure principale \"$\\texttt{quizz(fichier)}$\" qui :\n",
    "\n",
    "* affiche le meilleur score et le nom du joueur correspondant,\n",
    "* lit le questionnaire dans le fichier,\n",
    "* pose les questions, dans le désordre, avec les réponses possibles dans le désordre,\n",
    "* calcule le score du joueur,\n",
    "* met le meilleur score à jour.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Meilleur score : 3.5 -> NOM : LAGRAVE\n",
      "--------------------------------------------------\n",
      "\n",
      "Question 1 :  Quelle est la couleur du cheval blanc d'Henry IV ?\n",
      "1 - gris\n",
      "2 - blanc\n",
      "Entrez votre choix:2\n",
      "\n",
      "Question 2 :  Combien fait 2 + 2 ?\n",
      "1 - 4\n",
      "2 - 42\n",
      "Entrez votre choix:1\n",
      "\n",
      "Question 3 :  Un brelan de rois gagne une couleur\n",
      "1 - faux\n",
      "2 - vrai\n",
      "Entrez votre choix:1\n",
      "\n",
      "Fin du questionnaire.\n",
      "Entrez le nom du joueur : LAGRAVE\n"
     ]
    }
   ],
   "source": [
    "from random import shuffle, randint\n",
    "\n",
    "def quizz(fichier) : \n",
    "    \"\"\"\n",
    "    Hypothese :\n",
    "      - le questionnaire est passé en argument dans un fichier\n",
    "      - le meilleur score est sauvegardé dans le fichier score.txt\n",
    "    Effet de Bord :\n",
    "        Affiche le meilleur score et le nom du joueur correspondant\n",
    "        Lance l'execution sous forme de qcm et enregistre le score\n",
    "        Si le score obtenu > au meilleur score :\n",
    "        demande le nom du joueur et met à jour le fichier score.txt\n",
    "    \"\"\"    \n",
    "    f = open('score.txt', mode=\"r\")\n",
    "    entete = f.readline().rstrip()\n",
    "    score = f.readline().rstrip()\n",
    "    f.close()\n",
    "    print(f\"Meilleur score : {score} -> NOM : {entete}\")\n",
    "    print(\"-\"*50)\n",
    "    print()\n",
    "    qs = lecture_quizz(fichier)\n",
    "    ...\n",
    "    ...\n",
    "    \n",
    "    \n",
    "quizz('qcm_test.qcm')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <div id=\"S3\">Question à choix multiple</div> \n",
    "\n",
    "<div style=\"text-align : right\"><a href=\"#top\">Retour</a></div> \n",
    "\n",
    "Nous allons maintenant gérer les QCM où le nombre de réponses proposées peut-être supérieur à deux.\n",
    "\n",
    "Lorsque le nombre de réponses proposées est plus grand que 2, il faut gérer les mauvaises réponses différemment.  \n",
    "On remplace le champ \"incorrecte\" du dictionnaire par une liste de mauvaises réponses.  \n",
    "Par symétrie, le champ \"correcte\" contiendra lui aussi une liste de bonnes réponses.  \n",
    "(La plupart du temps, il n'y aura qu'une seule bonne réponse...)\n",
    "\n",
    "Voici un exemple de code $\\texttt{Python}$ produisant un questionnaire modifié : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "qcm = [{'question': \"Quelle est la couleur du cheval blanc d'Henry IV ?\",\n",
    "        'correctes': [\"blanc\"],\n",
    "        'incorrectes': [\"gris\",\"rouge à pois vert\",\"transparent\"]},\n",
    "       {'question': \"0 + 0 = ?\",\n",
    "        'correctes': [\"0\", \"la tête à Toto\"],\n",
    "        'incorrectes': [\"42\", \"c'est trop dur\"]}]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " **Attention :** le score est calculé de la manière suivante : s'il y a $n$ bonnes réponses et $m$ mauvaises réponses, le joueur\n",
    "\n",
    "* gagne 1.0 point pour une bonne réponse,  \n",
    "* perd $n / m$ point pour une mauvaise réponse.  \n",
    "\n",
    "Ceci permet d'assurer qu'en moyenne un joueur répondant au hasard a $0$pt. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Question 11  \n",
    "\n",
    "Écrire une fonction \"$\\texttt{question_qcm}$\" similaire à la fonction \"$\\texttt{question}$\" pour prendre les réponses multiples en compte.\n",
    "\n",
    "Pour mélanger les réponses, le plus simple est de :\n",
    "\n",
    "* créer un tableau reponses qui contient toutes les réponses, bonnes et mauvaises,\n",
    "* mélanger ce tableau (avec la méthode shuffle),\n",
    "* afficher les réponses et demander le choix du joueur,\n",
    "* vérifier si la réponse fournie correspond à une bonne ou une mauvaise réponse  \n",
    "  (en regardant si la réponse est $\\texttt{in q[\"correctes\"]}$ ou $\\texttt{in q[\"incorrectes\"]}$).\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question 1 :  Quelle est la couleur du cheval blanc d'Henry IV ?\n",
      "1 - blanc\n",
      "2 - rouge à pois vert\n",
      "3 - transparent\n",
      "4 - gris\n",
      "Entrez votre réponse (en séparant éventuellement vos choix par une virgule) :1\n",
      "\n",
      "Question 2 :  0 + 0 = ?\n",
      "1 - 0\n",
      "2 - la tête à Toto\n",
      "3 - 42\n",
      "4 - c'est trop dur\n",
      "Entrez votre réponse (en séparant éventuellement vos choix par une virgule) :1,2\n",
      "\n",
      "Fin du questionnaire.\n",
      "𝚅𝚘𝚝𝚛𝚎 𝚜𝚌𝚘𝚛𝚎 𝚎𝚜𝚝 𝚍𝚎 100.0 %.\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "totalpt = 0\n",
    "\n",
    "def question_qcm(q):\n",
    "    \"\"\"\n",
    "    dict -> float\n",
    "    Hypothese :\n",
    "      - q de type dictionnaire :\n",
    "        n réponses 'correctes' et m réponses 'incorrectes'\n",
    "      - les denominations des cles de q sont explicites\n",
    "    Effet de Bord : affiche la question, les reponses possibles\n",
    "                    et lit les reponses utilisateur \n",
    "    Retourne le score de la question :\n",
    "             +1 par bonne réponse et -n/m par mauvaise réponse.\"\"\"\n",
    "    print(q['question'])\n",
    "    tri = []\n",
    "    n = len(q['correctes'])\n",
    "    m = len(q['incorrectes'])\n",
    "    global totalpt\n",
    "    totalpt += n\n",
    "    for item in q['correctes'] + q['incorrectes'] :\n",
    "        tri.append(item)\n",
    "    shuffle(tri)\n",
    "    for i in range(len(tri)) :\n",
    "        print(f\"{i + 1} - {tri[i]}\")\n",
    "    rep = input(\"Entrez votre réponse (en séparant éventuellement vos choix par une virgule) :\")\n",
    "    pt = 0\n",
    "    for test in rep.split(\",\"):\n",
    "        if tri[int(test)-1] in q['correctes'] :\n",
    "            ...\n",
    "        else : \n",
    "            ...\n",
    "    return pt\n",
    "\n",
    "def questionnaire(qs):\n",
    "    \"\"\"\n",
    "    list[dict] -> float\n",
    "    Hypothese :\n",
    "      - qs de type list[dict] : chaque element de qs est un dictionnaire\n",
    "      - les denominations des cles des elements de qs sont explicites\n",
    "    Effet de Bord :\n",
    "        Pose toutes les questions du questionnaire qs passé en argument.\n",
    "    \"\"\"\n",
    "    score = 0\n",
    "    shuffle(qs)\n",
    "    for i in range(len(qs)):\n",
    "        print(\"Question\", i+1, \":\", end=\"  \")\n",
    "        score += question_qcm(qs[i])\n",
    "        print()\n",
    "    print(\"Fin du questionnaire.\")    \n",
    "    return score/totalpt *100\n",
    "\n",
    "𝚜𝚌𝚘𝚛𝚎 = 𝚚𝚞𝚎𝚜𝚝𝚒𝚘𝚗𝚗𝚊𝚒𝚛𝚎(𝚚cm)\n",
    "print(f\"𝚅𝚘𝚝𝚛𝚎 𝚜𝚌𝚘𝚛𝚎 𝚎𝚜𝚝 𝚍𝚎 {score:.1f} %.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <div id=\"S4\">Questionnaire dans un fichier</div> \n",
    "\n",
    "<div style=\"text-align : right\"><a href=\"#top\">Retour</a></div> \n",
    "\n",
    "Le format de fichier pour les QCM est le même que pour les quizz.  \n",
    "La seule différence est qu'il peut y avoir plusieurs bonnes / mauvaises réponses.  \n",
    "\n",
    "Par exemple :\n",
    "\n",
    "Quelle est la couleur du cheval blanc d'Henry IV ?  \n",
    "$+$ blanc  \n",
    "$-$ gris  \n",
    "$-$ transparent  \n",
    "$-$ rouge à pois verts  \n",
    "\n",
    "\n",
    "Combien fait 0 + 0 ?  \n",
    "$+$ 0  \n",
    "$-$ c'est trop dur  \n",
    "$-$ 42  \n",
    "$+$ la tête à Toto\n",
    "\n",
    "**Remarque :  vérifiez absolument que votre fichier ne comporte pas de ligne vide à la fin...**  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lecture du fichier\n",
    "\n",
    "#### Question 12   \n",
    "\n",
    "Écrire une fonction \"$\\texttt{lecture_qcm()}$\" qui prend un nom de fichier en argument et renvoie le questionnaire (liste de dictionnaires) correspondant.\n",
    "\n",
    "Par exemple :   \n",
    "\n",
    "$\\texttt{>>> lecture_qcm(\"questions.qcm\")}$  \n",
    "[{'question': \"Quelle est la couleur du cheval blanc d'Henry IV ?\"},  \n",
    "'correctes': ['blanc'],  \n",
    "'incorrectes': ['gris', 'transparent', 'rouge à pois verts']},       \n",
    " {'question': 'Combien fait 0 + 0 ?'},  \n",
    " 'correctes': ['0', 'la tête à Toto'],  \n",
    " 'incorrectes': [\"c'est trop dur\"', '42']}]  \n",
    " \n",
    " *Un fichier exemple <a href=\"http://lycee.lagrave.free.fr/nsi/programmation/questions.qcm\" target=\"_blank\">questions.qcm</a>  est disponible.* "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'question': \"Quelle est la couleur du cheval blanc d'Henry IV ?\",\n",
       "  'correctes': ['blanc'],\n",
       "  'incorrectes': ['gris', 'transparent', 'rouge à pois vert']},\n",
       " {'question': 'Combien fait 0 + 0 ?',\n",
       "  'correctes': ['0', 'la tête à Toto'],\n",
       "  'incorrectes': ['4', \"c'est trop dur\", '42', 'vert']},\n",
       " {'question': 'La vitesse de la lumière dans le vide vaut',\n",
       "  'correctes': ['299792258 mètres par seconde'],\n",
       "  'incorrectes': ['300000 kilomètre par seconde',\n",
       "   '330 mètres par seconde',\n",
       "   '90 kilomètres par heure']},\n",
       " {'question': 'Le langage de programmation Python est',\n",
       "  'correctes': ['interprété'],\n",
       "  'incorrectes': ['compilé']},\n",
       " {'question': 'Est-ce que cette phrase est fausse ?',\n",
       "  'correctes': ['???'],\n",
       "  'incorrectes': ['oui', 'non']}]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def lecture_qcm(fichier):\n",
    "    \"\"\"\n",
    "    str -> list[dict]\n",
    "    Hypothese : fichier contient les questions du qcm\n",
    "      - chaque question est sur une seule ligne,\n",
    "      - une bonne réponse est sur une seule ligne\n",
    "        commençant par un signe \"+\",\n",
    "      - une mauvaise réponse est sur une seule ligne\n",
    "        commençant par un signe \"-\",\n",
    "      - il y a 2 lignes blanches avant la question suivante.\n",
    "    Retourne le questionnaire formaté correspondant.\"\"\"\n",
    "    qs = []\n",
    "    f = open(fichier, mode=\"r\")\n",
    "    ligne = f.readline()\n",
    "    while ligne != \"\" :\n",
    "        dico = {'question':ligne.rstrip(),'correctes':[],'incorrectes':[]}\n",
    "        ligne = f.readline()\n",
    "        while ligne != \"\\n\" and ligne != \"\" :\n",
    "            if ligne[0] == '+' :\n",
    "                dico['correctes'].append(ligne[2:].rstrip())\n",
    "            else :\n",
    "                dico['incorrectes'].append(ligne[2:].rstrip())\n",
    "            ligne = f.readline()\n",
    "        ligne = f.readline()  \n",
    "        qs += [dico]\n",
    "        ligne = f.readline()\n",
    "    ...\n",
    "    ...\n",
    "\n",
    "\n",
    "lecture_qcm('questions.qcm')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fonction QCM à partir d'un fichier\n",
    "\n",
    "#### Question 13  \n",
    "\n",
    "Écrire une variante $\\texttt{QCM()}$ de la procédure $\\texttt{quizz()}$ pour utiliser les fonctions précédentes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Meilleur score : 100.0 -> NOM : LAGRAVE\n",
      "--------------------------------------------------\n",
      "\n",
      "Question 1 :  La vitesse de la lumière dans le vide vaut\n",
      "1 - 299792258 mètres par seconde\n",
      "2 - 330 mètres par seconde\n",
      "3 - 300000 kilomètre par seconde\n",
      "4 - 90 kilomètres par heure\n",
      "Entrez votre réponse (en séparant éventuellement vos choix par une virgule) :1\n",
      "\n",
      "Question 2 :  Combien fait 0 + 0 ?\n",
      "1 - 4\n",
      "2 - 42\n",
      "3 - vert\n",
      "4 - la tête à Toto\n",
      "5 - c'est trop dur\n",
      "6 - 0\n",
      "Entrez votre réponse (en séparant éventuellement vos choix par une virgule) :4,6\n",
      "\n",
      "Question 3 :  Quelle est la couleur du cheval blanc d'Henry IV ?\n",
      "1 - gris\n",
      "2 - blanc\n",
      "3 - transparent\n",
      "4 - rouge à pois vert\n",
      "Entrez votre réponse (en séparant éventuellement vos choix par une virgule) :2\n",
      "\n",
      "Question 4 :  Le langage de programmation Python est\n",
      "1 - compilé\n",
      "2 - interprété\n",
      "Entrez votre réponse (en séparant éventuellement vos choix par une virgule) :2\n",
      "\n",
      "Question 5 :  Est-ce que cette phrase est fausse ?\n",
      "1 - non\n",
      "2 - ???\n",
      "3 - oui\n",
      "Entrez votre réponse (en séparant éventuellement vos choix par une virgule) :2\n",
      "\n",
      "Fin du questionnaire.\n",
      "𝚅𝚘𝚝𝚛𝚎 𝚜𝚌𝚘𝚛𝚎 𝚎𝚜𝚝 𝚍𝚎 100.0 %.\n"
     ]
    }
   ],
   "source": [
    "from random import shuffle, randint\n",
    "\n",
    "totalpt = 0\n",
    "\n",
    "def lecture_qcm(fichier):\n",
    "    \"\"\"\n",
    "    str -> list[dict]\n",
    "    Hypothese : fichier contient les questions du qcm\n",
    "      - chaque question est sur une seule ligne,\n",
    "      - une bonne réponse est sur une seule ligne\n",
    "        commençant par un signe \"+\",\n",
    "      - une mauvaise réponse est sur une seule ligne\n",
    "        commençant par un signe \"-\",\n",
    "      - il y a 2 lignes blanches avant la question suivante.\n",
    "    Retourne le questionnaire formaté correspondant.\"\"\"\n",
    "    qs = []\n",
    "    f = open(fichier, mode=\"r\")\n",
    "    ligne = f.readline()\n",
    "    while ligne != \"\" :\n",
    "        dico = {'question':ligne.rstrip(),'correctes':[],'incorrectes':[]}\n",
    "        ligne = f.readline()\n",
    "        while ligne != \"\\n\" and ligne != \"\" :\n",
    "            if ligne[0] == '+' :\n",
    "                dico['correctes'].append(ligne[2:].rstrip())\n",
    "            else :\n",
    "                dico['incorrectes'].append(ligne[2:].rstrip())\n",
    "            ligne = f.readline()\n",
    "        ligne = f.readline()  \n",
    "        qs += [dico]\n",
    "        ligne = f.readline()\n",
    "    f.close()\n",
    "    return qs\n",
    "\n",
    "def question_qcm(q):\n",
    "    \"\"\"\n",
    "    dict -> float\n",
    "    Hypothese :\n",
    "      - q de type dictionnaire :\n",
    "        n réponses 'correctes' et m réponses 'incorrectes'\n",
    "      - les denominations des cles de q sont explicites\n",
    "    Effet de Bord : affiche la question, les reponses possibles\n",
    "                    et lit les reponses utilisateur \n",
    "    Retourne le score de la question :\n",
    "             +1 par bonne réponse et -n/m par mauvaise réponse.\"\"\"\n",
    "    print(q['question'])\n",
    "    tri = []\n",
    "    n = len(q['correctes'])\n",
    "    m = len(q['incorrectes'])\n",
    "    global totalpt\n",
    "    totalpt += n\n",
    "    for item in q['correctes'] + q['incorrectes'] :\n",
    "        tri.append(item)\n",
    "    shuffle(tri)\n",
    "    for i in range(len(tri)) :\n",
    "        print(f\"{i + 1} - {tri[i]}\")\n",
    "    rep = input(\"Entrez votre réponse (en séparant éventuellement vos choix par une virgule) :\")\n",
    "    pt = 0\n",
    "    for test in rep.split(\",\"):\n",
    "        if tri[int(test)-1] in q['correctes'] :\n",
    "            pt += 1\n",
    "        else : \n",
    "            pt -= n/m\n",
    "    return pt\n",
    "\n",
    "def questionnaire(qs):\n",
    "    \"\"\"\n",
    "    list[dict] -> float\n",
    "    Hypothese :\n",
    "      - qs de type list[dict] : chaque element de qs est un dictionnaire\n",
    "      - les denominations des cles des elements de qs sont explicites\n",
    "    Effet de Bord :\n",
    "        Pose toutes les questions du questionnaire qs passé en argument.\n",
    "    \"\"\"\n",
    "    score = 0\n",
    "    shuffle(qs)\n",
    "    for i in range(len(qs)):\n",
    "        print(\"Question\", i+1, \":\", end=\"  \")\n",
    "        score += question_qcm(qs[i])\n",
    "        print()\n",
    "    print(\"Fin du questionnaire.\")    \n",
    "    return score/totalpt *100\n",
    "\n",
    "def QCM(fichier) : \n",
    "    \"\"\"\n",
    "    Hypothese :\n",
    "      - le questionnaire est passé en argument dans un fichier\n",
    "      - le meilleur score est sauvegardé dans le fichier score.txt\n",
    "    Effet de Bord :\n",
    "        Affiche le meilleur score et le nom du joueur correspondant\n",
    "        Lance l'execution du qcm et enregistre le score\n",
    "        Si le score obtenu > au meilleur score :\n",
    "        demande le nom du joueur et met à jour le fichier score.txt\n",
    "    \"\"\"    \n",
    "    f = open('score.txt', mode=\"r\")\n",
    "    entete = f.readline().rstrip()\n",
    "    score = f.readline().rstrip()\n",
    "    f.close()\n",
    "    print(f\"Meilleur score : {score} -> NOM : {entete}\")\n",
    "    print(\"-\"*50)\n",
    "    print()\n",
    "    ...\n",
    "    ...\n",
    "    print(f\"𝚅𝚘𝚝𝚛𝚎 𝚜𝚌𝚘𝚛𝚎 𝚎𝚜𝚝 𝚍𝚎 {s:.1f} %.\")\n",
    "    gestion_score(s)\n",
    "    \n",
    "QCM('questions.qcm')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}