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>`_