4_Elements_programmation_diapo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## <p style=\"text-align: center;\">NSI - Éléments de programmation</p>\n",
    "## <p style=\"text-align: center;\">Séquences, variables et alternatives</p>\n",
    "## <p style=\"text-align: center;\">Lycée Beaussier - F. Lagrave</p>\n",
    "\n",
    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/Fklag/NSI_iere/master?filepath=4_Elements_programmation_diapo.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Supports de cours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div id=\"top\"><a href=\"http://lycee.lagrave.free.fr/nsi/programmation/0_Elements_programmation_diapo.pdf\" target=\"_blank\">Revoir les premiers éléments incontournables de la programmation</a>  \n",
    "    \n",
    "• Notion d'<b>expression</b> et de <b>type</b>  associé\n",
    "\n",
    "• Principe d’<b>évaluation</b>  des expressions en une <b>valeur</b> \n",
    "\n",
    "• Définition de <b>fonctions</b>  \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def perimetre(largeur,longueur ):\n",
    "    \"\"\"Number ∗ Number −> Number\n",
    "    hypothese : ( largeur >= 0) and ( longueur >=0)\n",
    "    hypothese : largeur <= longueur\n",
    "    retourne le perimetre du rectangle defini par sa largeur et sa longueur\"\"\"\n",
    "    return 2*(largeur + longueur)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#Jeu de tests\n",
    "assert perimetre(2,5)==14\n",
    "assert perimetre(0,0)==0\n",
    "assert perimetre(0,2)==4\n",
    "assert perimetre(2,3)==10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Instructions\n",
    "Autre composant d'un programme de nature différent : l'**instruction**.\n",
    "\n",
    "<div style=\"background-color:#f0f0fa;\">\n",
    "À la différence d'une expression, une instruction :\n",
    "    \n",
    "• ne possède pas de valeur (et donc pas de type).\n",
    "\n",
    "• modifie l'état de la machine\n",
    "\n",
    "Mais comme une expression, une instruction possède un principe d'interprétation qui précise le déroulement de son exécution.\n",
    "</div>\n",
    "\n",
    "**Une expression s'évalue, une instruction s'exécute**\n",
    "\n",
    "• Les instructions contiennent souvent une ou des expressions.\n",
    "\n",
    "• Évaluer une application, c'est interpréter le corps de la fonction."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Exemple : On a déjà vu quelques instructions   \n",
    "\n",
    "* $\\texttt{return} <\\text{expression}>$ :\n",
    "  1. **Évaluation** de l'expression $<\\text{expression}>$ en une **valeur de retour** ;  \n",
    "  2. **Sortie** de la fonction (à l'endroit du $\\texttt{return}$ ) avec la valeur de retour.\n",
    "\n",
    "* $\\texttt{assert} <\\text{expression}>$ :  \n",
    "  1. Évaluation de l'expression $<\\text{expression}>$ en une **valeur de test** ( $\\texttt{bool}$ ) ;  \n",
    "  2. Si la valeur de test vaut $\\texttt{False}$ , arrêt du programme et affichage d'une erreur.  \n",
    "     Sinon, rien ne se passe.\n",
    "\n",
    "Dans la suite nous allons passer en revue quelques unes des instructions fondamentales :\n",
    "1.  les **séquences d’instructions** ;  \n",
    "2.  la notion de **variables** et d'**affectation** variables  ;  \n",
    "3.  les **alternatives**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "On a parfois besoin de décomposer une solution (un algorithme) en une suite d'opérations élémentaires.  \n",
    "En $\\texttt{python}$, il suffit d'écrire à la suite les différentes instructions ligne après ligne :\n",
    "\n",
    "$\\texttt{instruction} \\,1$  \n",
    "$\\texttt{instruction} \\,2$  \n",
    "$\\ldots$  \n",
    "$\\texttt{instruction} \\,n$  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Principe d'interprétation de la séquence  \n",
    "Une suite d'instruction est interprétée par la succession suivante :\n",
    "\n",
    "• on exécute l'instruction $\\texttt{instruction} \\,1$  \n",
    "\n",
    "• on exécute l'instruction $\\texttt{instruction} \\,2$  \n",
    "• $\\ldots$  \n",
    "• on termine par l'exécution de l'instruction $\\texttt{instruction} \\,n$  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Mémoire d'un ordinateur\n",
    "    \n",
    "Deux **composants primordiaux** d'un ordinateur :\n",
    "* le **processeur** qui effectue des calculs ;  \n",
    "* la **mémoire** qui permet de stocker de l'information de façon temporaire (mémoire centrale) ou permanente (disques)  \n",
    "\n",
    "On a déjà manipulé la mémoire $\\texttt{def perimetre(largeur, longueur):}$  \n",
    "Dans cette déclaration, les paramètres :\n",
    "* désignent des cases mémoires ;  \n",
    "* contiennent une valeur  \n",
    "\n",
    "Question principale : **quelle valeur est contenue dans une case mémoire ?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Valeur d'une case mémoire  \n",
    "**Valeur d'un paramètre**\n",
    "La valeur d'une case mémoire désignée par un paramètre :  \n",
    "* est celle de l'expression utilisée au moment de l'appel de fonction.\n",
    "* ne change pas au cours de l'exécution de la fonction  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perimetre(2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Pendant l'interprétation de cet appel :\n",
    "* la case mémoire $\\texttt{largeur}$ contient la valeur $2$ ;  \n",
    "* la case mémoire $\\texttt{longueur}$ contient la valeur $3$.  \n",
    "\n",
    "**Insuffisant** :\n",
    "1. besoin de mémoriser des calculs intermédiaires\n",
    "2. besoin de modifier une case mémoire"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Aire d'un triangle  \n",
    "Donner une définition de la fonction $\\texttt{aire_triangle}$ qui calcule l'aire d'un triangle à partir de la longueur des ses trois côtés.  \n",
    "\n",
    "**Rappel des quatre étapes pour définir une fonction :**\n",
    "1. Établir la spécification de la fonction  \n",
    "2. Inventer les opérations à effectuer pour répondre au problème  \n",
    "3. Traduire la solution dans le langage choisi  \n",
    "4. Tester la correction de la fonction  \n",
    "\n",
    "**Rappel sur la spécification :**  \n",
    "**en-tête :** précise son *nom* et le nom de ses *paramètres*  \n",
    "**signature :** donne le type de la *valeur des paramètres* et de la *valeur de\n",
    "retour*  \n",
    "**hypothèses :** *limitent les valeurs* que peuvent prendre les paramètres  \n",
    "**description :** *décrit* le problème résolu par la fonction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def aire_triangle(a,b,c):\n",
    "    \"\"\"Number ∗ Number ∗ Number −> float\n",
    "    hypothese : (a>0) and (b>0) and (c>0)\n",
    "    hypothese : les cotes a, b et c definissent bien un triangle .\n",
    "    retourne l'aire du triangle dont les cotes sont de longueur a, b, et c.\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Remarques :  \n",
    "• $\\texttt{float}$ en type de la valeur de retour → lié à la division flottante   \n",
    "• une hypothèse non décrite par des booléens → **on évitera !**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Aire d'un triangle : implémentation  \n",
    "*Trouver l'algorithme, c’est le plus dur !*  \n",
    "**Formule de Héron** Soit $ABC$ un triangle quelconque ayant pour longueurs de ses côtés $a$, $b$ et $c$.  \n",
    "Soit $p$ la valeur du demi-périmètre de $ABC$ donné par : $p = \\frac{a+b+c}{2}$.  \n",
    "L'aire $\\texttt{Aire}$ du triangle $ABC$ est donnée par la formule de Héron suivante :\n",
    "$\\texttt{Aire}=\\sqrt{p(p - a)(p - b)(p - c)}$\n",
    "\n",
    "*Reste à décrire ce calcul en $\\texttt{python}$.* Une première solution possible :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import math   # necessaire pour pouvoir utiliser la racine carree\n",
    "def aire_triangle(a,b,c):\n",
    "    \"\"\"Number ∗ Number ∗ Number −> float\n",
    "    hypothese : (a>0) and (b>0) and (c>0)\n",
    "    hypothese : les cotes a, b et c definissent bien un triangle .\n",
    "    retourne l'aire du triangle dont les cotes sont de longueur a, b, et c.\"\"\"\n",
    "    return math.sqrt(((a + b +  c)/2)  \n",
    "                     * (((a + b + c)/2) - a)\n",
    "                     * (((a + b + c)/2) - b)\n",
    "                     * (((a + b + c)/2) - c) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Pas satisfaisant car :  \n",
    "• elle est illisible  \n",
    "• on effectue le même calcul plusieurs fois !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Problème de l'implémentation précédente : pas de calcul du demi-périmètre.  \n",
    "Pour mimer la formule de Héron, il faudrait :  \n",
    "1. calculer la valeur du demi-périmètre  \n",
    "2. mémoriser cette valeur  \n",
    "3. utiliser cette valeur (sans la re-calculer) $4$ fois  \n",
    "→ besoin d'une variable intermédiaire pour mémoriser ce calcul."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import math   # necessaire pour pouvoir utiliser la racine carree\n",
    "def aire_triangle(a,b,c):\n",
    "    \"\"\"Number ∗ Number ∗ Number −> float\n",
    "    hypothese : (a>0) and (b>0) and (c>0)\n",
    "    hypothese : les cotes a, b et c definissent bien un triangle .\n",
    "    retourne l'aire du triangle dont les cotes sont de longueur a, b, et c.\"\"\"\n",
    "    # p : float\n",
    "    p = (a + b + c)/2  # valeur du demi−perimetre\n",
    "    return math.sqrt(p*(p - a) * (p - b) * (p - c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "• beaucoup plus lisible  \n",
    "• correspond exactement à l'algorithme élaboré  \n",
    "• pas de calcul inutile  \n",
    "\n",
    "**Attention**, la variable $p$ :\n",
    "• n'existe qu'à partir de la ligne $p = (a + b + c)/2$ .  \n",
    "• n'existe plus à la sortie de la fonction (après le $\\texttt{return}$ )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Portée de la variable**  \n",
    "Une variable n'existe que lors de l'exécution d’une fonction. On dit alors qu'elle est **locale** à la fonction.\n",
    "\n",
    "Dans le script précédent $p$ est une variable locale à la fonction $\\texttt{aire_triangle}$, c'est-à-dire qu’elle ne peut être utilisée que dans le corps de cette fonction, et\n",
    "nulle part ailleurs. Elle ne joue un rôle que local car elle ne nous est utile que pour mémoriser\n",
    "un résultat intermédiaire (la valeur du demi-périmètre) et l'utiliser ensuite plusieurs fois dans\n",
    "l'expression du calcul de l'aire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#Jeu de tests\n",
    "assert aire_triangle(3,4,5) == 6.0\n",
    "assert aire_triangle(13,14,15) == 84.0\n",
    "assert aire_triangle(1,1,1) == math.sqrt(3/16)\n",
    "assert aire_triangle(2,3,5) == 0.0 # c'est un triangle plat ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Remarque :  \n",
    "• Penser aux cas extrêmes ( $\\texttt{aire_triangle(2,3,5)}$ )  \n",
    "• Ne mettre que des valeurs que l'on est capable de calculer *à la main*.  \n",
    "Surtout pas de : $\\texttt{assert aire_triangle(1,1,1) == 0.4330127018922193}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Remarque :** suite à notre petite réflexion concernant les tests, nous pouvons d’affiner un peu notre  spécification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def aire_triangle(a,b,c):\n",
    "    \"\"\"Number ∗ Number ∗ Number −> float\n",
    "    hypothese : (a>0) and (b>0) and (c>0)\n",
    "    hypothese : (a <= b + c) and (b <= a + c) and (c <= a + b)\n",
    "                -- les côtés a, b et c définissent bien un triangle.\n",
    "    retourne l'aire du triangle dont les cotes sont de longueur a, b, et c.\"\"\"\n",
    "    # p : float\n",
    "    p = (a + b + c)/2  # valeur du demi−perimetre\n",
    "    return math.sqrt(p*(p - a) * (p - b) * (p - c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Variables  \n",
    "**Caractéristiques des variables**  \n",
    "Une variable désigne une case mémoire dans laquelle on peut mémoriser une valeur.\n",
    "Une variable possède :  \n",
    "un **nom** : il permet faire référence à la case mémoire  \n",
    "une **valeur** : elle correspond au contenu de la case mémoire  \n",
    "un **type** : c’est celui de la valeur que contient la variable  \n",
    "\n",
    "On associe traditionnellement $4$ opérations sur les variables :  \n",
    "• la **déclaration** de variable  \n",
    "• l'**initialisation** de variable  \n",
    "• l'utilisation de la valeur d'une variable dans une expression  \n",
    "• l'**affectation** d'une valeur à une variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Déclaration de variables  \n",
    "La syntaxe pour déclarer une variable est la suivante : $\\texttt{#< var > : < type >}$  \n",
    "• $\\texttt{<var>}$ est le nom de la variable  \n",
    "• $\\texttt{<type>}$ est le type du contenu  \n",
    "Par exemple :  $\\texttt{# p : float}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Affectation de variables  \n",
    "On peut donner une valeur à une variable. On parle alors d'**affectation**.  \n",
    "La syntaxe en $\\texttt{Python}$ est : $\\texttt{< var > = < expression >}$.  \n",
    "\n",
    "**Principe d'interprétation de l'affectation**\n",
    "L'instruction :$\\texttt{< var > = < expression >}$ s'exécute de la manière suivante :  \n",
    "1. on évalue l'expression $\\texttt{< expression >}$  \n",
    "2. la valeur obtenue est mémorisée dans le contenu de la variable $\\texttt{< var >}$  \n",
    "\n",
    "Par exemple l'instruction $p = (2+3+4)/2$ :\n",
    "1. évalue l'expression $(2+3+4)/2$ en la valeur $4.5$  \n",
    "2. puis affecte la valeur $4.5$ à la variable $p$ .  \n",
    "\n",
    "**Attention** à ne pas confondre $\\,=$ et $\\,==$ ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Initialisation et définition\n",
    "Il y a deux types différents d'affectation :  \n",
    "• la première affectation qui correspond à l'initialisation de la variable.  \n",
    "• une ré-affectation qui consiste à mettre à jour le contenu de la variable.  \n",
    "\n",
    "**Définition de variables**\n",
    "La définition d’une variable consiste en une déclaration puis une initialisation\n",
    "immédiate de la variable voulue.\n",
    "$\\texttt{# <var> : <type>}$  \n",
    "$\\texttt{<var> = <expression>}$  \n",
    "Par exemple :  \n",
    "$\\texttt{# p : float}$  \n",
    "$\\texttt{p = (a + b + c)/2}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Convention sur les définitions  \n",
    "**Définition de variables dans les fonctions**  \n",
    "Les variables sont définies au début du corps des fonctions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def ma_fonction(param1,param2, ...):\n",
    "    \"\"\" partie 1 : specification \n",
    "    ...\n",
    "    \"\"\" \n",
    "    # partie 2 : declaration et initialisation des variables\n",
    "    # v1 : type1\n",
    "    v1 = expr1\n",
    "    # v2 : type2\n",
    "    v2 = expr2\n",
    "    ...\n",
    "    # vn : typeN\n",
    "    vn = exprN\n",
    "    # partie 3 : corps de la fonction\n",
    "    instruction 1\n",
    "    instruction 2\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Occurrence d'une variable  \n",
    "**Occurrence d'une variable**  Une fois définie, on peut utiliser la valeur d'une variable dans une expression.\n",
    "On parle alors d'**occurrence** de la variable.\n",
    "\n",
    "Par exemple, l'expression $\\texttt{math.sqrt(p*(p - a) * (p - b) * (p - c))}$ contient $4$ occurrences de la variable $p$ .  \n",
    "\n",
    "**Principe d'évaluation*** d'une occurrence d'une variable :  \n",
    "L'occurrence de la variable est remplacée par la valeur qu’elle contient.\n",
    "\n",
    "Important :  \n",
    "• le contenu d'une variable est une valeur  \n",
    "• la valeur d'une variable n'est calculée qu'une seule fois !\n",
    "### Exemple :  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def f():\n",
    "    \"\"\" −> int\n",
    "    renvoie un entier ...\n",
    "    \"\"\"\n",
    "    # n : int\n",
    "    n = 0\n",
    "    # m : int\n",
    "    m = 58\n",
    "    n = m - 16\n",
    "    m = m + 1\n",
    "    return n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Que donne l'appel à $\\texttt{f()}$ ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Suivi de la valeur des variables  \n",
    "Pour connaı̂tre les valeurs de $n$ et $m$ à la fin, on peut suivre leurs valeurs avec une table des variables.  \n",
    "\n",
    "| variable | $n$ | $m$ |\n",
    "|:--------:|:---:|:---:|\n",
    "| valeur   | $0$ | $58$|\n",
    "|  $\\,$ | $42$| $59$|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Convention de nommage  \n",
    "Le nom de la variable (comme de la fonction) renseigne sur son rôle.  \n",
    "→ choisir des noms explicites !  \n",
    "**Nommage des variables**  \n",
    "Par convention :  \n",
    "• mots en minuscules  \n",
    "• mots séparés par des  $_$  \n",
    "• peut avoir des chiffres à la fin (mais sans $_$)    \n",
    "\n",
    "Exemples :  \n",
    "* $\\texttt{compteur}$ \n",
    "* $\\texttt{plus_grand_nombre}$  \n",
    "  $\\texttt{plusgrandnombre}$ est incorrect  \n",
    "* $\\texttt{min1}$  \n",
    "  $\\texttt{min_1}$ est incorrect"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Alternative : principe  \n",
    "On a souvent besoin de faire des choix dans les calculs. Exemple : valeur absolue $\\left|x\\right| =\\left\\{\\begin{array}{ll}x &  \\text{ si } x \\geqslant 0 \\\\-x& \\text{ sinon }\\\\ \\end{array}\\right.$\n",
    "\n",
    "Comment écrire une fonction calculant la valeur absolue ?  \n",
    "Spécification :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def valeur_absolue (x):\n",
    "    \"\"\"Number − > Number\n",
    "    retourne la valeur absolue de x.\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Syntaxe de l’alternative  \n",
    "$\\texttt{if <condition> :}$   \n",
    "$\\phantom{.} \\qquad \\texttt{<consequent>}$  \n",
    "$\\texttt{else :}$    \n",
    "$\\phantom{.} \\qquad \\texttt{<alternant>}$  \n",
    "\n",
    "• $\\texttt{<condition>}$ : expression booléenne (dont la valeur est $\\texttt{True}$ ou $\\texttt{False}$ )  \n",
    "• $\\texttt{<consequent>}$ : suite d'instructions  \n",
    "• $\\texttt{<alternant>}$ : suite d'instructions  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Principe d'interprétation de l'alternative  \n",
    "• On évalue la $\\texttt{<condition>}$  \n",
    "• Si la valeur obtenue est $\\texttt{True}$ :  \n",
    "$\\phantom{.} \\qquad$ • Évaluation uniquement du consequent  \n",
    "• Si la valeur obtenue est $\\texttt{False}$ :  \n",
    "$\\phantom{.} \\qquad$ • Évaluation uniquement de l'alternant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def valeur_absolue (x):\n",
    "    \"\"\"Number −> Number\n",
    "    retourne la valeur absolue de x.\"\"\"\n",
    "    # abs_x : Number\n",
    "    abs_x = 0     # stockage de la valeur absolue , le choix de 0 pour l'initialisation est ici arbitraire\n",
    "    if x >= 0:\n",
    "        abs_x = x # consequent\n",
    "    else :\n",
    "        abs_x = -x # alternant\n",
    "    return abs_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert valeur_absolue(3) == 3\n",
    "assert valeur_absolue(-3) == 3\n",
    "assert valeur_absolue(1.5 - 2.5) == valeur_absolue(2.5 - 1.5)\n",
    "assert valeur_absolue(0) == 0\n",
    "assert valeur_absolue(-0) == 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Sortie anticipée de fonction  \n",
    "Autre implémentation possible :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def valeur_absolue2(x):\n",
    "    \"\"\"Number −> Number\n",
    "    retourne la valeur absolue de x.\"\"\"\n",
    "    if x >= 0:\n",
    "        return x # consequent\n",
    "    else :\n",
    "        return -x # alternant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert valeur_absolue2(3) == 3\n",
    "assert valeur_absolue2(-3) == 3\n",
    "assert valeur_absolue2(1.5 - 2.5) == valeur_absolue2(2.5 - 1.5)\n",
    "assert valeur_absolue2(0) == 0\n",
    "assert valeur_absolue2(-0) == 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Alternatives multiples  \n",
    "**Problème** Définir la fonction $\\texttt{nb_solutions}$ qui, étant donné trois nombres $a$ , $b$ et $c$ , renvoie\n",
    "le nombre de solutions de l'équation du second degré $a.x^2 + b.x + c = 0$.\n",
    "\n",
    "• On sait qu'il faut calculer le discriminant et discuter:  \n",
    "$\\phantom{.} \\qquad$ • si le discriminant est strictement positif il y a $2$ solutions,  \n",
    "$\\phantom{.} \\qquad$ • si le discriminant est nul il y a $1$ solution,  \n",
    "$\\phantom{.} \\qquad$ • si le discriminant est négatif il n'y a aucune solution.  \n",
    "\n",
    "• On a un choix en trois cas.  \n",
    "• On pourrait imbriquer deux alternatives."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Alternatives multiples  \n",
    "**Problème** Définir la fonction $\\texttt{nb_solutions}$ qui, étant donné trois nombres $a$ , $b$ et $c$ , renvoie\n",
    "le nombre de solutions de l'équation du second degré $a.x^2 + b.x + c = 0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def nb_solutions(a,b,c):\n",
    "    \"\"\"Number ^ 3 −> int\n",
    "    renvoie le nombre de solutions de l'equation du second degre ax^2 + bx + c\"\"\"\n",
    "    # delta : Number\n",
    "    delta = b**2 - 4 * a * c\n",
    "    if delta < 0:\n",
    "        return 0\n",
    "    else :\n",
    "        if delta == 0:\n",
    "            return 1\n",
    "        else :\n",
    "            return 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Alternatives multiples  \n",
    "Permettent le choix entre plus de deux valeurs\n",
    "$\\texttt{if <condition1> :}$   \n",
    "$\\phantom{.} \\qquad \\texttt{<consequent1>}$   \n",
    "$\\texttt{elif <condition2> :}$  \n",
    "$\\phantom{.} \\qquad \\texttt{<consequent2>}$  \n",
    "$\\texttt{elif \\ldots :}$  \n",
    "$\\phantom{.} \\qquad \\texttt{\\ldots}$  \n",
    "$\\texttt{else :}$  \n",
    "$\\phantom{.} \\qquad \\texttt{<alternant>}$\n",
    "\n",
    "**Principe d'interprétation de l'alternative multiple**\n",
    "• On évalue $\\texttt{<condition1>}$  \n",
    "• Si la valeur est $\\texttt{True}$ , on évalue uniquement $\\texttt{<consequent1>}$  \n",
    "• Sinon, on évalue la $\\texttt{<condition2>}$  \n",
    "• Si la valeur est $\\texttt{True}$ on évalue uniquement $\\texttt{<consequent2>}$  \n",
    "• $\\ldots$  \n",
    "• Si aucune des conditions n'est vraie, on évalue $\\texttt{<alternant>}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Alternatives multiples  \n",
    "**Problème** Définir la fonction $\\texttt{nb_solutions}$ qui, étant donné trois nombres $a$ , $b$ et $c$ , renvoie\n",
    "le nombre de solutions de l'équation du second degré $a.x^2 + b.x + c = 0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def nb_solutions(a,b,c):\n",
    "    \"\"\"Number ^ 3 −> int\n",
    "    renvoie le nombre de solutions de l'equation du second degre ax^2 + bx + c\"\"\"\n",
    "    # delta : Number\n",
    "    delta = b**2 - 4 * a * c\n",
    "    if delta < 0:\n",
    "        return 0\n",
    "    elif delta == 0:\n",
    "        return 1\n",
    "    else :\n",
    "        return 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Expressions booléennes  \n",
    "La condition d'une alternative est une **expression booléenne** (valeur $\\texttt{True}$ ou $\\texttt{False}$ )  \n",
    "Les <a href=\"http://lycee.lagrave.free.fr/nsi/numerisation/2_Decouvrir_algebre_Boole_diapo.pdf\" target=\"_blank\">expressions booléennes</a> sont souvent composées :  \n",
    "• de comparaisons $==, !=, <, <=, >, >=$  \n",
    "• d'expressions composées avec des opérateurs logiques $\\texttt{and}, \\texttt{or}, \\texttt{not}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Comparaisons  \n",
    "• $==$ test d'égalité  \n",
    "Attention à ne pas confondre avec l'affectation $=$  \n",
    "• $!=$ test d'inégalité    \n",
    "• $<$ inférieur strict  \n",
    "• $<=$ inférieur ou égal  \n",
    "• $>$ supérieur strict  \n",
    "• $>=$ supérieur ou égal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Négation  \n",
    "$\\texttt{not <expression>}$  \n",
    "\n",
    "Principe d'évaluation du $\\texttt{not}$ :  \n",
    "• On évalue expression  \n",
    "• Si la valeur est $\\texttt{True}$ on renvoie $\\texttt{False}$  \n",
    "• Si la valeur est $\\texttt{False}$ on renvoie $\\texttt{True}$  \n",
    "\n",
    "**Remarque** : le $\\texttt{not}$ est prioritaire sur les comparateurs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, True, True, False)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 == 3, not(2 == 3), 9 > 1, not (9 > 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Conjonction (et logique)  \n",
    "$\\texttt{<expression1>} \\quad \\texttt{and} \\quad \\texttt{<expression2>}$\n",
    "\n",
    "Sémantique du $\\texttt{and}$ :\n",
    "$(\\texttt{expr1} \\quad \\texttt{and} \\quad \\texttt{expr2)}$ vaut $\\texttt{True}$ quand les deux expressions valent $\\texttt{True}$ ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, True)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(3 >= 9) and (9 <= 27), (3 <= 9) and (9 <= 27)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Principe d'évaluation du $\\texttt{and}$** :  \n",
    "• On évalue $\\texttt{<expression1>}$  \n",
    "• Si la valeur est $\\texttt{False}$ , la valeur finale est $\\texttt{False}$  \n",
    "• Sinon, on évalue $\\texttt{<expression2>}$ et on renvoie cette valeur\n",
    "    \n",
    "On parle de **mode d'évaluation paresseux**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Illustration  \n",
    "**Problème** Définir la fonction $\\texttt{est_divisible}$ qui, étant donné deux entiers naturels renvoie le $\\texttt{True}$ ssi $a$ est divisible par $b$ ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def est_divisible(a, b):\n",
    "    \"\"\"int ∗ int −> bool\n",
    "    Hypothese : (a >= 0) and (b >= 0)\n",
    "    retourne True si a est divisible par b, False sinon.\"\"\"\n",
    "    return (b != 0) and (a % b == 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "$a \\% b$ n'est évalué que si $b != 0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert est_divisible(5, 2) == False\n",
    "assert est_divisible(8, 2) == True\n",
    "assert est_divisible(8, 0) == False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Disjonction (ou logique)  \n",
    "$\\texttt{<expression1>} \\quad \\texttt{or} \\quad \\texttt{<expression2>}$\n",
    "\n",
    "Sémantique du $\\texttt{or}$ :\n",
    "$(\\texttt{expr1} \\quad \\texttt{or} \\quad \\texttt{expr2)}$ vaut $\\texttt{True}$ si l'une des deux expressions (au moins) vaut $\\texttt{True}$ . "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, True, True)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(3 >= 9) or (9 >= 27), (3 >= 9) or (9 <= 27), (3 <= 9) or (9 <= 27)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Principe d'évaluation du $\\texttt{or}$** :  \n",
    "• On évalue $\\texttt{<expression1>}$  \n",
    "• Si la valeur est $\\texttt{True}$ , la valeur finale est $\\texttt{True}$  \n",
    "• Sinon, on évalue $\\texttt{<expression2>}$ et on renvoie cette valeur\n",
    "    \n",
    "On parle de **mode d'évaluation paresseux**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conclusion  \n",
    "Ce qu'il faut savoir faire à l'issue de cette partie :  \n",
    "* Utiliser les constructions élémentaires :\n",
    "  * Séquences, affectation conditionnelles\n",
    "  * Appels de fonction."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Diaporama",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "rise": {
   "autolaunch": true,
   "enable_chalkboard": true,
   "scroll": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}