Feat: ajoute le lien vers les chapitres syst expl et fonctions

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

@@ -0,0 +1,471 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e51b69a2",
+   "metadata": {},
+   "source": [
+    "# Fonctions python pour décorer du texte\n",
+    "\n",
+    "Dans ce TP, vous allez voir plus en précision la manipulation des chaines de caractère en python et surtout apprendre à manipuler une nouveau concept `les fonctions` en python.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3b934b68",
+   "metadata": {},
+   "source": [
+    "## Décorer du texte: manipulation des str (strings)\n",
+    "\n",
+    "Vous avez déjà vu que les opérations en python n'avait pas le même effets en fonction de type de données sur lesquels elles opéraient.\n",
+    "\n",
+    "1. Pour tous les cas suivants, faire des tests pour décrire l'effet des opérations suivantes\n",
+    "\n",
+    "Ci-dessous vous trouverez quelques chaines de caractères pour faire vos tests. N'hésitez pas à en ajouter d'autres qui vous semblent appropriés."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "5779596e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chaine1 = \"Bonjour \"\n",
+    "chaine2 = \"42\"\n",
+    "chaine3 = \"10.23\"\n",
+    "chaine4 = \"#\"\n",
+    "chaine5 = \"Bonjour\\nComment vas-tu?\\nBien et toi?\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f5ca828f",
+   "metadata": {},
+   "source": [
+    "a) L'opération `+` sur deux chaines de caractères"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "181cceef",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# à compléter"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5907fa80",
+   "metadata": {},
+   "source": [
+    "Description"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1cad7007",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b0d5fa55",
+   "metadata": {},
+   "source": [
+    "b) L'opération `*` entre une chaine de caractères et un entier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "21c1972e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# à compléter"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9b1b85df",
+   "metadata": {},
+   "source": [
+    "Description"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fc031ece",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b55bf1d9",
+   "metadata": {},
+   "source": [
+    "c) Les opérations `-`, `/` sur deux chaines de caractères"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4184cd65",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "531763ec",
+   "metadata": {},
+   "source": [
+    "d) La fonction `len(...)` sur une chaine de caractère"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "399fd2a6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# à compléter"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38eb7527",
+   "metadata": {},
+   "source": [
+    "Description"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5112faa0",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "52d39bc2",
+   "metadata": {},
+   "source": [
+    "2. Compléter le programme suivante pour qu'il affiche le texte contenu dans la variable `texte` entouré de 4 symboles `*` avant et apprès."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "886e910c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "texte = \"Menu du repas de midi\"\n",
+    "# à compléter"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "41cd3376",
+   "metadata": {},
+   "source": [
+    "3. Compléter le programme suivant pour qu'il affiche le texte contenu dans la variable `texte` souligné avec le symbole `-` sur toute la longueure"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d3d0808e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "texte = \"Titre de mon roman\"\n",
+    "# à compléter\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "000c2e59",
+   "metadata": {},
+   "source": [
+    "4. Comment fait-on pour ajouter un saut de ligne dans une chaine de caractère?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66a9c657",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c8a1df85",
+   "metadata": {},
+   "source": [
+    "## Les fonctions\n",
+    "\n",
+    "Quand on écrit des programmes, nous avons souvent besoin de réutiliser des morceaux de code à plusieurs endroits. Afin d'éviter un copié collé, il plus interessant d'utiliser une `fonction` qui contiendra les instructions répétées.\n",
+    "\n",
+    "Le code sera alors factorisé (une partie servira à plusieurs endroit), plus clair à lire et plus simple à utiliser.\n",
+    "\n",
+    "Ci-dessous, vous trouverez une fonction qui entoure un texte avec 4 symboles avant et après."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "81a9ed1d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def entoure4(texte, symbole):\n",
+    "    avant = symbole * 4\n",
+    "    apres = symbole * 4\n",
+    "    return avant + texte + apres"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "23ede0b2",
+   "metadata": {},
+   "source": [
+    "Quand vous avez validé ce code, a priori rien ne s'est passé. Mais en réalité, vous avez ajouter une nouvelle \"capacité\" au language python sous le mot clé `entoure4`.\n",
+    "\n",
+    "Vous pouvez alors l'utiliser de la manière suivante"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "5c256888",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "~~~~Bonjour~~~~\n",
+      "--------blablabla--------\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(entoure4(\"Bonjour\", \"~\"))\n",
+    "print(entoure4(\"blablabla\", \"--\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "37acfeea",
+   "metadata": {},
+   "source": [
+    "1. Utiliser la fonction `entoure4` pour entourer le texte \"NSI\" avec des \"<3\"."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bd3c1dbc",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7e45aeb1",
+   "metadata": {},
+   "source": [
+    "2. Décrire les mots clés et la structure pour définir une fonction."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "722f901b",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "23bb82d0",
+   "metadata": {},
+   "source": [
+    "3. Ecrire puis tester une fonction qui va ajouter 5 symboles avant un texte."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "79b19741",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c2826872",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f8a6cfb0",
+   "metadata": {},
+   "source": [
+    "4. Ecrire puis tester une fonction qui va souligné un texte avec le sympbole `-`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ede2aa48",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b39a53e1",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "993d2f51",
+   "metadata": {},
+   "source": [
+    "5. Ecrire une fonction qui prend en argument un texte et un symbole puis qui retourne le texte souligné du symbole"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e75a3098",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d72c78a0",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "758505a5",
+   "metadata": {},
+   "source": [
+    "6. Ecrire une fonction qui prend en argument un texte, un symbole et une nombre puis qui retourne le texte entouré du nombre de symboles avant et après.\n",
+    "\n",
+    "Exemple:\n",
+    "\n",
+    "Arguments: texte=\"NSI\", symbole=\"#\", nombre=5\n",
+    "\n",
+    "Retourne: \"#####NSI#####\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "81927856",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3f1ec576",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dad10cc7",
+   "metadata": {},
+   "source": [
+    "7. Ecrire une fonction qui prend en argument un texte et un symbole puis qui retrourne le texte **encadré** par le symbole."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "714ca4b6",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2fb4c208",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d21d1fc5",
+   "metadata": {},
+   "source": [
+    "8. Ecrire une fonction qui prend en argument un texte et un symbole puis qui retourne le texte avec une pyramide croissante de symboles avant et une décroissante après.\n",
+    "\n",
+    "Exemple:\n",
+    "\n",
+    "arguments: texte=\"NSI\" symbole=\"#\"\n",
+    "\n",
+    "valeur retournée:\n",
+    "   \n",
+    "    #\n",
+    "    ##\n",
+    "    ###\n",
+    "    NSI\n",
+    "    ###\n",
+    "    ##\n",
+    "    #"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "732ce915",
+   "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

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

@@ -0,0 +1,358 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ebadd52b",
+   "metadata": {},
+   "source": [
+    "# Fonctions et documentations\n",
+    "\n",
+    "Dans le TP précédent, vous avez écrit des fonctions qui marchent. C'est un bon début, mais il est important pour soit et pour les autres de documenter et de spécifier son code pour le rendre plus explicite et éviter les bugs.\n",
+    "\n",
+    "Voici une fonction correctement documentée"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "4f5978cc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def entoure(texte:str, symbole:str, nombre:int)->str:\n",
+    "    \"\"\" Entoure le texte avec le symbole (nombre de fois)\n",
+    "    \n",
+    "    :param texte(str): texte à entourer\n",
+    "    :param symbole(str): symbole pour entourer\n",
+    "    :param nombre(int): nombre de répétition du symbole (avant et après)\n",
+    "    :return (str): le texte entouré\n",
+    "    \n",
+    "    :example:\n",
+    "    >>> entoure(\"NSI\", \"~\", 3)\n",
+    "    ~~~NSI~~~\n",
+    "    >>> entoure(\"Plop\", \"-\", 1)\n",
+    "    -Plop-\n",
+    "    \"\"\"\n",
+    "    symbole_repete = nombre*symbole\n",
+    "    return symbole_repete + texte + symbole_repete"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1ce40493",
+   "metadata": {},
+   "source": [
+    "1. Repérer les nouveaux élèments et la syntaxe associée qui permettent de documenter la fonction."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3a50223f",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3115b6ce",
+   "metadata": {},
+   "source": [
+    "## Carré\n",
+    "\n",
+    "Programmer une fonction qui prend en argument un nombre et qui retourne son carré.\n",
+    "\n",
+    "Fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "363b80f7",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "988eec99",
+   "metadata": {},
+   "source": [
+    "Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7331c1eb",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53bd8be0",
+   "metadata": {},
+   "source": [
+    "## Max à 2\n",
+    "\n",
+    "Programmer une fonction qui prend en argument deux nombres puis qui renvoie le plus grand.\n",
+    "\n",
+    "Fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77541d90",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ffece552",
+   "metadata": {},
+   "source": [
+    "Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "79f0e4d4",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5171aad2",
+   "metadata": {},
+   "source": [
+    "## Max à 3\n",
+    "\n",
+    "Programmer une fonction qui prend en argument 3 nombres et qui renvoie le plus grand.\n",
+    "\n",
+    "Fonctions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2812d74e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "981bd705",
+   "metadata": {},
+   "source": [
+    "Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f124ff62",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6d76f12c",
+   "metadata": {},
+   "source": [
+    "Essayer de programmer cette fonction en réutilisant la fonction max à 2 de la question précédente"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1dd297be",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd596431",
+   "metadata": {},
+   "source": [
+    "## Question réponse\n",
+    "\n",
+    "Programmer une fonction qui prend en argument une question et une réponse qui pose la question à l'utilisateur puis qui renvoie True si la réponse est juste ou False sinon.\n",
+    "\n",
+    "Fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1446ed52",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "101dfbfb",
+   "metadata": {},
+   "source": [
+    "Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9190ce3b",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "104c2a6c",
+   "metadata": {},
+   "source": [
+    "## Mention\n",
+    "\n",
+    "Dans cette partie, vous devez programmer une fonction qui prend en argument une note (entre 0 et 20) puis qui retourne la mention associée suivant la règle:\n",
+    "\n",
+    "- R si la note < 10\n",
+    "- A si 10 <= note < 12\n",
+    "- AB si 12 <= note < 14\n",
+    "- B si 14 <= note < 16\n",
+    "- TB si 16 <= note\n",
+    "\n",
+    "Fonction\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6757393e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c09ad023",
+   "metadata": {},
+   "source": [
+    "Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e064533a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ef55d84d",
+   "metadata": {},
+   "source": [
+    "### Questionnaire\n",
+    "\n",
+    "Ecrire un programme qui pose 10 questions, fait gagner 2points par question juste puis qui donne une mention à l'utilisateur. La mention devra être encadré avec le symbole \"o\"\n",
+    "\n",
+    "Il n'est pas attendu que vous mettiez tout ce programme dans une seul fonction. Par contre, vous devrez réutiliser le plus possible de fonctions déjà programmée précédement et celle ci-dessous"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "12e09ca3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def encadre(texte:str, symbole:str)->str:\n",
+    "    \"\"\"  Encadre le texte avec le symbole\n",
+    "    \n",
+    "    :param texte(str): texte à encadrer\n",
+    "    :param symbole(str): symbole pour encadrer\n",
+    "    :return(str): le texte encadré\n",
+    "    \n",
+    "    \n",
+    "    :example:\n",
+    "    >>> encadre(\"A\", \"~\")\n",
+    "    ~~~\n",
+    "    ~A~\n",
+    "    ~~~\n",
+    "    >>> encadre(\"ZE\", \"-\")\n",
+    "    ----\n",
+    "    -ZE-\n",
+    "    ----\n",
+    "    \n",
+    "    \"\"\"\n",
+    "    texte_encadre = entoure(texte, symbole, 1)\n",
+    "    longueur_boite = len(texte_encadre)\n",
+    "    haut_bas = longueur_boite * symbole\n",
+    "    return haut_bas + \"\\n\" + texte_encadre + \"\\n\" + haut_bas"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "7afc6232",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "----\n",
+      "-ZE-\n",
+      "----\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(encadre(\"ZE\", \"-\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4976f3cd",
+   "metadata": {},
+   "source": [
+    "Votre programme"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "25466c67",
+   "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

1NSI/04_Fonctions_specifications_et_tests/index.rst

@@ -0,0 +1,48 @@
+Fonctions spécifications et tests
+#################################
+
+:date: 2022-12-02
+:modified: 2022-12-02
+:authors: Benjamin Bertrand
+:tags: Programmation
+:category: 1NSI
+:summary: Découverte des fonctions en python, de la spécification et des tests.
+
+
+Éléments du programme
+=====================
+
+.. list-table:: Fonction, spécification et tests
+    :header-rows: 1
+
+    * - Contenus
+      - Capacités attendues
+      - Commentaires
+
+    * - Spécification
+      - Prototyper une fonction. Décrire les préconditions sur les arguments. Décrire des postconditions sur les résultats.
+      - Des assertions peuvent être utilisées pour garantir des préconditions ou des postconditions.
+
+    * - Mise au point de programmes
+      - Utiliser des jeux de tests.
+      - L’importance de la qualité et du nombre des tests est mise en évidence. Le succès d’un jeu de tests ne garantit pas la correction d’un programme.
+
+Progression
+===========
+
+Étape 1: Création de fonctions décoratives
+------------------------------------------
+
+Activité capytale pour apprendre a programmer des fonctions en décorant du texte.
+
+- `Fonctions décoratives (notebook) <./1E fonctions de décorations.ipynb>`_
+
+Bilan: structure d'une fonction, arguments, valeur retournée, spécifications
+
+
+Étape 2: Coder des fonctions et les documenter
+----------------------------------------------
+
+Fonctions plus classiques à programmer et à documenter.
+
+- `Fonctions et documentation (notebook) <./2E fonction documentations.ipynb>`_

1NSI/index.rst

@@ -2,7 +2,7 @@ Spécialité première NSI
 #######################
 
 :date: 2022-07-25
-:modified: 2022-09-29
+:modified: 2022-12-02
 :authors: Bertrand Benjamin
 :category: 1NSI
 :tags: Progression
@@ -29,9 +29,11 @@ Période 1
 
 .. big_button::
    :title: Système d'exploitation
+   :link: ./03_Systeme_dexploitation/
 
 .. big_button::
    :title: Représentation d'entiers en binaire
+   :link: ./04_Fonctions_specifications_et_tests/
 
 Période 2
 ---------