Feat(NSI): ajoute tester les fonctions et export en html

1NSI/04_Fonctions_specifications_et_tests/1E fonctions de décorations.ipynb

@@ -463,7 +463,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.8"
+   "version": "3.10.9"
   }
  },
  "nbformat": 4,

1NSI/04_Fonctions_specifications_et_tests/2E fonction documentations.ipynb

@@ -350,7 +350,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.8"
+   "version": "3.10.9"
   }
  },
  "nbformat": 4,

1NSI/04_Fonctions_specifications_et_tests/3E Tester des fonctions.ipynb

@@ -0,0 +1,482 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9b151783",
+   "metadata": {},
+   "source": [
+    "# Tests et fonctions\n",
+    "\n",
+    "Jusqu'à présent, pour tester des fonctions, vous exécutiez la fonction et vous vérifiez que le résultat était celui attendu. Pour s'assurer que la fonction marche bien comme comme on l'entend, il faut écrire des **tests**.\n",
+    "\n",
+    "Pour cela, on utilise le mot clé: `assert` (affirmer en français).\n",
+    "\n",
+    "Par exemple, on peut écrire le test suivant"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a56fd205",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert 1+2 == 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2202397b",
+   "metadata": {},
+   "source": [
+    "Rien ne se passe, c'est normal, le test est validé.\n",
+    "\n",
+    "Par contre, le test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b2d4859e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert 1+1 == 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "968bfafa",
+   "metadata": {},
+   "source": [
+    "ne passe pas(ouf).\n",
+    "\n",
+    "Même s'il est difficile de s'astreindre à cette rigueur, il est conseillé d'écrire les tests avant la fonction. Cela permet de se mettre au clair sur ce que l'on attend du fonctionnement de la fonction.\n",
+    "\n",
+    "Par exemple, on souhaite ecrire une fonction qui prend en paramètre un score entre 0 et 25 et qui renvoie la qualité de la prestation en fonction du tableau suivant\n",
+    "\n",
+    "![regles](./fig/regle_hanabi.png)\n",
+    "\n",
+    "On décide que la fonction s'appellera `prestation` et que l'on ne retournera que le début du texte.\n",
+    "\n",
+    "On peut alors écrire les tests suivants"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5749cbaf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert prestation(4) == \"H\"\n",
+    "assert prestation(7) == \"M\"\n",
+    "assert prestation(12) == \"H\"\n",
+    "assert prestation(17) == \"Exc\"\n",
+    "assert prestation(22) == \"Ext\"\n",
+    "assert prestation(25) == \"L\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1c20db23",
+   "metadata": {},
+   "source": [
+    "Pour le moment, ces tests ne *passent* pas. C'est normal, nous n'avons pas encore écrit la fonction.\n",
+    "\n",
+    "A vous de la faire (enlevé le mot clé `pass` avant de compléter la fonction)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "20c39faf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def prestation():\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cfddb3de",
+   "metadata": {},
+   "source": [
+    "On souhaite ajouter les deux tests suivants pour éviter de chercher un qualificatif inéxistant."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0c9f5415",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert prestation(0) == \"Erreur\"\n",
+    "assert prestation(27) == \"Erreur\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "550c8156",
+   "metadata": {},
+   "source": [
+    "Modifier la fonction `prestation` pour que ces tests passent.\n",
+    "\n",
+    "Enfin dans la pratique, on regroupe tous les tests dans une ou plusieurs fonctions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0716e117",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def test_prestation():\n",
+    "    assert prestation(4) == \"H\"\n",
+    "    assert prestation(7) == \"M\"\n",
+    "    assert prestation(12) == \"H\"\n",
+    "    assert prestation(17) == \"Exc\"\n",
+    "    assert prestation(22) == \"Ext\"\n",
+    "    assert prestation(25) == \"L\"\n",
+    "    assert prestation(0) == \"Erreur\"\n",
+    "    assert prestation(27) == \"Erreur\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4d3cb26b",
+   "metadata": {},
+   "source": [
+    "Et on fait passer les tests en exécutant."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cab73efc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_prestation()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e06e55cb",
+   "metadata": {},
+   "source": [
+    "Les tests sont passés quand rien ne se passe."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "698ae343",
+   "metadata": {},
+   "source": [
+    "## Fonctions de calendrier\n",
+    "\n",
+    "Dans la suite, vous allez écrire des fonctions pour manipuler les dates du calendier.\n",
+    "\n",
+    "Pour les programmer, vous aurez besoin de savoir si un nombre est divisible par d'un autre. Pour cela, on utilise l'opérateur `%` qui donne le reste de la division eublidienne."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "92a23517",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "3 % 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b0ea399d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "10 % 5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f62d21cb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "9 % 5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f30669d9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "17 % 5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "665d03a2",
+   "metadata": {},
+   "source": [
+    "Ainsi pour savoir si un nombre est divisible par un autre, il faut que le reste de la division euclidienne soit égal à 0.\n",
+    "\n",
+    "Vérifier si 123456789 est divisible par 3 (on veut avoir True ou False comme réponse - pas besoin d'écrire une fonction pour cela)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e966d0cb",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "642178d9",
+   "metadata": {},
+   "source": [
+    "Vérifier si 123456789 est divisible par 7"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2d9fbbd9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e87024c4",
+   "metadata": {},
+   "source": [
+    "Vérifier si 123456789 est divisible par 3803"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "111ef141",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "37748954",
+   "metadata": {},
+   "source": [
+    "### Années bissextiles\n",
+    "\n",
+    "On rappelle qu'une année est dites **bissextile** si elle est divisible par 4. Les siècles ne sont pas pas bissextiles sauf les multiples de 400.\n",
+    "\n",
+    "Vous allez devoir écrire une fonction `est_bissextile` qui prend en argument une année et qui renvoie `True` si elle bissextile et `False` sinon.\n",
+    "\n",
+    "Tests de la fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08130e6f",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e367d29",
+   "metadata": {},
+   "source": [
+    "La fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c7b0673f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def est_bissextile():\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "43ccc643",
+   "metadata": {},
+   "source": [
+    "## Nombre de jours dans le mois\n",
+    "\n",
+    "Vous devez écrire une fonction `nb_jours_mois` qui prend en argument le numéro du mois (1 pour janvier, 7 pour juillet...) et une année et qui renvoie le nombre de jours que contient le mois.\n",
+    "\n",
+    "Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "68d24122",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "30bb7765",
+   "metadata": {},
+   "source": [
+    "La fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b5111f24",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def nb_jours_mois():\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9894ecf2",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22c263a7",
+   "metadata": {},
+   "source": [
+    "### Nombre de jours depuis de début de l'année\n",
+    "\n",
+    "\n",
+    "Vous devez écrire une fonction `nb_jours_debut_annee` qui prend en argument une date décomposé en jour, mois et année et qui renvoie le nombre de jours depuis le début de l'année jusqu'à cette date.\n",
+    "\n",
+    "Test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1443e43c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ffff8b65",
+   "metadata": {},
+   "source": [
+    "La fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "76908583",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def nb_jours_debut_annee(jour, mois, annee):\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf369afd",
+   "metadata": {},
+   "source": [
+    "### Jour de la semaine\n",
+    "\n",
+    "On code les jours de la semaine de la manière suivante: \n",
+    "\n",
+    "    0 -> Lundi, 1 -> Mardi ... 6 -> Dimanche\n",
+    "\n",
+    "Vous devez écrire une fonction `jour_semaine` qui prend en argument une date (décomposée comme précédement) et le code du premier jour de l'année correspondante et qui renvoie le code de la date indiquée.\n",
+    "\n",
+    "Voici quelques tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e903bc1a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def test_jour_semaine():\n",
+    "    assert jour_semaine(14, 7, 2022, 5) == 3    \n",
+    "    assert jour_semaine(1, 3, 1933, 6) == 2\n",
+    "    assert jour_semaine(25, 12, 2004, 3) == 5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9909f403",
+   "metadata": {},
+   "source": [
+    "La fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "feb24c9c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def jour_semaine(jour, mois, annee, jour0):\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "587f5f62",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.10.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

1NSI/04_Fonctions_specifications_et_tests/index.rst

@@ -2,7 +2,7 @@ Fonctions spécifications et tests
 #################################
 
 :date: 2022-12-02
-:modified: 2023-01-03
+:modified: 2023-01-07
 :authors: Benjamin Bertrand
 :tags: Programmation
 :category: 1NSI
@@ -35,6 +35,7 @@ Progression
 
 Activité capytale pour apprendre à programmer des fonctions en décorant du texte.
 
+- `Fonctions décoratives (html) <./1E fonctions de décorations.html>`_
 - `Fonctions décoratives (notebook) <./1E fonctions de décorations.ipynb>`_
 
 Bilan: structure d'une fonction, arguments, valeur retournée, spécifications
@@ -49,6 +50,7 @@ Bilan: structure d'une fonction, arguments, valeur retournée, spécifications
 
 Fonctions plus classiques à programmer et à documenter.
 
+- `Fonctions et documentation (html) <./2E fonction documentations.html>`_
 - `Fonctions et documentation (notebook) <./2E fonction documentations.ipynb>`_
 
 Bilan: documenter et spécifier une fonction
@@ -63,3 +65,6 @@ Bilan: documenter et spécifier une fonction
 ----------------------------
 
 Écrire des tests avant d'écrire une fonction. Utilisation d'assert.
+
+- `Fonctions et tests (html) <./3E Tester des fonctions.html>`_
+- `Fonctions et tests (notebook) <./3E Tester des fonctions.ipynb>`_

1NSI/Evaluations/DS_2023-01-09/annexes/QCM_f.py

@@ -0,0 +1,5 @@
+def f(x, y):
+    x = x + y
+    y = x - y
+    x = x - y
+    return (x, y)

1NSI/Evaluations/DS_2023-01-09/annexes/QCM_for.py

@@ -0,0 +1,3 @@
+n = 1
+for i in range(4):
+    n = n + 2

1NSI/Evaluations/DS_2023-01-09/annexes/QCM_if.py

@@ -0,0 +1,10 @@
+a = 3
+b = 4
+if a > b and a == 3:
+    print('vert')
+if a > b and b == 4:
+    print('rouge')
+if a == 4 or b > a:
+    print('bleu')
+if a == 3 or a < b:
+    print('jaune')

1NSI/Evaluations/DS_2023-01-09/annexes/QCM_while.py

@@ -0,0 +1,5 @@
+compt = 0
+resultat = 1
+while compt !=7:
+    resultat = resultat * compt
+    compt = compt + 1

1NSI/Evaluations/DS_2023-01-09/exercises.tex

@@ -0,0 +1,171 @@
+\begin{exercise}[subtitle={QCM}, step={1}, origin={Annales}, topics={  }, tags={  }]
+    \begin{enumerate}
+        \item Quelle commande permet de connaître le répertoire courant ?
+
+            \textbf{Réponses}
+            \begin{multicols}{4}
+                \begin{enumerate}
+                    \item \mintinline{bash}{cd}
+                    \item \mintinline{bash}{ls}
+                    \item \mintinline{bash}{pwd}
+                    \item \mintinline{bash}{chmod}
+                \end{enumerate}
+            \end{multicols}
+
+        \item Quelle est la racine du système de fichier de Linux?
+
+            \textbf{Réponses}
+            \begin{multicols}{4}
+                \begin{enumerate}
+                    \item \mintinline{bash}{/}
+                    \item \mintinline{bash}{root}
+                    \item \mintinline{bash}{sudo}
+                    \item \mintinline{bash}{home}
+                \end{enumerate}
+            \end{multicols}
+
+        \item À partir du répertoire \mintinline{bash}{~/Perso/Doc} quelle commande permet de rejoindre le répertoire \mintinline{bash}{~/Public} ?
+
+            \textbf{Réponses}
+            \begin{multicols}{2}
+                \begin{enumerate}
+                    \item \mintinline{bash}{cd ./Public}
+                    \item \mintinline{bash}{cd ../Public}
+                    \item \mintinline{bash}{cd ././Public}
+                    \item \mintinline{bash}{cd ../../Public}
+                \end{enumerate}
+            \end{multicols}
+
+
+        \item Depuis le répertoire \texttt{/home/ubuntu/} on exécute la commande: \mintinline{bash}{mkdir ./Documents/Plop}
+
+            Quel est son effet?
+            \textbf{Réponses}
+            \begin{enumerate}
+                \item supprimer le dossier \texttt{Plop} situé dans \texttt{Documents}
+                \item changer de répertoire pour se retrouver dans le répertoire \texttt{/home/Documents/Plop}
+                \item créer un dossier \texttt{Plop} dans le répertoire \texttt{/home/ubuntu/Documents}
+                \item lister le contenu du répertoire \texttt{Plop} dans \texttt{Documents}
+            \end{enumerate}
+
+        \item Dans un terminal sous Linux, quelle commande faut-il écrire pour donner à tout le monde le droit d'écriture sur un fichier \texttt{information.py}?
+
+            \textbf{Réponses}
+            \begin{multicols}{2}
+                \begin{enumerate}
+                    \item \mintinline{bash}{chmod o+w information.py}
+                    \item \mintinline{bash}{chmod a+w information.py}
+                    \item \mintinline{bash}{chmod o+x information.py}
+                    \item \mintinline{bash}{chmod a+x information.py}
+                \end{enumerate}
+            \end{multicols}
+
+        \item Lequel de ces systèmes d'exploitation est sous licence propriétaire ?
+
+            \textbf{Réponses}
+            \begin{multicols}{4}
+                \begin{enumerate}
+                    \item \mintinline{bash}{Android}
+                    \item \mintinline{bash}{Linux}
+                    \item \mintinline{bash}{Windows}
+                    \item \mintinline{bash}{Ubuntu}
+                \end{enumerate}
+            \end{multicols}
+
+        \item Qu'affiche le programme suivant :
+            \begin{multicols}{2}
+                \begin{center}
+                    \begin{minipage}{0.8\linewidth}
+                        \inputminted[bgcolor=base3]{python}{./annexes/QCM_if.py}
+                    \end{minipage}
+                \end{center}
+
+                \textbf{Réponses}
+                \begin{enumerate}
+                    \item Vert\\Rouge
+                    \item bleu\\jaune
+                    \item bleu
+                    \item vert\\jaune
+                \end{enumerate}
+            \end{multicols}
+
+        \item Quelle est la valeur de la variable \texttt{n} à la fin de l'exécution du script ci-dessous?
+            \begin{center}
+                \begin{minipage}{0.5\linewidth}
+                    \inputminted[bgcolor=base3]{python}{./annexes/QCM_for.py}
+                \end{minipage}
+            \end{center}
+
+            \textbf{Réponses}
+            \begin{multicols}{4}
+                \begin{enumerate}
+                    \item 1
+                    \item 8
+                    \item 9
+                    \item 18
+                \end{enumerate}
+            \end{multicols}
+
+
+        \item On exécute le script suivant :
+            \begin{center}
+                \begin{minipage}{0.5\linewidth}
+                    \inputminted[bgcolor=base3]{python}{./annexes/QCM_while.py}
+                \end{minipage}
+            \end{center}
+
+            Laquelle de ces affirmations est vraie?
+
+            \textbf{Réponses}
+            \begin{enumerate}
+                \item Le script ne s'arrête pas
+                \item Le script entre 7 fois dans le boucle et à la fin de son exécution, resultat vaut 0.
+                \item Le script entre 7 fois dans le boucle et à la fin de son exécution, resultat vaut 720.
+                \item Le script entre 6 fois dans le boucle et à la fin de son exécution, resultat vaut 0.
+            \end{enumerate}
+
+        \item On définit la fonction suivante
+            \begin{center}
+                \begin{minipage}{0.5\linewidth}
+                    \inputminted[bgcolor=base3]{python}{./annexes/QCM_f.py}
+                \end{minipage}
+            \end{center}
+            Quel est la valeur renvoyée par l'appel \mintinline{python}{f(2019, 2020)}
+
+            \textbf{Réponses}
+            \begin{multicols}{4}
+                \begin{enumerate}
+                    \item (2019, 2019)
+                    \item (2019, 2020)
+                    \item (2020, 2019)
+                    \item (2020, 2020)
+                \end{enumerate}
+            \end{multicols}
+
+        \item Quelle est l'écriture binaire du nombre entier 183?
+
+            \textbf{Réponses}
+            \begin{multicols}{4}
+                \begin{enumerate}
+                    \item 0100 1000
+                    \item 1110 1101
+                    \item 1011 0111
+                    \item 1001 0101
+                \end{enumerate}
+            \end{multicols}
+
+        \item Quel est le résultat de l'addition binaire \texttt{0100 1110 + 0110 1101 }?
+
+            \textbf{Réponses}
+            \begin{multicols}{4}
+                \begin{enumerate}
+                    \item 0101 1011
+                    \item 1010 1101
+                    \item 1011 0110
+                    \item 1011 1011
+                \end{enumerate}
+            \end{multicols}
+
+    \end{enumerate}
+
+\end{exercise}

1NSI/Evaluations/DS_2023-01-09/sujet.tex

@@ -0,0 +1,29 @@
+\documentclass[a4paper,12pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+
+% Title Page
+\title{ DS2 \hfill }
+\tribe{1NSI}
+\date{09 janvier 2023}
+\duree{1h}
+
+\DeclareExerciseCollection[step=1]{banque}
+\xsimsetup{collect}
+
+\pagestyle{empty}
+
+\begin{document}
+\maketitle
+
+Le barème est donné à titre indicatif, il pourra être modifié.
+
+\input{exercises.tex}
+\printcollection{banque}
+\end{document}
+
+%%% Local Variables:
+%%% mode: latex
+%%% TeX-master: "master"
+%%% End: