découverte_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "administrative-collar",
   "metadata": {
    "tags": []
   },
   "source": [
    "<h1 align=\"center\" style=\"font-size:40px\"> A la découverte de </h1>\n",
    "<img src=\"./images/python.jpeg\", style=\"width:5cm;display: block;margin-left: auto;margin-right: auto;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "rational-federation",
   "metadata": {},
   "source": [
    "Python est un langage de programmation, c'est à dire un ensemble de mot clefs et de syntaxes permettant de donner des instructions à une machine via un _interpréteur python_\n",
    "Dans un IDE classique comme [Edupython](https://edupython.tuxfamily.org/) ou [pyzo](https://pyzo.org/)\n",
    "Dans ce _Notebook Jupyter_ nous allons pouvoir écrire des suites d'instructions plus complexes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "immediate-speaking",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "    <b>CONSIGNES GENERALES </b> \n",
    "     <ul>\n",
    "        <li> Lire les consignes dans les cellules bleues. </li>\n",
    "        <li> Les aides (cellules vertes) sont à utiliser qu'après avoir vraiment essayé de compléter le code. </li>\n",
    "        <li> Sauf cas particulier, les indications données dans les exercices sont suffisantes pour répondre aux questions mais en cas de diffiultés - ou pour aller plus loin - on trouvera une fiche plus détaillée sur ce langage <a href=\"https://nuage-creteil.beta.education.fr/s/7kqcytKETt2aieb?dir=undefined&path=%2FNotices%2FPython&openfile=20467\">ici</a> et l'ensemble des vidéos qui suivent <a href=\"https://colibris.link/PC_peerTube\">là</a>. </li>\n",
    "         <li> Pour se familiariser avec Python, rien de mieux que la pratique: ne pas hésiter à modifier les exemples pour bien comprendre la syntaxe utilisée</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "induced-cheat",
   "metadata": {},
   "source": [
    "<a id=\"sommaire\"></a>__SOMMAIRE__ \n",
    "\n",
    "<a href=\"#partie1\"><b>1. variables</b></a>\n",
    "\n",
    "<a href=\"#partie2\"><b>2.instructions d'entrée et de sortie</b></a>\n",
    "\n",
    "<a href=\"#partie3\"><b>3. structures conditionnelles</b></a>\n",
    "\n",
    "<a href=\"#partie31\">3.1. if / else </a>\n",
    "\n",
    "<a href=\"#partie32\">3.2. elif </a>\n",
    "\n",
    "<a href=\"#partie4\"><b>4. boucles bornées</b></a>\n",
    "\n",
    "<a href=\"#partie5\"><b>5. boucles non bornées</b></a>\n",
    "\n",
    "<a href=\"#partie6\"><b>6. listes</b></a>\n",
    "\n",
    "<a href=\"#partie61\">6.1. éléments d'une liste </a>\n",
    "\n",
    "<a href=\"#partie62\">6.2. utiliser et modifier une liste</a>\n",
    "\n",
    "<a href=\"#partie63\">6.3. boucles et listes</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "embedded-emperor",
   "metadata": {
    "tags": []
   },
   "source": [
    "<a id=\"partie1\"></a><h2 style=\"background-color:#ffb84d;\"> Partie 1 : variables </h2> "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "specialized-southeast",
   "metadata": {},
   "source": [
    "<img src=\"./images/sepia.png\" style=\"width:60px;display:block\"> <b>Ressource vidéo : </b> (exécuter la cellule si nécessaire)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "large-arbitration",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import IFrame\n",
    "IFrame(width=600, height=400, src=\"https://tube-creteil.beta.education.fr/videos/watch/c0284ab3-4a0a-4ca1-ae5c-a2db2a0871b4\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "soviet-trademark",
   "metadata": {},
   "source": [
    "-----\n",
    "### Le concept de variable en informatique\n",
    "Les variables sont des emplacement mémoires permettant de stocker des informations. Selon le type d'informations (texte, nombre, tableau...) le stockage sera fait de manière différente et il convient donc de définir des __types de variables__ pour lesquelles on pourra faire des opérations différentes.\n",
    "Une variable peut être vu comme une boite avec un nom qui peut contenir différentes valeurs.\n",
    "\n",
    "<img src=\"./images/schema_variable.png\" style=\"margin-left:auto;margin-right:auto;width:20%\">\n",
    "\n",
    "<p style=\"text-align:center;\"> <i> Source : Le livre scolaire </i> </p>\n",
    "\n",
    "<p> Lorsqu'on écrit <code>a = 8</code>, il faut comprendre : <span style=\"color:blue\"> on affecte la valeur 8 à la variable <code>a</code> </span> </p>\n",
    "\n",
    "<p><b> ATTENTION :</b> le signe \"=\" n'a donc pas la même signification qu'en mathématique! </p>\n",
    "\n",
    "### Les types de variables à connaitre\n",
    "\n",
    "|Type(en francais)|Type (en anglais)|Rédaction|Exemple|\n",
    "|-----------------|-----------------|---------|-------|\n",
    "|     Entiers     |Integer          |Entiers relatifs|3|\n",
    "|Nombre décimaux (virgule flotante)| Decimal number (floatting point)| Avec un point|3.0|\n",
    "|Chaines de caractère|String|Entre guillemet| \"Bonjour\" ou 'Bonjour'|\n",
    "|Listes           | List            | Entre crochets| \\[1, 2, \"a\", \"b\"\\]|\n",
    "\n",
    "### L'instruction `print()`\n",
    "\n",
    "`print(\"ce que je veux afficher\")` permet d'afficher sous la cellule un message ou la valeur d'une variable. On y reviendra dans la [partie 2](#partie2)\n",
    "\n",
    "_Exemple:_\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "mounted-episode",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Un message à afficher\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "double-lightning",
   "metadata": {},
   "source": [
    "-----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "advance-trinity",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Exercice 1 : les variables </b>\n",
    "    <ol>\n",
    "        <li> Exécuter le programme ci-dessous (ctrl + entrée) </li>\n",
    "        <li> Expliquer en quoi le terme de \"variable\" est approprié pour a. </li>\n",
    "        <li> Par analogie, ajouter deux nouvelles instructions permettant d'obtenir <i>a=42</i> </li>\n",
    "    </ol>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "complimentary-saudi",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 39\n",
    "print(a)\n",
    "a = a + 2\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sized-michael",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Exercice 2 : le type de variable </b>\n",
    "    <ol>\n",
    "        <li> Exécuter le programme ci-dessous (ctrl + entrée) </li>\n",
    "        <li> indiquer le type de la variable a et sa notation en python </li>\n",
    "        <li> En modifiant la première ligne changer le type de la variable a et exécuter la cellule. Indiquer la notation des nombres décimaux, des chaines de caractères et des listes en python </li>\n",
    "    </ol>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "strategic-tolerance",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "__NOTE :__ l'instruction `type(a)` renvoie le type de la variable a _en notation python_. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "material-silence",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 42\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "quiet-sleep",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Exercice 3 : La concaténation </b>\n",
    "    <ol>\n",
    "        <li> Exécuter le programme ci-dessous (ctrl + entrée) </li>\n",
    "        <li> Expliquer en quoi la concaténation diffère de l'addition </li>\n",
    "    </ol>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "boring-quality",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "chaine_1 = \"tu dois \"\n",
    "chaine_2 = \"maitriser \"\n",
    "chaine_3 = \"la force \"\n",
    "\n",
    "chaine_4 = chaine_1 + chaine_2 + chaine_3\n",
    "print(chaine_4)\n",
    "chaine_5 = chaine_3 + chaine_1 + chaine_2\n",
    "print(chaine_5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "strategic-swedish",
   "metadata": {
    "tags": []
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "veterinary-lotus",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Exercice 4 : changer le type de variable </b>\n",
    "    <ol>\n",
    "        <li> Exécuter la cellule ci-dessous </li>\n",
    "        <li> Que fait l'instruction de la ligne 5? </li>\n",
    "        <li> En déduire ce que fait l'instruction de la ligne 4 </li>\n",
    "        <li> Même question pour la ligne 7 </li>\n",
    "    </ol>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fifteen-overview",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"42\"\n",
    "print(type(a))\n",
    "\n",
    "a = int(a)\n",
    "print(type(a))\n",
    "\n",
    "a = float(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "driving-edition",
   "metadata": {
    "tags": []
   },
   "source": [
    "<p style=\"font-size:20px;text-align:center\"><a href=\"#sommaire\"> &#x23EB; retour au sommaire  &#x23EB;</a></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "average-dining",
   "metadata": {
    "tags": []
   },
   "source": [
    "# <a id=\"partie2\"></a><h2 style=\"background-color:#ffb84d;\"> Partie 2 : instructions d'entrée et de sortie </h2> "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "heavy-drinking",
   "metadata": {},
   "source": [
    "---\n",
    "### Instructions d'entrée\n",
    "\n",
    "* En python, lorsque l'instruction `input()` s'exécute, le programme demande à l'utilisateur de saisir une chaine de caractère.\n",
    "* Si on veut utiliser la valeur entrée par l'utilisateur comme un entier ou un flottant, il faut le convertir à l'aide des instructions vues dans l'exercices précédent.\n",
    "\n",
    "### Instruction de sortie\n",
    "\n",
    "L'instruction `print()` permet d'afficher la valeur d'une variable ou une chaine de caractère.\n",
    "\n",
    "Pour bien comprendre la différence entre les deux possibilités, exécuter la cellule suivante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "alone-netscape",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 42\n",
    "# affichage de la valeur de a\n",
    "print(a)\n",
    "\n",
    "# affichage du caractère \"a\"\n",
    "print(\"a\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "flexible-sweden",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Exercice 5 : print() et input()  </b>\n",
    "    <ol>\n",
    "        <li> Exécuter la cellule ci dessous et observer le résultat. </li>\n",
    "        <li> Ajouter l'instruction nécessaire pour déterminer le type de la variable <code>mon_age</code> et exécuter la cellule pour le déterminer. </li>\n",
    "        <li> Pour déterminer l'âge de Roberto, qui a 8 ans de plus, on tame l'instruction suivante:<br> <code>age_de_roberto = mon_age + 8</code></li>\n",
    "        <li> Expliquer pourquoi cette instruction renvoie une erreur</li>\n",
    "        <li> Ajouter une ligne après la ligne 1 pour corriger ce problème.</li>\n",
    "        <li> Ajouter une dernière ligne pour afficher l'âge de Roberto.\n",
    "    </ol>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "existing-allowance",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "mon_age = input('Quelle âge as-tu?')\n",
    "print(\"Tu as\", mon_age, \"ans\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "minute-administrator",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "    <details>\n",
    "        <summary> <b> Aides </b> </summary>\n",
    "        <ul>\n",
    "            <li> <b> Question 4 :</b> On ne peut pas ajouter des oranges et des choux</li>\n",
    "            <li> <b> Question 5 :</b> Il faudrait changer le type d'une variable </li>\n",
    "        </ul>\n",
    "    </details>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sustained-alcohol",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Exercice 6 : on fait le bilan </b>\n",
    "    <p> Ecrire un script qui demande à un utilisateur son année de naissance et affiche l'âge qu'il aura cette année</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "distinguished-engine",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "    <details>\n",
    "        <summary> <b> Aides </b> </summary>\n",
    "        <ul>\n",
    "            <li> Pour demander l'année de naissance, on utilise un input et on stocke la valeur entrée dans une variable </li>\n",
    "            <li> On peut calculer le nombre d'année qui sont passée depuis </li>\n",
    "            <li> Attention au type des variables</li>\n",
    "            <li> Il ne reste plus qu'à afficher l'âge qu'aura l'utilisateur cette année </li>\n",
    "        </ul>\n",
    "    </details>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "terminal-serbia",
   "metadata": {
    "tags": []
   },
   "source": [
    "<p style=\"font-size:20px;text-align:center\"><a href=\"#sommaire\"> &#x23EB; retour au sommaire  &#x23EB;</a></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "comprehensive-belize",
   "metadata": {},
   "source": [
    "<a id=\"partie3\"></a><h2 style=\"background-color:#ffb84d;\" > Partie 3 : structures conditionnelles</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "developmental-inside",
   "metadata": {},
   "source": [
    "<a id=\"partie31\"></a><h3 style=\"background-color:#fff5e6\"> <b>3.1. if/else</b> </h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "happy-roman",
   "metadata": {},
   "source": [
    "<img src=\"./images/sepia.png\" style=\"width:60px;display:block\"> <b>Ressource vidéo : </b> (exécuter la cellule si nécessaire)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "piano-seeking",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import IFrame\n",
    "IFrame(width=600, height=400, src=\"https://tube-creteil.beta.education.fr/videos/watch/1d3625db-5d10-4c25-ab61-9857e80978c3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "voluntary-decrease",
   "metadata": {},
   "source": [
    "---\n",
    "Une structure conditionnelle permet d'exécuter des instructions différentes <b><span style=\"color:orange\">selon qu'une condition est vérifiée ou non.</span></b>\n",
    "### Syntaxe\n",
    "\n",
    "``` \n",
    "if condition :\n",
    "    instruction A\n",
    "    instruction B\n",
    "Suite du code\n",
    "```\n",
    "\n",
    "\n",
    "### Explications\n",
    "\n",
    "Si la condition est vraie, alors le programme fera successivement *instruction A* et *instruction B*, puis *la suite du code*\n",
    "sinon, il fera direcement la *suite du code*\n",
    "\n",
    "<p style=\"text-align:center\"><img src=\"./images/if.jpg\" width=45%> <br>\n",
    "</p>\n",
    "\n",
    "\n",
    "### L'indentation\n",
    "\n",
    "* __L'indentation__ est le décalage du début de la ligne. Il correspond en python à 4 espaces ou une __tabulation__ (touche \"tab\").\n",
    "* Contrairement à d'autre langages, <b><span style=\"color:red\">en python elle est très importante.</span></b>\n",
    "    \n",
    "_Exemple_ : exécuter la cellule suivante et observer l'erreur et constater que le message d'erreur est explicite."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "hispanic-operations",
   "metadata": {},
   "outputs": [],
   "source": [
    "if True:\n",
    "print(\"C'est bon?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "corresponding-tampa",
   "metadata": {},
   "source": [
    "_Avec l'indentation:_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "growing-hampton",
   "metadata": {},
   "outputs": [],
   "source": [
    "if True:\n",
    "    print(\"C'est bon!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "checked-shape",
   "metadata": {},
   "source": [
    "---\n",
    "### Syntaxe avec if / else\n",
    "``` \n",
    "if condition :\n",
    "    instruction A\n",
    "    instruction B\n",
    "else:\n",
    "    instruction C\n",
    "Suite du code\n",
    "```\n",
    "\n",
    "### Explications"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "increasing-illinois",
   "metadata": {},
   "source": [
    "<img src=\"./images/sepia.png\" style=\"width:60px;display:block\"> <b>Ressource vidéo : </b> (exécuter la cellule si nécessaire)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "endangered-period",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import IFrame\n",
    "IFrame(width=600, height=400, src=\"https://tube-creteil.beta.education.fr/videos/watch/160c0c43-c5cb-4948-8fd2-f96cfa987080\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "prompt-compiler",
   "metadata": {},
   "source": [
    "Si la condition est vraie, alors le programme fera successivement *instruction A* et *instruction B* puis la *suite du code*.\n",
    "sinon, il fera l'*instruction C*, puis *la suite du code*\n",
    "\n",
    "<p style=\"text-align:center\"><img src=\"./images/if_else.jpg\" width=50%> <br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ordinary-activation",
   "metadata": {},
   "source": [
    "### Opérateurs logiques\n",
    "\n",
    "|Opérateur                                             | Signification     |\n",
    "|------------------------------------------------------|------------------|\n",
    "|    <                                                 | Inférieur        |\n",
    "|    <=                                                | Inférieur ou égal|\n",
    "|    >                                                 | Supérieur        |\n",
    "|    >=                                                | Supérieur ou égal|\n",
    "| <span style=\"color:blue;font-family:bold\">==</span>  | <span style=\"color:blue;font-family:bold\">Égal</span>         |\n",
    "|    !=                                                | Différent        |\n",
    "\n",
    "_Exemple_ : Exécuter la cellule suivante et faire quelques test en utilisant les différents opérateurs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "utility-geology",
   "metadata": {},
   "outputs": [],
   "source": [
    "8 <= 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "round-halifax",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "remarkable-discrimination",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Exercice 7 : majeur ou mineur? </b>\n",
    "    <p> Compléter la cellule ci-dessous pour qu'après que l'utilisateur ait entré son âge, le programme affiche s'il est mineur ou majeur.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "willing-coverage",
   "metadata": {},
   "outputs": [],
   "source": [
    "mon_age = float(input(\"saisir ton âge :\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "laden-scoop",
   "metadata": {},
   "source": [
    "--- \n",
    "<a id=\"partie32\"></a><h3 style=\"background-color:#fff5e6\"><b>3.2. elif</b></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tested-rental",
   "metadata": {},
   "source": [
    "<img src=\"./images/sepia.png\" style=\"width:60px;display:block\"> <b>Ressource vidéo : </b> (exécuter la cellule si nécessaire)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "discrete-gather",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import IFrame\n",
    "IFrame(width=600, height=400, src=\"https://tube-creteil.beta.education.fr/videos/watch/1a107442-af05-4f1f-8ac8-51009ef3766d\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cutting-contributor",
   "metadata": {},
   "source": [
    "### Synthaxe\n",
    "\n",
    "``` \n",
    "if condition 1:\n",
    "    instruction A\n",
    "    instruction B\n",
    "elif condition 2:\n",
    "    instruction C\n",
    "else:\n",
    "    instruction D\n",
    "suite du code \n",
    "```\n",
    "\n",
    "\n",
    "### Explication\n",
    "\n",
    "<b><span style=\"color:orange\">elif</span> </b>est la contraction de <span style=\"color:orange\"><b>\"else if\" </b></span> (sinon si): Si la condition 1 n'est pas vérifiée, le programme test la condition 2. Si elle est vérifiée le code exécute l'instruction C. Si aucunes des conditions n'est vérifiée, le programme exécute l'instruction D.\n",
    "\n",
    "<p style=\"text-align:center\"><img src=\"./images/if_elif_else.jpg\" width=50%></p>\n",
    "\n",
    "### Remarque\n",
    "\n",
    "Il peut y avoir autant de elif que l'on veut, <span style=\"color:red\">mais un seul else, toujours en dernière position.</span>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "banned-transmission",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Exercice 8 : amélioration avec elif </b>\n",
    "    <p> En utilisant un elif, proposer une amélioration du code de l'exercice 7 permettant d'afficher : \"cet âge n'est pas possible\" lorsqu'on entre une valeur négative</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "exact-album",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <p><b> Exercice 9 : le juste prix </b></p>\n",
    "    <img src=\"./images/juste_prix.jpeg\" alt=\"Le juste prix\" style=\"width:20%;margin-right:auto;margin-left:auto;display:block\">\n",
    "    <p> Le juste prix est un (vieux) jeux télévisé francais dans lequel les candidat·e·s doivent déterminer le prix d'un objet le plus rapidement possible.</br>\n",
    "    La seule indication à leur disposition est le présentateur qui leur dit: \"c'est plus!\" ou \"c'est moins!\" chaque proposition.</p>\n",
    "    <p> On souhaite écrire un code simulant une version simplifiée de ce jeux: le joueur doit deviner un chiffre, choisi aléatoirement entre 1 et 6 (inclus). Il ne dispose que de deux tentatives.</p>\n",
    "    <p> Compléter la cellule ci-dessous et vérifier le bon fonctionnement du programme.</p>\n",
    "    <p> <b> INFOS : </b> \n",
    "    <ul> \n",
    "        <li> L'instruction <code> randint(a,b)</code> renvoie aléatoirement un nombre enrier compris entre a et b inclus.</li>\n",
    "        <li> En python, le signe <code> # </code> indique un <b> commmentaire </b>, c'est à dire un morceau de code qui sera ignorer lors de l'exécution du programme: il est en général à destination de l'utilisateur du code.</li>\n",
    "   </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "removable-biography",
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint\n",
    "\"\"\"\n",
    "Le juste prix sur un echantillon de 1 à 6\n",
    "\"\"\"\n",
    "lejuste_Prix = randint(..., ...)                         ## A COMPLÉTER ##\n",
    "\n",
    "votre_prix = ...(input(\"Saisir votre prix inférieur 6\")) ## A COMPLÉTER ##\n",
    "\n",
    "if ... > 6:                                             ## A COMPLÉTER ##\n",
    "    print(\"Vous êtes éliminé!Il fallait saisir un nombre <=6.\")\n",
    "\n",
    "elif lejuste_Prix ... votre_prix:                        ## A COMPLÉTER ##\n",
    "    print(\"Bravo vous avez le juste prix au 1er essai\")\n",
    "\n",
    "... (votre_prix < lejuste_Prix) :\n",
    "    print(\"C'est plus!\")\n",
    "    votre_prix=int(input(\"Saisir un autre prix!\"))\n",
    "\n",
    "    if lejuste_Prix == votre_prix:\n",
    "        print(\"Bravo vous avez le juste prix qui est: \",lejuste_Prix,\" au 2 ème essai\")\n",
    "    else:\n",
    "        print(\"Perdu. il ne vous reste plus d'essai.\")\n",
    "\n",
    "\n",
    "...:                                                       ## A COMPLÉTER ##\n",
    "    print(\"C'est moins!\")\n",
    "    votre_prix=int(input(\"Saisir un autre prix!\"))\n",
    "    if lejuste_Prix==votre_prix:\n",
    "        print(\"Bravo vous avez le juste prix qui est: \",lejuste_Prix,\" au 2 ème essai\")\n",
    "    else:\n",
    "        print(\"Perdu. il ne vous reste plus d'essai.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "finished-kruger",
   "metadata": {
    "tags": []
   },
   "source": [
    "<p style=\"font-size:20px;text-align:center\"><a href=\"#sommaire\"> &#x23EB; retour au sommaire  &#x23EB;</a></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "working-israeli",
   "metadata": {
    "tags": []
   },
   "source": [
    "<a id=\"partie4\" ></a> <h2 style=\"background-color:#ffb84d;\"> Partie 4 : boucles bornées</h2> "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tender-champion",
   "metadata": {},
   "source": [
    "<img src=\"./images/sepia.png\" style=\"width:60px;display:block\"> <b>Ressource vidéo : </b> (exécuter la cellule si nécessaire)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aboriginal-healing",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import IFrame\n",
    "IFrame(width=600, height=400, src=\"https://tube-creteil.beta.education.fr/videos/watch/2e8cfdb1-f8b6-46c7-a981-9f1ab48bdf5c\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "material-trace",
   "metadata": {},
   "source": [
    "---\n",
    "Une boucle est une partie de code permettant de répéter plusieurs fois une ou plusieurs instructions.\n",
    "Dans une boucle bornée, on définit le nombre de répétitions.\n",
    "\n",
    "### Syntaxe\n",
    "\n",
    "<code>\n",
    "for i in range(a,b):\n",
    "    instruction 1\n",
    "    instruction 2\n",
    "    ...\n",
    "suite du code\n",
    "</code>\n",
    "\n",
    "### Explications\n",
    "\n",
    "Les instructions qui sont \"dans le bloc\", c'est-à-dire dont la ligne commence par une indentation, seront exécutées successivement pour des valeurs de i allant <b><span style=\"color:orange\">de a à b exlu (c-a-d de a à b-1).</span></b>\n",
    "\n",
    "<img src=\"./images/for.jpg\" style=\"margin-left:auto;margin-right:auto;width:55%\">\n",
    "\n",
    "_Exemple : exécuter la ligne suivante et faire des tests avec plusieurs valeurs différentes._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ranking-allowance",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "signed-trinidad",
   "metadata": {},
   "source": [
    "### Bon à savoir\n",
    "\n",
    "Lorsqu'on écrit `for i in range(n)`, cela équivaut à `for i in range(0,n)`: le bloc d'instruction(s) sera donc exécuté pour i allant de 0 à n-1 (c'est à dire n fois).\n",
    "\n",
    "_Exemple : pour s'en convaincre, on peut modifier la cellule précédente et tester plusieurs valeurs de n_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ready-range",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Exercice 10 : \"la table de 7\" </b>\n",
    "    <p> Écrire un script utilisant une boucle affichant la table de multiplication de 7 de 1 à 10.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "stopped-prospect",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Exercice 11 : \"La punition\" </b>\n",
    "    <p> Il fut un temps pas si lointain où les professeurs donnaients comme punition d'écrire 50 ou 100 fois la même phrase aux élèves désobéissants: Si les élèves de l'époque avaient connu les boucles bornées, ils auraient gagné beaucoup de temps! </p>\n",
    "    <ol>\n",
    "        <li> Proposer un script permettant d'afficher 50 fois la ligne \"La SNT est ma matière préférée !\" </li>\n",
    "        <li> Le professeur veut maintenant vérifier que la ligne a bien été écrite 50 fois: modifier le code précédent pour afficher le numéro de chaque ligne</li>\n",
    "    </ol>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "advisory-compromise",
   "metadata": {
    "tags": []
   },
   "source": [
    "<p style=\"font-size:20px;text-align:center\"><a href=\"#sommaire\"> &#x23EB; retour au sommaire  &#x23EB;</a></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "paperback-newark",
   "metadata": {
    "tags": []
   },
   "source": [
    "<a id=\"partie5\"></a><h2 style=\"background-color:#ffb84d;\"> Partie 5 : boucles non bornées</h2> "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "viral-strain",
   "metadata": {},
   "source": [
    "---\n",
    "Parfois, on ne connait pas _a priori_ le nombre derépétitions souaitées: dans ce cas on utilise une <span style=\"color:orange\"><b> une boucle non bornées</b></span>\n",
    "\n",
    "### Syntaxe\n",
    "    while condition:\n",
    "        instruction 1\n",
    "        instruction 2\n",
    "        ...\n",
    "    suite du code\n",
    "\n",
    "### Explications\n",
    "* Le programme exécute successivement les instructions 1 et 2 <b><span style=\"color:orange\">tant que la condition est vérifiée.</span></b>\n",
    "* Lorsque la condidtion n'est plus vérifiée, le programme exécute la suite du code (à partir de la première ligne non indentée\n",
    "\n",
    "<img src=\"./images/while.jpg\" style=\"margin-left:auto;margin-right:auto;width:50%\">\n",
    "<p style=\"text-align:center\"></p>\n",
    "\n",
    "_Exemple: dans le cas suivant, on ne peut pas connaitre à l'avance le nombre de fois qu'un utilisateur ne donnera pas la bonne réponse_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cultural-playlist",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "reponse = \"non\" # création de la variable reponse et attribution d'une valeur\n",
    "\n",
    "while reponse != \"oui\": #tant que la réponse n'est pas \"oui\",\n",
    "    reponse = input(\"Acceptez-vous les conditions d'utilisation?\") # On repose la question\n",
    "print(\"Vous pouvez passer à la suite :)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "talented-tribe",
   "metadata": {},
   "source": [
    "--- "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "primary-provincial",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Exercice 12 : encore la table de 7   </b>\n",
    "    <p> Écrire un script utilisant une boucle pour afficher la table de multiplication de 7 jusqu'à ce que le résultat soit supérieur à 200.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "subsequent-stack",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Exercice 13 : le risque avec les boucles non bornées  </b>\n",
    "    <ol>\n",
    "        <li> Expliquer pourquoi il ne faut surtout pas exécuter le code ci-dessous: </li>\n",
    "<pre><code>i = 1\n",
    "while i<10:\n",
    "    print(\"Mauvaise idée!\")</code></pre>\n",
    "        <li> Pour éviter ce problème on peut ajouter une ligne qui augmente la valeur de i à chaque boucle. Compléter la cellule suivante pour que le message s'affiche 10 fois</li>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "executed-fabric",
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i <... : # À COMPLÉTER\n",
    "    print(i,\"C'est mieux comme ça!\")\n",
    "    i=...      # À COMPLÉTER"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "functioning-reservoir",
   "metadata": {
    "tags": []
   },
   "source": [
    "<p style=\"font-size:20px;text-align:center\"><a href=\"#sommaire\"> &#x23EB; retour au sommaire  &#x23EB;</a></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "coordinated-electricity",
   "metadata": {
    "tags": []
   },
   "source": [
    "<a id=\"partie6\"></a> <h2 style=\"background-color:#ffb84d;\"> Partie 6 : listes</h2> "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "latter-pleasure",
   "metadata": {},
   "source": [
    "<a id=\"partie61\"></a><h3 style=\"background-color:#fff5e6\"><b>6.1. Éléments d'une liste </b></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "nutritional-picking",
   "metadata": {},
   "source": [
    "* Une liste est une suite ordonnée d'éléments (str, int, floats)\n",
    "* À chaque éléments est affecté un indique qui indique sa position dans la liste.\n",
    "* __ATTENTION !__ Le premier élément de la liste correspond à l'indice 0 \n",
    "\n",
    "_Exemple: une liste de prénoms:_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cubic-senegal",
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_prenom = [\"Harry\", \"Ron\", \"Hermione\", \"Albus\", \"Luna\", \"Neville\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "directed-georgia",
   "metadata": {},
   "source": [
    "_Correspond à :_\n",
    "\n",
    "|**Valeurs**|\"Harry\"|\"Ron\"|\"Hermione\"|\"Albus\"|\"Luna\"|\"Neville\"|\n",
    "|-----------|:-----:|:---:|:--------:|:-----:|:----:|:-------:|\n",
    "|**Indices**|   0   |  1  |   2      |   3   |   4  |  5      |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "humanitarian-system",
   "metadata": {},
   "source": [
    "* **Appeler l'élément d'une liste**:  `ma_liste[i]` où i est l'indice d'un élément de la liste.\n",
    "\n",
    "_Exemple: exécuter la cellule ci-dessous et la modifier pour faire quelques tests_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "introductory-updating",
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_prenom[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "limiting-sharing",
   "metadata": {},
   "source": [
    "* **Sélectionner plusieurs éléments** d'une liste : `ma_liste[i:j]`\n",
    "\n",
    "On sélectionne les éléments de l'indice i à l'indice  <span style=\"color:orange\"> j exclu</span>\n",
    "\n",
    "_Exemple : on peut utiliser cette syntaxe pour sélectrionner \"Ron\", \"Hermionne\" et \"Albus\"._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "specific-poetry",
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_prenom[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hazardous-hundred",
   "metadata": {},
   "source": [
    "* **Sélectionner les derniers éléments d'une liste** : On peut utiliser des indices négatifs. `ma_liste[-1]` correspond au dernier élément,  `ma_liste[-2]` à l'avant dernier etc...\n",
    "\n",
    "_Exemple : écrire l'instruction permettant de sélectionner [l'antépénultième](https://fr.wikipedia.org/wiki/P%C3%A9nulti%C3%A8me) élément de liste_prenom._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "primary-computer",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "electronic-report",
   "metadata": {},
   "source": [
    "<a id=\"partie62\"></a> <h3 style=\"background-color:#fff5e6\"><b>6.2. Utiliser et modifier une liste </b></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sapphire-office",
   "metadata": {},
   "source": [
    "* **Ajouter un élément à la fin de la liste** : `ma_liste.append(...)` \n",
    "\n",
    "_Exemple : compléter la ligne ci-dessous pour ajouter \"Drago\" à liste_prenom et appeler à nouveau la liste pour vérifier cet ajout_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "tough-forest",
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_prenom..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "extreme-anthony",
   "metadata": {},
   "source": [
    "* **Supprimer un élément** : `del(ma_liste[i])` \n",
    "\n",
    "_Exemple: supprimer \"Albus\" de liste_prenom et appeler la liste pour vérifier la suppression._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "musical-might",
   "metadata": {},
   "outputs": [],
   "source": [
    "del(liste_prenom[6])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "scheduled-consistency",
   "metadata": {},
   "source": [
    "* **Supprimer des éléments - 2e métode:** `ma_liste = ma_liste[i, j]`\n",
    "\n",
    "Avec cet syntaxe on sélectionne les éléments dont les indices sont compris entre i et j exlcu et on l'affecte à la variable `ma_liste`.\n",
    "\n",
    "_Exemple: pour bien comprendre, exécuter la cellule suivante et la modifier pour faire quelques tests_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "worth-rugby",
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_prenom = liste_prenom[1:5]\n",
    "liste_prenom"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ready-water",
   "metadata": {
    "tags": []
   },
   "source": [
    "<a id=\"partie63\"></a> <h3 style=\"background-color:#fff5e6\"><b>6.3.Utiliser une boucle avec une liste </b></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sought-brighton",
   "metadata": {},
   "source": [
    "* Les boucles for vont être particulièrement utiles pour faire une même opération sur tous les éléments d'une liste.\n",
    "* Il faut cependant connaitre le nombre d'éléments de la liste, ce qui n'est pas forcément évident lorsqu'elle en contient beaucoup. Pour cela il existe une instruction bien pratique : `len(ma_liste)` qui renvoie le nombre d'élément de ma_liste.\n",
    "\n",
    "_Exemple:_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "documentary-depth",
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_prenom = [\"Harry\", \"Ron\", \"Hermione\", \"Albus\", \"Luna\", \"Neville\"]\n",
    "len(liste_prenom)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "certain-stationery",
   "metadata": {},
   "source": [
    "* Maintentant qu'on connait le nombre d'éléments de cette liste, on peut choisir de tous les afficher:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "frequent-howard",
   "metadata": {},
   "outputs": [],
   "source": [
    "N = len(liste_prenom) # On stocke cette valeur dans une variable N\n",
    "\n",
    "for i in range(N):\n",
    "    print(liste_prenom[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "spare-petite",
   "metadata": {},
   "source": [
    "__Remarque:__ On rappelle que l'indice du premier élément vaut 0, donc N vaut 6 mais l'indice du dernier élément vaut 5. Et cela tombe bien puisque i prend toutes les valeurs de 0 à .... N-1! pratique, non?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bigger-consolidation",
   "metadata": {
    "tags": []
   },
   "source": [
    "<p style=\"font-size:20px;text-align:center\"><a href=\"#sommaire\"> &#x23EB; retour au sommaire  &#x23EB;</a></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "statutory-eugene",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b> Exercice 14 : liste de course </b>\n",
    "    <p> On considère la liste de course dans la cellule ci-dessous. </p>\n",
    "    <ol>\n",
    "        <li> Ecrire les instructions permettant de connaitre: </li>\n",
    "        <ol>\n",
    "            <li> Le nombre de produits différents à acheter </li>\n",
    "            <li> l'élément de cette liste correspondant à l'indice 7 </li>\n",
    "        </ol>\n",
    "        <li> finalement, il reste des brosses à dents : modifier la liste en conséquence</li>\n",
    "        <li>  écrire les instructions permettant d'Afficher les 5  derniers artices à acheter</li>\n",
    "      \n",
    "        \n",
    "        \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "moral-sport",
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_course = [\"oeufs\", \"lait\", \"carotte\", \"laitue\", \"poulet\", \"poisson pannés\", \"beurre\", \"yaourt\", \"jus d'orange\", \"mouchoirs\", \"savon\", \"dentifrice\", \"brosse à dents\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cross-brazilian",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "administrative-arrow",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}