TD3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les boucles `while`\n",
    "\n",
    "Les boucles permettent de répéter plusieurs fois un ensemble d'opérations. C'est ce qui fait la puissance des programmes informatiques : ils ne se lassent pas de répéter une opération un million de fois.\n",
    "\n",
    "Imaginons que l'on veuille afficher les valeurs de $x^2$ pour $x=1, 2, 3 ... 10$. On pourrait écrire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"1^2 = \",1*1)\n",
    "print(\"2^2 = \",2*2)\n",
    "print(\"3^2 = \",3*3)\n",
    "print(\"4^2 = \",4*4)\n",
    "print(\"5^2 = \",5*5)\n",
    "print(\"6^2 = \",6*6)\n",
    "print(\"7^2 = \",7*7)\n",
    "print(\"8^2 = \",8*8)\n",
    "print(\"9^2 = \",9*9)\n",
    "print(\"10^2 = \",10*10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cela fait beaucoup de lignes de codes donc beaucoup de risque d'erreur. Et si je veux maintenant aller jusqu'à 1000, ce n'est pas très adapté.\n",
    "\n",
    "Si on regarde bien, on réalise en fait plusieurs fois la même opération en modifiant un paramètre. Dans ce cas, nous allons pouvoir utiliser les boucles. \n",
    "\n",
    "Il y a deux types de boucle : les boucles `while` et les boucles `for`. La boucle `for` nécessite de connaître les listes. Nous y reviendrons plus tard.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_____\n",
    "## La boucle `while`\n",
    "*On répètre un bloc **tant que** (`while`) une condition (au sens vu dans le TD précédent) est respectée.*\n",
    "\n",
    "Cela s'écrit de la façon suivante :\n",
    "\n",
    "    while condition :\n",
    "        instruction 1\n",
    "        instruction 2\n",
    "        instruction 3...\n",
    "        \n",
    "- Il est nécessaire d'avoir une condition qui finit par ne pas être satisfaite. Sinon la boucle ne s'arrête jamais.\n",
    "- Une des instructions au moins doit donc avoir un effet sur la condition et la faire passer à `False`\n",
    "- Les conditions peuvent être multiples.\n",
    "- Il est possible de répéter le bloc sans savoir à l'avance combien de fois on va le répéter.\n",
    "\n",
    "Programmons un simple compteur affichant les nombres de 0 à 9 :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb = 0    # initialisation du compteur\n",
    "\n",
    "while nb < 10 :    # condition : tant que nb est inférieur à 10\n",
    "    print(nb)      # on affiche la valeur de nb\n",
    "    nb = nb + 1    # on incrémente le compteur, et donc on modifie la condition qui \n",
    "                   # finira par ne plus être satisfaite   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette boucle offre de nombreuses possibilités :\n",
    "- Si je veux compter jusqu'à 100, on modifie simplement la condition `nb < 100`\n",
    "- Si je veux compter de 2 en 2, on modifie l'avancée du compteur `nb = nb + 2`\n",
    "- Si je veux faire un compte à rebours, on initialise `nb = 10`, on modifie la condition `nb > 0` et l'incrémentation `nb = nb -1`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exercice 1.1\n",
    "Sans l'exécuter, indiquer ce qu'affichera le programme suivant, dans lequel on a inversé les deux dernières lignes du programme précédent. Dans un second temps, exécuter le programme pour vérifier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb = 0 \n",
    "\n",
    "while nb < 10 :\n",
    "    nb = nb + 1\n",
    "    print(nb) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exercice 1.2 : Erreur courante\n",
    "Une erreur que l'on commet souvent en débutant (voire plus tard) est d'oublier d'indenter ou de mal indenter. Exécuter le programme suivant, fortement inspiré du précédent et expliquer ce que vous obtenez en sortie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb = 0\n",
    "\n",
    "while nb < 10 : \n",
    "    nb = nb + 1\n",
    "print(nb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exercice 1.2\n",
    " \n",
    "Sans l'exécuter, examiner le programme suivant et écrire de la façon la plus précise possible, sur un papier, ce qui sera affiché lorsqu'il sera exécuté. \n",
    "\n",
    "Dans un second temps, exécuter le programme pour vérifier votre prédiction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb = 0\n",
    "\n",
    "while nb < 100 :    \n",
    "    print(nb)      \n",
    "    nb = nb**2 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exercice 1.3 :\n",
    "Écrire un programme qui écrit les carrés des 10 premiers entiers, avec une boucle `while`. L'éxécution du programme doit **exactement** donner\n",
    "\n",
    "    1^2 =  1\n",
    "    2^2 =  4\n",
    "    3^2 =  9\n",
    "    4^2 =  16\n",
    "    5^2 =  25\n",
    "    6^2 =  36\n",
    "    7^2 =  49\n",
    "    8^2 =  64\n",
    "    9^2 =  81\n",
    "    10^2 =  100\n",
    "    \n",
    "On pourra s'inspirer du programme donné en exemple pour introduire la boucle `while`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exercice 1.2\n",
    "Reprendre le code précédent et adapter ensuite ce code pour que l'on puisse facilement changer l'exposant (écrire les cubes ou les puissances quatrièmes des entiers successifs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La fonction `input()`\n",
    "\n",
    "Dans la suite, l'utilisateur va devoir entrer un nombre. Ceci est réalisé par la commande `input`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "choix = input(\"Entrer un nombre : \")\n",
    "print(\"Vous avez choisi : \", choix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attention, `input()` renvoie toujours la chaîne de caractères entrée par l'utilisateur (réessayez le code précédent en entrant un mot plutôt qu'un nombre).\n",
    "\n",
    "Si on veut accéder à une valeur numérique, il faut la convertir grâce aux fonctions, `int()` ou `float()` selon l'usage qu'on veut en faire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "choix = input(\"Entrer un nombre : \")\n",
    "print(\"Vous avez choisi : \", float(choix))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exemples de boucle `while` qui ne connait pas à l'avance le nombre de fois que la boucle va être exécutée\n",
    "Dans la boucle suivante, l'utilisateur va devoir entrer un nombre. Tant que ce nombre est négatif, l'ordinateur redemande à l'utilisateur de rentrer un nombre. A vous d'essayer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valeur = -1\n",
    "while valeur < 0 :\n",
    "    valeur = float(input(\"Entrez un nombre positif : \"))\n",
    "print(\"Merci\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'exemple suivant montre une boucle potentiellement éternelle, la condition n'étant jamais fausse. Pour sortir de la boucle, il est alors possible d'utiliser la commande `break`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True :\n",
    "    valeur = input(\"Pour quitter, entrez Q :\")\n",
    "    if (valeur == \"Q\") :\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Exercice 2 : Division par 2\n",
    "\n",
    "L'utilisateur donne un entier positif et le programme annonce combien de fois de suite cet entier est divisible par 2.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exercice 3 : Nombres premiers\n",
    "\n",
    "**Nombre premier :** *nombre qui ne peut être divisé que par lui-même et par $1$.*\n",
    "\n",
    "Écrire un programme qui vérifie qu'un nombre est un nombre premier. \n",
    "\n",
    "Il existe plusieurs approches, mais la plus simple est de vérifier qu'un nombre $n$ n'est pas divisible par $2$, $3$, ..., $n-1$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exercice 4  : Suite de Fibonacci\n",
    "*La suite de Fibonacci peut être considérée comme le tout premier modèle mathématique en dynamique des populations ! Elle décrit la croissance d’une population de lapins sous des hypothèses très simplifiées, à savoir : chaque couple de lapins, dès son troisième mois d’existence, engendre chaque mois un nouveau couple de lapins, et ce indéfiniment.*\n",
    "\n",
    "Mathématiquement, la suite $F_n$ s'écrit comme cela :\n",
    "\n",
    "<div align=\"center\">$ F_0 = 0$</div>\n",
    "<div align=\"center\">$ F_1 = 1$</div>\n",
    "<div align=\"center\">$ F_n = F_{n-1} + F_{n-2}$</div>\n",
    "\n",
    "Ecrire un code pour déterminer combien de mois (i.e. la valeur $n$) requis pour avoir plus de $100$ lapins. Pour cela :\n",
    "\n",
    "* initialiser les variables `F0` et `F1`\n",
    "* calculer `F2` à partir de `F0` et `F1`\n",
    "* Mettre la valeur de `F1` dans `F0`\n",
    "* Mettre la valeur de `F2` dans `F1`\n",
    "* Prendre tout ce code et le mettre dans une boucle `while` \n",
    "* Compter le nombre de fois que la boucle est exécutée et en déduire le nombre de mois.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}