5_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;\">Répétitions et boucles $\\texttt{while}$</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=5_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\">Revoir les notions de <a href=\"http://lycee.lagrave.free.fr/nsi/programmation/4_Elements_programmation_diapo.pdf\" target=\"_blank\">séquences, variables et alternatives</a> \n",
    "    \n",
    "• Les <b>principes d'évaluation</b> pour les expressions arithmétiques  \n",
    "• La définition de fonctions simples  \n",
    "• La différence entre <b>expression</b> et <b>instruction</b>  \n",
    "• L'application de fonction et son évaluation  (principe d'évaluation des paramètres et d'interprétation du corps)    \n",
    "• L'utilisation de variables (<b>déclaration et initialisation, ré-affactation</b>) pour mémoriser et utiliser les calculs intermédiaires  \n",
    "• Les <b>séquences</b> d'instructions  \n",
    "• Les <b>alternatives</b> simples et multiples et les expressions booléennes\n",
    "\n",
    "• Il manque une instruction très utile:  l'instruction d'affichage : $\\texttt{print}$  \n",
    "• La notion de boucles pour répéter des calculs  \n",
    "• La notion de structures de données\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Remarques et précisions  \n",
    "\n",
    "$\\texttt{if}$ cond1 :  \n",
    "$\\phantom{.} \\quad \\texttt{return True}$    \n",
    "$\\texttt{else :}$  \n",
    "$\\phantom{.} \\quad \\texttt{return False}$  \n",
    "    \n",
    "**Écrire:**  $\\texttt{return}$ cond1\n",
    "\n",
    "-----\n",
    "$\\texttt{if}$ cond1 :  \n",
    "$\\phantom{.} \\quad \\texttt{return False}$    \n",
    "$\\texttt{else :}$  \n",
    "$\\phantom{.} \\quad \\texttt{return True}$  \n",
    "    \n",
    "**Écrire:**  $\\texttt{return not}$ cond1\n",
    "\n",
    "-----\n",
    "$\\texttt{if}$ cond1 :  \n",
    "$\\phantom{.} \\quad s = \\texttt{True}$    \n",
    "$\\texttt{else :}$  \n",
    "$\\phantom{.} \\quad s = \\texttt{False}$  \n",
    "    \n",
    "**Écrire:**  $\\texttt{s =}$ cond1\n",
    "\n",
    "-----\n",
    "• Précisions sur le test d'égalité, **Non-associativité** : $\\qquad 3 == (4 == \\texttt{False} )\\,$ vs. $\\,(3 == 4) == \\texttt{False}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Instruction d'affichage  \n",
    "L'instruction print est l'instruction d'affichage de $\\texttt{Python}$. Par exemple $\\texttt{print}(2)$\n",
    "affiche la valeur $2$ à l'écran."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Principe d'interprétation du $\\texttt{print}$   \n",
    "L'instruction : $\\texttt{print} ( \\texttt{< expression 1 > , < expression 2 >} , \\ldots , \\texttt{< expression n > })$  a pour effet d'afficher les résultats des calculs des $\\texttt{< expression 1 >, < expression 2 >}, \\ldots, \\texttt{< expression n >}$ séparées par des espaces.\n",
    "\n",
    "Un passage à la ligne est ajouté en fin d'affichage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bonjour\n",
      "La valeur de pi est environ : 3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print('Bonjour')\n",
    "print('La valeur de pi est environ :', math.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bonjour\n"
     ]
    }
   ],
   "source": [
    "def bonjour():\n",
    "    \"\"\" −> NoneType\n",
    "    affiche bonjour et retourne None.\n",
    "    \"\"\"\n",
    "    print('Bonjour')\n",
    "\n",
    "# Jeu de tests\n",
    "assert bonjour() == None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Remarque :  $\\texttt{bonjour}()$ ne renvoie rien. Il n'y a même pas d'instruction $\\texttt{return}$ .  \n",
    "Remarque : notez la signature (jamais de telles fonctions ne seront demandées en NSI)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Piège du print  \n",
    "**Attention :** l'erreur commune est de considérer que la valeur affichée à l'écran\n",
    "est une *valeur de retour* de la fonction $\\texttt{print}$ .  \n",
    "• $\\texttt{print}$ est une **instruction**, non pas une fonction (donc pas une expression) mais plus exactement une **procédure**  \n",
    "• La valeur du $\\texttt{print}$ est toujours $\\texttt{None}$ (de type $\\texttt{NoneType}$ )."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(print(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bonjour\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('Bonjour') == None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Instruction d'affichage  \n",
    "Différence entre $\\texttt{print}$ et $\\texttt{return}$  \n",
    "• $\\texttt{print}$ affiche la valeur de son argument sur la sortie standard.  \n",
    "• $\\texttt{return}$ renvoie la valeur de son argument à l'**appelant**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def fun1(x):\n",
    "    \"\"\" ... \"\"\"\n",
    "    return x + 1\n",
    "\n",
    "def fun2(x):\n",
    "    \"\"\" ... \"\"\"\n",
    "    print(x + 1)\n",
    "\n",
    "def fun3(y):\n",
    "    \"\"\" ... \"\"\"\n",
    "    return y * fun1(y)  # OK\n",
    "\n",
    "def fun4(y):\n",
    "    \"\"\" ... \"\"\"\n",
    "    return y * fun2(y) # Erreur"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Utilité  \n",
    "Le $\\texttt{print}$ est inutile du point de vue du calcul. Il sert à observer l'**exécution** d'une fonction.  \n",
    "C'est une aide précieuse pour ”débugger” une fonction."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Passage par valeur vs. par adresse  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def add(x, y):\n",
    "    return x + y\n",
    "\n",
    "def fun():\n",
    "    # a : int\n",
    "    a = 1\n",
    "    # b : int\n",
    "    b = 2\n",
    "    return add(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Que se passe-t-il exactement au moment de l'appel à $\\texttt{add(a,b)}$ ?  \n",
    "Qu'est-ce qui est donné exactement à la fonction $\\texttt{add}$ ? Deux modèles possibles :\n",
    "\n",
    "• passage par **valeur** (cas de $\\texttt{python}$) : on fournit une **copie** du contenu des variables ;    \n",
    "• passage par **adresse** : on fournit l'**adresse mémoire** des variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Somme des premiers entiers   \n",
    "Quelle est la somme des $5$ premiers entiers naturels non nuls ?   \n",
    "1ère réponse : c'est le résultat de $1 + 2 + 3 + 4 + 5$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def somme5():\n",
    "    \"\"\" −> int\n",
    "    renvoie la somme des 5 premiers entiers naturels \"\"\"\n",
    "    return 1 + 2 + 3 + 4 + 5\n",
    "\n",
    "#jeu de tests\n",
    "assert somme5() == 15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Ok. Mais quelle est la somme des $100$ premiers entiers non nuls ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def somme100():\n",
    "    \"\"\" −> int\n",
    "    renvoie la somme des 100 premiers entiers naturels \"\"\"\n",
    "    return 1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20+21+22+23+24+25+26+27+28+29 \\\n",
    "            +30+31+32+33+34+35+36+37+38+39+40+41+42+43+44+45+46+47+48+49+50+51+52+53+54+55 \\\n",
    "            +56+57+58+59+60+61+62+63+64+65+66+67+68+69+70+71+72+73+74+75+76+77+78+79+80+81 \\\n",
    "            +82+83+84+85+86+87+88+89+90+91+92+93+94+95+96+97+98+99+100\n",
    "\n",
    "#jeu de tests\n",
    "assert somme100() == 5050"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "... Ok. Mais quelle est la somme des $100\\, 000$ premiers entiers ? ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Somme des $n$ premiers entiers    \n",
    "Solution insatisfaisante pour plusieurs raisons :\n",
    "1. Long à écrire pour un entier élevé\n",
    "2. Une fonction pour chaque entier !\n",
    "3. Ne répond pas au problème paramétrisé : Quelle est la somme des $n$ premiers entiers ?  \n",
    "\n",
    "On aimerait répondre une fois pour toute au problème et avoir une fonction :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def somme_entiers(n):\n",
    "    \"\"\"int −> int\n",
    "    hypothese : n >= 1\n",
    "    renvoie la somme des n premiers entiers naturels \"\"\"\n",
    "    ...\n",
    "    \n",
    "    \n",
    "#jeu de tests \n",
    "assert somme_entiers(5) == 15  \n",
    "assert somme_entiers(100) == 5050"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Reprenons le premier problème.**  \n",
    "On veut calculer la valeur de $\\displaystyle \\sum_{i=1}^{5} i = 1+2+3+4+5$\n",
    "\n",
    "Calcul itératif des différentes additions : soit $s$ la somme calculée à chaque itération.  \n",
    "$s = 0$ initialement. On veut ensuite :  \n",
    "1. ajouter à $s$ la valeur du prochain entier naturel $1 : s = 1$\n",
    "2. ajouter à $s$ la valeur du prochain entier naturel $2 : s = 3$\n",
    "3. ajouter à $s$ la valeur du prochain entier naturel $3 : s = 6$\n",
    "4. ajouter à $s$ la valeur du prochain entier naturel $4 : s = 10$\n",
    "5. ajouter à $s$ la valeur du prochain entier naturel $5 : s = 15$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def somme5():\n",
    "    \"\"\" −> int\n",
    "    renvoie la somme des 5 premiers entiers naturels \"\"\"\n",
    "    #s : int\n",
    "    s = 0 # calcul des sommes successives\n",
    "    s = s + 1\n",
    "    s = s + 2\n",
    "    s = s + 3\n",
    "    s = s + 4\n",
    "    s = s + 5\n",
    "    return s\n",
    "\n",
    "#jeu de tests\n",
    "assert somme5() == 15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "On approche. Mais on effectue (presque) le **même calcul** à chaque étape.\n",
    "\n",
    "Ce qu'on voudrait en fait c'est :  \n",
    "• Avoir une variable $s$ pour mémoriser les additions successives (fait)  \n",
    "• Avoir une variable $i$ pour représenter successivement les entiers $1$ à $5$.  \n",
    "• Répéter les opérations suivantes $5$ fois :\n",
    "  1. Ajouter à $s$ la valeur de l'entier courant $i$ (on sait faire)  \n",
    "  2. incrémenter la valeur de la variable $i$ (on sait faire)  \n",
    "  \n",
    "Il nous manque une instruction : le $\\texttt{while}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Principe : $i = 1$ au début. Tant que $i \\leqslant 5$ répéter les instructions suivantes :  \n",
    "• ajouter à $s$ la valeur de l'entier naturel mémorisé dans $i$ ;   \n",
    "• incrémenter la valeur de $i$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def somme5():\n",
    "    \"\"\" −> int\n",
    "    renvoie la somme des 5 premiers entiers naturels \"\"\"\n",
    "    #s : int\n",
    "    s = 0 # calcul des sommes successives\n",
    "    #i : int\n",
    "    i = 1 # prochain entier a ajouter\n",
    "    while i <= 5 :\n",
    "        s = s + i\n",
    "        i = i + 1\n",
    "    return s\n",
    "\n",
    "#jeu de tests\n",
    "assert somme5() == 15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Syntaxe du $\\texttt{while}$  \n",
    "\n",
    "$\\texttt{while} <expression> \\texttt{:}$  \n",
    "$\\phantom{.} \\quad <instruction\\, 1>$  \n",
    "$\\phantom{.} \\quad <instruction\\, 2>$  \n",
    "$\\phantom{.} \\quad \\ldots$  \n",
    "$\\phantom{.} \\quad <instruction\\, n>$\n",
    "\n",
    "où  \n",
    "• $\\texttt{< expression >}$ : est une expression booléenne (type $\\texttt{bool}$ ) appelée **condition de sortie de boucle**  \n",
    "• $< instruction\\, 1 >, \\ldots, < instruction\\, n >$ : sont les instructions qui sont répétées à chaque étape, appelées **corps de la boucle**  \n",
    "\n",
    "C'est l'**indentation** qui délimite le corps de la boucle !!\n",
    "\n",
    "$\\texttt{while} <expression> \\texttt{:}$  \n",
    "$\\phantom{.} \\quad <instruction\\, 1>$  \n",
    "$\\phantom{.} \\quad <instruction\\, 2>$  \n",
    "$\\phantom{.} \\quad \\ldots$  \n",
    "$\\phantom{.} \\quad <instruction\\, n>$  \n",
    "$<instruction\\, n+1>$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Principe d'interpretation du $\\texttt{while}$  \n",
    "Soit le programme suivant :  \n",
    "\n",
    "$\\texttt{while} <expression> \\texttt{:}$  \n",
    "$\\phantom{.} \\quad <instruction\\, 1>$  \n",
    "$\\phantom{.} \\quad <instruction\\, 2>$  \n",
    "$\\phantom{.} \\quad \\ldots$  \n",
    "$\\phantom{.} \\quad <instruction\\, n>$  \n",
    "$<instruction\\, n+1>$\n",
    "\n",
    "1. On évalue $< expression >$.  \n",
    "   De deux choses l'une :  \n",
    "   • Soit elle est différente de $\\texttt{False}$ . Alors :  \n",
    "      a. on exécute $< instruction\\,1 >$  \n",
    "      b. on exécute $< instruction\\,2 >$  \n",
    "      c. $\\ldots$  \n",
    "      d. on exécute $< instruction\\,n >$  \n",
    "      e. on retourne à l'étape $1$  \n",
    "   • Soit elle vaut $\\texttt{False}$ . Alors on sort de la boucle et on exécute l'instruction $<instruction\\, n+1>$ (et les suivantes)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Somme des premiers entiers\n",
    "• Grâce au $\\texttt{while} :$ écriture synthétique de $\\texttt{somme5}$ .  \n",
    "• Généralisation de la somme: $n$ comme paramètre :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def somme_entiers(n):\n",
    "    \"\"\"int −> int\n",
    "    hypothese : n >= 1\n",
    "    retourne la somme des n premiers entiers naturels .\"\"\"\n",
    "    # s : int\n",
    "    s = 0 # la somme cumulee\n",
    "    # i : int\n",
    "    i = 1 # prochain entier a ajouter\n",
    "    while i <= n:\n",
    "        s = s + i\n",
    "        i = i + 1\n",
    "    return s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Simulation de boucles  \n",
    "• Parfois difficile de ”voir” le calcul qui est effectué dans une boucle $\\texttt{while}$  \n",
    "• On s'appuie alors sur les simulations de boucles  \n",
    "\n",
    "**Tables de simulation**  \n",
    "1. fixer des valeurs pour les paramètres (on simule sur un exemple précis)  \n",
    "2. fixer des valeurs pour les variables non modifiées par la boucle.  \n",
    "3. créer un tableau avec:  \n",
    "  • une colonne tour de boucle,  \n",
    "  • une colonne par variable modifiée par la boucle.  \n",
    "  \n",
    "4. 1ere ligne: entrée et valeurs des variables avant la boucle.  \n",
    "5. lignes suivantes: tours effectués et valeurs des variables après le tour.  \n",
    "6. dernière ligne: (sortie) au dernier tour."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Simulation de $\\texttt{somme_entiers}$  \n",
    "On se fixe $5$ comme valeur du (seul) paramètre. \n",
    "\n",
    "| tour de boucle | variable $s$ | variable $i$ |\n",
    "|:--------:|:---:|:---:|\n",
    "| entrée  | $0$ | $1$|\n",
    "| $1$  | $1$ | $2$|\n",
    "| $2$  | $3$ | $3$|\n",
    "| $3$  | $6$ | $4$|\n",
    "| $4$  | $10$ | $5$|\n",
    "| $5$ (sortie)  | $15$ | $6$|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Utilisation de $\\texttt{print}$  \n",
    "L'instruction $\\texttt{print}$ peut être utilisée pour tracer (obtenir une trace) des boucles, en affichant, pendant la boucle, la valeur des différentes variables :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=====================\n",
      "s en entree vaut  0\n",
      "i en entree vaut  1\n",
      "−−−−−−−−−−−−−−−−−−\n",
      "s apres le tour vaut  1\n",
      "i apres le tour vaut  2\n",
      "−−−−−−−−−−−−−−−−−−\n",
      "s apres le tour vaut  3\n",
      "i apres le tour vaut  3\n",
      "−−−−−−−−−−−−−−−−−−\n",
      "s apres le tour vaut  6\n",
      "i apres le tour vaut  4\n",
      "−−−−−−−−−−−−−−−−−−\n",
      "s apres le tour vaut  10\n",
      "i apres le tour vaut  5\n",
      "−−−−−−−−−−−−−−−−−−\n",
      "s apres le tour vaut  15\n",
      "i apres le tour vaut  6\n",
      "−−−−−−−−−−−−−−−−−−\n",
      " sortie \n",
      "===================== \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def somme_entiers_tracee(n):\n",
    "    \"\"\"int −> int\n",
    "    Hypothese : n >= 1\n",
    "    retourne la somme des n premiers entiers naturels .\"\"\"\n",
    "    # i : int\n",
    "    i = 1 # compteur\n",
    "    # s : int\n",
    "    s = 0 # somme\n",
    "    print(\"=====================\")\n",
    "    print(\"s en entree vaut \", s)\n",
    "    print(\"i en entree vaut \", i)\n",
    "    while i <= n:\n",
    "        s = s + i\n",
    "        i = i + 1\n",
    "        print(\"−−−−−−−−−−−−−−−−−−\")\n",
    "        print(\"s apres le tour vaut \", s)\n",
    "        print(\"i apres le tour vaut \", i)\n",
    "    print(\"−−−−−−−−−−−−−−−−−−\")\n",
    "    print(\" sortie \")\n",
    "    print(\"===================== \")\n",
    "    return s\n",
    "\n",
    "somme_entiers_tracee(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercices ?\n",
    "• Exercice : somme carres .  \n",
    "• Exercice : somme impairs ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Notion de correction  \n",
    "Quelle est la somme des $n$ premiers entiers naturels non nuls ?  \n",
    "Autre réponse (analytique) : c'est $\\,\\frac{n\\left(n+1\\right)}{2}\\,$  bien sûr !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def somme_entiers(n):\n",
    "    \"\"\"int −> int\n",
    "    hypothese : n >= 1\n",
    "    renvoie la somme des n premiers entiers naturels \"\"\"\n",
    "    return n * (n + 1) / 2\n",
    "\n",
    "#jeu de tests\n",
    "assert somme_entiers(5) == 15\n",
    "assert somme_entiers(100) == 5050"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Notion de correction  \n",
    "• La reflexion est utile (améliore l'efficacité ici)  \n",
    "→ preuve du résultat analytique (*math*)  \n",
    "• La simulation pallie l'absence d'analyse  \n",
    "→ preuve de la correction de la fonction (*info*)  **Notion de correction** : cf. prochain cours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Notion de terminaison  \n",
    "**Terminaison** Une fonction (*informatique*) $f$ termine sur l'entrée $e$ quand l'exécution de $f(e)$ finit par s'arrêter.  \n",
    "Elle termine quand elle termine sur toutes ses entrées.  \n",
    "\n",
    "Pourquoi on ne se pose la question que maintenant :  \n",
    "• Jusqu'ici, toutes nos fonctions terminaient trivialement.  \n",
    "• Avec $\\texttt{while}$  : possibilité des boucles **infinies**  \n",
    "\n",
    "Erreur classique :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def somme_entiers(n):\n",
    "    \"\"\"int −> int\n",
    "    hypothese : n >= 1\n",
    "    retourne la somme des n premiers entiers naturels .\"\"\"\n",
    "    # s : int\n",
    "    s = 0 # la somme cumulee\n",
    "    # i : int\n",
    "    i = 1 # prochain entier a ajouter\n",
    "    while i <= n:\n",
    "        s = s + i  # Boucle infinie !\n",
    "    return s      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Règle de bonne conduite pour un $\\texttt{while}$  \n",
    "Il faut obligatoirement qu'**une des instructions** du corps de la boucle **modifie** *potentiellement* la **valeur de la condition de sortie** de boucle.  \n",
    "\n",
    "Pourquoi $\\texttt{somme_entiers}$ termine ?  \n",
    "i.e. pourquoi $\\texttt{somme_entiers}(n)$ termine pour tout $n$ ?  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "• $i$ vaut $1$ initialement  \n",
    "• $i$ est incrémentée à chaque étape et se rapproche un peu plus du nombre de répétition $n$ voulu : la valeur $n - i$ décroit !  \n",
    "• on sort de la boucle quand la condition est fausse ( $i < = n$ )  \n",
    "\n",
    "Plus de détails au prochain cours, on attend aussi l'avancée du cours de maths pour aller plus loin :  \n",
    "* **Problèmes numériques**  \n",
    "  Calcul des éléments d'une suite  \n",
    "  Calcul d'une somme ou d'un produit des éléments d'une suite  \n",
    "  Calcul du pgcd  \n",
    "  Boucles imbriquées  \n",
    "* **Un cran plus loin** :  \n",
    "  Les fonctionnelles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conclusion  \n",
    "Ce qu'il faut savoir faire à l'issue de cette partie :  \n",
    "* Retenir et utiliser :\n",
    "  * Nouvelle instruction $\\texttt{while}$  \n",
    "  * Notion de simulation de boucles"
   ]
  }
 ],
 "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
}