{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Les boucles\n",
    "\n",
    "Une boucle est un outil puissant pour éviter de répéter des opérations. Prenons une liste"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "source": [
    "x = [1,2,3]"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "source": [
    "x[0] *= 2\n",
    "x[1] *= 2\n",
    "x[2] *= 2\n",
    "x"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "[2, 4, 6]"
      ]
     },
     "metadata": {},
     "execution_count": 17
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "On peut faire beaucoup mieux..."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Itérateur  `for`\n",
    "\n",
    "On peut itérer sur une liste de deux façons en utilisant un itérateur. D'abord, on peut le faire par l'indice, ce qui est la forme commune dans d'autres langages:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "source": [
    "x = [1,2,3]\n",
    "for i in [0,1,2]:\n",
    "\tx[i] *= 2\n",
    "x"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "[2, 4, 6]"
      ]
     },
     "metadata": {},
     "execution_count": 18
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "On doit faire attention à l'indentation en Python. Pour une boucle, comme un fonction, il faut indenter ce qui roule à l'intérieur d'une boucle. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Python permet aussi d'utiliser le même itérateur de la manière suivante:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "source": [
    "x = [1,2,3]\n",
    "[x[i]**2 for i in [0,1,2]]"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "[1, 4, 9]"
      ]
     },
     "metadata": {},
     "execution_count": 19
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "On peut aussi utiliser  `range` ou lieu de la liste sur les indices. `len()` redonne le nombre d'éléments dans la liste."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "source": [
    "x = [1,2,3]\n",
    "[x[i]**2 for i in range(len(x))]"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "[1, 4, 9]"
      ]
     },
     "metadata": {},
     "execution_count": 20
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "On peut aussi itérer sur les éléments de la liste directement. Ceci évite de gérer les indices. \n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "source": [
    "xs = [1,2,3]\n",
    "[x**2 for x in xs]"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "[100, 400, 900]"
      ]
     },
     "metadata": {},
     "execution_count": 21
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## La fonction `enumerate`"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Parfois, on veut utiliser à la fois les indices d'une liste mais aussi itérer sur les éléments. Alors on utilise `enumerate()`. Deux indices sont alors disponible dans la boucle: le premier est l'indice, le deuxième la valeur. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "source": [
    "xs = [10,20,30]\n",
    "for i,x in enumerate(xs):\n",
    "\tprint('indice =',i,', valeur de la liste = ',x)\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "indice = 0 , valeur de la liste =  10\n",
      "indice = 1 , valeur de la liste =  20\n",
      "indice = 2 , valeur de la liste =  30\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## La fonction `zip`\n",
    "\n",
    "Parfois, il y a deux listes et on veut faire quelque chose éléments par éléments, on peut y aller directement au lieu de passer par les indices"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "source": [
    "xs = [10,20,30]\n",
    "zs = [4,2,3]\n",
    "for x,z in zip(xs,zs):\n",
    "\tprint('x = ',x,', z = ',z)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "x =  10 , z =  4\n",
      "x =  20 , z =  2\n",
      "x =  30 , z =  3\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Boucles multiples\n",
    "\n",
    "On peut facilement imbriquer des boucles. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "source": [
    "for x in xs:\n",
    "\tfor z in zs:\n",
    "\t\tprint('x = ',x,', z = ',z)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "x =  10 , z =  4\n",
      "x =  10 , z =  2\n",
      "x =  10 , z =  3\n",
      "x =  20 , z =  4\n",
      "x =  20 , z =  2\n",
      "x =  20 , z =  3\n",
      "x =  30 , z =  4\n",
      "x =  30 , z =  2\n",
      "x =  30 , z =  3\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Boucles `while`\n",
    "\n",
    "La boucle `while` est utile quand on ne sait pas quand une répétition doit se terminer ou quand la terminaison dépendra d'un calcul qui doit être fait. Je donne un exemple "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "source": [
    "todo = 5\n",
    "while todo>0:\n",
    "\tprint('todo = ',todo)\n",
    "\ttodo -=1\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "todo =  5\n",
      "todo =  4\n",
      "todo =  3\n",
      "todo =  2\n",
      "todo =  1\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {}
  }
 ],
 "metadata": {
  "orig_nbformat": 4,
  "language_info": {
   "name": "python",
   "version": "3.8.5",
   "mimetype": "text/x-python",
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "pygments_lexer": "ipython3",
   "nbconvert_exporter": "python",
   "file_extension": ".py"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.8.5 64-bit ('base': conda)"
  },
  "interpreter": {
   "hash": "ba2340ab882356406e091df0706039b4b3cc5191eef6c073d3fb97005dbe0324"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}