Intro4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=right> <font color='darkblue'>Une petite introduction à Python [4/5]</font></div>\n",
    "\n",
    "----\n",
    "\n",
    "\n",
    "# <font color=darkred> &#10070; Les boucles</font>\n",
    "## <font color=darkblue> &diams; Répéter une instruction avec la boucle for </font>\n",
    "\n",
    "Le programme ci-dessous permet d'afficher à l'écran un carré de caractère *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*****\n",
      "*****\n",
      "*****\n",
      "*****\n",
      "*****\n"
     ]
    }
   ],
   "source": [
    "# Affiche un carré de 5 sur 5  de caractères *\n",
    "print('*****')\n",
    "print('*****')\n",
    "print('*****')\n",
    "print('*****')\n",
    "print('*****')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comme vous pouvez le constater, nous avons du écrire la même instruction `print('*****')` à cinq reprises.\n",
    "Il serait beaucoup mieux d'indiquer à Python que nous voulons répéter ce `print` cinq fois, nous pouvons le faire à l'aide d'une boucle `for` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*****\n",
      "*****\n",
      "*****\n",
      "*****\n",
      "*****\n"
     ]
    }
   ],
   "source": [
    "for cpt in range(5):\n",
    "    print('*****')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observer attentivement le programme ci-dessus, `cpt` s'écrit en noir indiquant que c'est une variable. C'est en fait cette variable qui va \"compter jusqu'à 5\" de façon à répéter 5 fois l'instruction `print`. Nous l'avons nommé `cpt` pour compteur en abrégé. \n",
    "Observer le programme suivant qui demande d'afficher la valeur de la variable indiquer dans la boucle `for`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for cpt in range(3):\n",
    "    print(cpt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\"><b>&#9889; A retenir : </b><ul>\n",
    "    <li> L'instruction <code><b> for</b> &lt;variable&gt; <b>in</b> <b>range</b>(&lt;entier&gt;):</code>  permet de créer une variable parcourant les entiers de 0 (inclus) à <code>entier</code> (exclu)\n",
    "    <li> Les instructions indentées suivantes seront exécutées pour chaque valeur prise par la variable\n",
    "    <li> La boucle <code><b> for</b> </code> permet donc notamment de répéter un nombre <b>prédéfini</b> de fois des instructions, on dit que c'est une boucle <b>bornée</b>\n",
    "    </ul> </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=green> &#9998; Exercices </font>\n",
    "1. <font color='green'> **Ecrire** en utilisant une boucle for un programme Python qui affiche le dessin suivant à l'écran :</font>\n",
    "```\n",
    "    ******\n",
    "    *    *\n",
    "    *    *\n",
    "    *    *\n",
    "    *    *\n",
    "    ******\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Taper votre programme ici, utiliser une boucle for pour afficher les lignes 2 à 5\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. <font color=\"green\"> **Compléter** le programme ci-dessous qui affiche les 10 premiers multiples de 7.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Affiche les 10 premiers multiples de 7\n",
    "___ k in _____(0,__):\n",
    "    print(k*7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. <font color=\"green\"> **Compléter** le programme ci-dessous qui affiche les 10 premières puissances de 2.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Affichage de 2**0, 2**1, 2**2, 2**3, ..., 2**10\n",
    "for ____ in _________ \n",
    "    print(________)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. <font color=\"green\"> **Corriger** le programme ci-dessous qui demande à l'utilisateur d'entrer trois notes puis calcule et affiche la moyenne.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Programme moyenne\n",
    "for i in range(1,3):\n",
    "    print(Entrer la note n°\",i)\n",
    "    note = input\n",
    "    somme = somme + note\n",
    "    moyenne = somme/3\n",
    "print(\"La moyenne des trois notes est : ,moyenne\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. <font color=\"green\">**Ecrire** un programme qui donne <i>lorsqu'il y en a</i> toutes les façon d'obtenir un entier donné en lançant deux dés à 6 faces. Par exemple pour 1, le programme répondra \"aucune possibilité\", pour 6, il répondra \"1+5\", \"2+4\" et \"3+3\".<br>\n",
    "Même question lorsqu'il y a 3 dés.\n",
    "</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Programme somme des dés\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=darkblue> &diams; Quelques précisions sur l'instruction `range`</font>\n",
    "\n",
    "Pour le moment nous avons utilisé l'instruction `range` sous la forme `range(<fin>)` pour parcourir les entiers de 0 jusqu'à `fin` **exclu**. On peut aussi spéficier le début lorsqu'on ne veut pas démarrer de 0.\n",
    "Par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "# On compte de 10 à 14 : n'oublier que la fin du range est EXCLU\n",
    "for entier in range(10,15):\n",
    "    print(entier)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'instruction `range` peut même prendre un troisième paramètre, pour comprendre à quoi il correspond, observer attentivement l'exemple suivant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "7\n",
      "14\n",
      "21\n",
      "28\n",
      "35\n",
      "42\n",
      "49\n",
      "56\n",
      "63\n"
     ]
    }
   ],
   "source": [
    "# Essayer de comprendre à quoi sert le troisième paramètre du range\n",
    "# Le nom de la variable est là pour vous aider\n",
    "for mult7 in range(0,70,7):\n",
    "    print(mult7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous avons afficher les 10 premiers multiples de 7, parce que nous avons compté de 7 en 7. Le troisième paramètre est donc l'**incrément** c'est à dire la valeur ajoutée à la variable quand on avance dans la boucle."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bien sur, nous pouvons compter à rebours si notre **incrément** est négatif"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "# Compte à rebours de 3 jusqu'à 0 :\n",
    "for cpt in range(3,-1,-1):\n",
    "    print(cpt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observer encore que la dernière valeur `-1` est exclue, on s'arrête donc à 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=green> &#9998; Exercices </font>\n",
    "7. <font color='green'> La coupe du monde de football se déroule tout les quatre ans et sa première édition date de 1930. D'autre part, à cause de la seconde guerre mondiale, la compétition n'a pas eu lieu en 1942 et en 1946. <b>Compléter</b> le programme Python ci-dessous qui liste toutes les années où la coupe du monde s'est déroulée de 1930 à nos jours </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Programme qui affiche les années coupe du monde de football\n",
    "___ annee in _____(____,____,_):\n",
    "    if annee!=1942 and annee!=1946:\n",
    "        print(annee)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. <font color='green'> <b>Modifier</b> le programme \"coupe du monde\" ci-dessus pour qu'il affiche en plus des années le numéro de l'édition. Le programme devra donc afficher : </font>\n",
    "```\n",
    "1930 : Coupe du monde N°1\n",
    "1934 : Coupe du monde N°2\n",
    "..```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Programme qui affiche les années coupe du monde de football avec le numéro\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9. <font color='green'>Compléter le programme ci-dessous qui calcule la somme des entiers **impairs** de 1 à 99 :</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calcul de 1+3+5+7......+99\n",
    "somme = 0\n",
    "#On parcourt la liste des entiers impairs de 1 à 99 en les ajoutant à la variable somme\n",
    "for _______ in ________\n",
    "    somme = ___________\n",
    "print(\"La somme des entiers impairs de 1 à 99 est égal à : \",_______)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarquons qu'il est possible en Python d'utiliser la multiplication `*` pour indiquer combien de fois afficher un caractère. Par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "##########\n"
     ]
    }
   ],
   "source": [
    "print('#'*10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10. <font color='green'>En utilisant la remarque ci-dessus, écrire un programme Python qui affiche à l'écran le dessin suivant: </font>\n",
    "\n",
    "```\n",
    "*******\n",
    "******\n",
    "*****\n",
    "****\n",
    "***\n",
    "**\n",
    "*\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Programme triangle d'étoiles !\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color='darkblue'> &diams; La boucle `while`</font>\n",
    "\n",
    "Nous avons vu ci-dessus que la boucle `for` permet de parcourir une structure et de répéter des instructions un nombre **déterminé** de fois, c'est pourquoi on dit que c'est une boucle **bornée**. Cependant dans certaines situations, il n'est pas possible de connaître à l'avance le nombre de répétitions nécessaires. \n",
    "\n",
    "Prenons un exemple, on demande à l'utilisateur d'entrer un code secret pour continuer, si l'utilisateur se trompe, il peut recommencer autant de fois qu'il le désire. On doit cette fois utiliser une boucle **non bornée**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrer le code secret pour continuer : titi\n",
      "Entrer le code secret pour continuer : 1234\n",
      "Entrer le code secret pour continuer : toto\n"
     ]
    }
   ],
   "source": [
    "code_secret = 'toto' \n",
    "reponse = ''\n",
    "while reponse != code_secret:\n",
    "    reponse = input(\"Entrer le code secret pour continuer : \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\"><b>&#9889; A retenir :</b>\n",
    "<ul>\n",
    "    <li> La syntaxe de l'instruction <code><b>while</b></code> est <code> <b>while</b> &lt;condition&gt;: </code>\n",
    "    <li> Les instructions indentées qui suivent seront exécutées tant que  <code>&lt;condition&gt;</code> est vrai\n",
    "     <li> Contrairement à la boucle <code><b>for</b></code> qui s'arrête après un nombre déterminé d'itérations, la boucle <code><b>while</b></code> est dite \"non bornée\", son nombre de répétitions n'est pas connu a priori. \n",
    "    </ul>\n",
    "    </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=green> &#9998; Exercices </font>\n",
    "11. <font color='green'>**Compléter** le programme ci-dessous en vous aidant des commentaires qui y figurent</font> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Trouve le plus petit entier N tel que 1+2+3+...N dépasse 1000\n",
    "somme = 0  \n",
    "entier = 0 \n",
    "while ______<1000: #On répète les instructions qui suivent tant que la somme n'a pas dépassé 1000\n",
    "    entier = ______+1 #On incrémente entier de façon à ajouter 1 puis 2, puis 3, puis 4, ...\n",
    "    somme = somme+_______ #On rajouter entier à la somme\n",
    "print(\"On dépasse 1000 après avoir ajouté \",entier)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "12.<font color='green'> Lorsqu'on place un capital a intérêts composés à un taux de $t \\%$, cela signifie que la somme dont on dispose est multipliée par $1+\\dfrac{t}{1000}$ chaque année. Ecrire un programme Python qui demande à l'utilisateur le taux d'intérêt $t$ puis calcule le nombre d'années au bout duquel le capital placé au départ est doublé.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Programme taux d'intérêt\n"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}