01_03_Les_Boucles_en_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans ce notebook, nous verrons comment faire en sorte que notre programme repète un comportement ou une suite d'instructions. On parle de boucles ou `loops` en anglais."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# La boucle For"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette partie est l'une des parties facile à apprendre pour ceux qui parlent l'anglais. Python utilise des mots en anglais pour representer des concepts. Je ferai l'effort d'expliquer les concepts avec du code en français dans un premier temps avant de vous montrer l'équivalent en anglais qui sera juste une traduction."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La boucle For nous permet de parcourir un itérable. Un itérable est une collection d'éléments comme une liste, un dictionnaire, un tuple ou une chaîne de caractère. \n",
    "\n",
    "Prenoms l'exemple d'une liste d'animaux : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "animaux = ['chien', 'chat', 'abeille', 'oiseau']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous souhaitons parcourir cette liste (`itérable`) et afficherons chaque élement en Majuscule. Si on devrait écrire le code dans notre propre langage, on dira:\n",
    "> Pour chaque animal dans la liste animaux, \n",
    "    Met le en Majuscule et affiche le.\n",
    "\n",
    "Voici comment on l'écrirait si Python utilisait des mots en Français : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pour animal dans animaux:\n",
    "    animal = animal.majuscule()\n",
    "    affiche(animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans ce bout de code, on a définit une variable appelée `animal` à laquelle on va affecter chaque élément de la liste `animaux`, le modifier et l'afficher. A chaque itération, animal aura une valeur différente et sera modifié et affiché jusqu'à ce que tous les animaux soient affichés. Ecrivons maintenant ce code en Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CHIEN\n",
      "CHAT\n",
      "ABEILLE\n",
      "OISEAU\n"
     ]
    }
   ],
   "source": [
    "for animal in animaux:\n",
    "    animal = animal.upper()\n",
    "    print(animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voilà, il n'y a pas de grande différence. On a juste remplacé pour par sa traduction en anglais **for**, dans par **in**, majuscule par **upper** et affiche par **print**. \n",
    "\n",
    "On peut combiner cette compétence qu'on vient d'acquérir avec d'autres éléments qu'on a déjà appris, comme les conditions. Dans le code suivant, nous allons creer une liste vide`c_animaux`, puis parcourir la liste `animaux` et ajouter à c_animaux tous les animaux dont le nom commence par c:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "c_animaux = [] # liste vide pour stocker les animaux dont le nom commence par c\n",
    "for animal in animaux:\n",
    "    if animal.startswith('c'): # si animal commence par c\n",
    "        c_animaux.append(animal) # ajoute animal à c_animaux"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['chien', 'chat']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_animaux"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et voilà comment on peut utiliser la boucle for pour parcourir un itérable. Un dernier exemple serait d'afficher à tour de rôle les lettres d'une chaîne de caractères:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "K\n",
      "e\n",
      "v\n",
      "i\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "for lettre in \"Kevin\":\n",
    "    print(lettre)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut également afficher l'index de chaque élément tout en le parcourant avec la fonction enumerate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 K\n",
      "1 e\n",
      "2 v\n",
      "3 i\n",
      "4 n\n"
     ]
    }
   ],
   "source": [
    "for index, lettre in enumerate(\"Kevin\"):\n",
    "    print(index, lettre)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Autre chose qu'on peut faire avec la boucle for, c'est de parcourir une séquence de nombres. Ceci peut-être intéressant quand on veut repéter un comportement, un certain nombre de fois:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "la fonction `range` permet de générer une séquence de nombre. Dans l'exemple précédent, range(5) permet de générer les nombres de 0 à 5-1=4. Voici d'autres séquences générées avec la fonction range:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 6):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for i in range(2, 10, 2): # un pas de deux\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# La boucle While"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While veut dire **tant que** ou **pendant que**. La boucle while nous permet de répeter un comportement tant qu'une condition est vérifiée. On utilise la boucle while dans les cas où on n'a pas une idée exacte du nombre de fois qu'on devra repeter un bout de code. La syntaxe d'une boucle While est la suivante:\n",
    "```python\n",
    "while condition qui est vraie:\n",
    "    Fais quelque chose\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essayons d'afficher des nombres de 10 à -2. Voilà donc un comportement qu'on va répéter tant que le nombre est  > ou égale à -2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n",
      "-1\n",
      "-2\n"
     ]
    }
   ],
   "source": [
    "nombre = 10\n",
    "while nombre >= -2:\n",
    "    print(nombre)\n",
    "    nombre = nombre - 1 # reduisons nombre pour qu'éventuellement cette boucle s'arrête"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La dernière ligne est très importante. Si on ne diminuait pas le nombre, il sera toujours  >= -2 et donc la boucle d'executera pour toujours et éventuellement épuiser les ressources de votre ordinateur. On parle de boucle infinie."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parfois dans une boucle, on peut vouloir s'arrêter dès qu'une condition est vérifié. Imagine qu'on veuille parcourir une liste de prénoms et dès qu'on rencontre le prenom \"Ali\", on s'arrête et affiche son index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "prenoms = ['bob', 'alice', 'paul', 'ali', 'tom', 'toni']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bob\n",
      "alice\n",
      "paul\n",
      "ali\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for index, prenom in enumerate(prenoms):\n",
    "    print(prenom)\n",
    "    if prenom == 'ali':\n",
    "        print(index)\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En mettant le mot clé break dans notre boucle, on ne verra jamais tom et toni. Break arrête la boucle."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le mot clé `continue` est comme break mais au lieu d'arrêter la boucle, il passe à l'itération suivante. Voyons un exemple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "prenoms = ['bob', 'alice', 'paul', 'ali', 'tom', 'toni']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bob\n",
      "Je ne serai pas affiché pour ali\n",
      "alice\n",
      "Je ne serai pas affiché pour ali\n",
      "paul\n",
      "Je ne serai pas affiché pour ali\n",
      "ali\n",
      "tom\n",
      "Je ne serai pas affiché pour ali\n",
      "toni\n",
      "Je ne serai pas affiché pour ali\n"
     ]
    }
   ],
   "source": [
    "for index, prenom in enumerate(prenoms):\n",
    "    print(prenom)\n",
    "    if prenom == 'ali':\n",
    "        continue\n",
    "    print(\"Je ne serai pas affiché pour ali\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si vous faîtes attention, vous verrez que la dernière ligne n'est pas exécutée pour ali."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voilà les bases qu'il faut connaitre concernant les boucles. Comme d'habitude, vous pouvez pratiquer ce que vous venez d'apprendre ici : https://www.w3schools.com/python/exercise.asp?filename=exercise_while_loops1 et ici : https://www.w3schools.com/python/exercise.asp?filename=exercise_for_loops1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}