Seance2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Partie 2 : Listes , n-uplets, ensembles et dictionnaires"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Petits rappels sur les listes\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [1, 2, 3, 4, 5, 6, 7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "for e in L:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = L + [8]\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L.append(9)\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L.remove(2)\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, 5, 6, 7, 9]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L.remove(8)\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abdd\n",
      "dsada\n",
      "adad\n"
     ]
    }
   ],
   "source": [
    "L = [\"abdd\", \"dsada\", \"adad\"]\n",
    "for e in L:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/6.7.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'List' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-26-fcd99f366a28>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mdef\u001b[0m \u001b[0mlist_mult\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0ml\u001b[0m \u001b[0;34m:\u001b[0m \u001b[0mList\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m,\u001b[0m \u001b[0mk\u001b[0m \u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m     \u001b[0;34m\"\"\"Retourne la liste obtenue en multipliant par k tous les éléments de L.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0mlres\u001b[0m \u001b[0;34m:\u001b[0m \u001b[0mList\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mx\u001b[0m \u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;31m# element courant\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0ml\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'List' is not defined"
     ]
    }
   ],
   "source": [
    "def list_mult( l : List[T] , k : int):\n",
    "    \"\"\"Retourne la liste obtenue en multipliant par k tous les éléments de L.\"\"\"\n",
    "    lres : List[int] = []\n",
    "    x : int # element courant\n",
    "    for x in l:\n",
    "        lres.append(x * k)\n",
    "    return lres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert list_mult([3,5, 2, 4], 5) == [15, 25, 10, 20]\n",
    "assert list_mult([3, 5, 2, 4], -1) == [-3, -5, -2, -4]\n",
    "assert list_mult([3, 5, 2, 4], 0) == [0, 0, 0, 0]\n",
    "assert list_mult([], 10) == []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/6.7.1.2.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>\n",
    "<center>\n",
    "    <img src=\"./pics/6.7.1.3.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def list_div(l , k : int):\n",
    "    \"\"\"Precondition : k != 0\n",
    "    Retourne la liste obtenue en divisant par k les éléments de l\n",
    "    qui sont multiples de k et en supprimant les autres.\"\"\"\n",
    "    lres : List[int] = []\n",
    "    e : int\n",
    "    for e in l:\n",
    "        if e%k==0:\n",
    "            lres.append(e // k)\n",
    "    return lres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, -15]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# version range\n",
    "def list_div(l , k : int):\n",
    "    \"\"\"Precondition : k != 0\n",
    "    Retourne la liste obtenue en divisant par k les éléments de l\n",
    "    qui sont multiples de k et en supprimant les autres.\"\"\"\n",
    "    lres : List[int] = []\n",
    "    indice : int\n",
    "    for indice in range(len(l)): # [0, 1 ,2 .... len(l) - 1]\n",
    "        print(indice)\n",
    "        if l[indice]%k == 0:\n",
    "            lres.append(l[indice] // k)\n",
    "    return lres\n",
    "list_div([-3, 45, 10, 8, 50, 1], -3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert list_div([3, 45, 10, 8, 50, 1], 5) == [9, 2, 10]\n",
    "assert list_div([-3, 45, 10, 8, 50, 1], -3) == [1, -15]\n",
    "assert list_div([3, 5, 7, 11], 2) == []\n",
    "assert list_div([], 10) == []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/6.8.1.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    " def entrelacement(l1 , l2):\n",
    "        \"\"\"Precondition : len(l1) == len(l2)\n",
    "        retourne la liste obtenue en intercalant les éléments de l1 et les éléments de l2\"\"\"\n",
    "        lres : List[T] = []\n",
    "        indice : int #indice de l'élément courant\n",
    "        for indice in range(len(l1)):\n",
    "            lres.append(l1[indice]) # lres = lres + [l1[indice]]\n",
    "            lres.append(l2[indice]) # lres = lres + [l2[indice]]   (lres += [l2[indice]])\n",
    "        return lres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert entrelacement([1, 2, 3], [4, 5, 6]) == [1, 4, 2, 5, 3, 6]\n",
    "assert entrelacement([\"p\", \"t\", \"o\"], [\"y\", \"h\", \"n\"]) == ['p', 'y', 't', 'h', 'o', 'n']\n",
    "assert entrelacement([], []) ==[]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/6.8.2.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "taille de L1= 5\n",
      "taille de L2= 8\n"
     ]
    }
   ],
   "source": [
    "L1 = [1,2,3,4,5]\n",
    "L2 = [10, 11, 12, 13, 14, 15, 16, 17]\n",
    "print('taille de L1=',len(L1))\n",
    "print('taille de L2=',len(L2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 11, 12, 13, 14]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L2[:len(L1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[15, 16, 17]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L2[len(L1):]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def entrelacement_general(l1 , l2):\n",
    "    \"\"\"Retourne la liste obtenue en intercalant les éléments de l1 et ceux de l2\"\"\"\n",
    "    if len(l1) == len(l2):\n",
    "        return entrelacement(l1, l2)\n",
    "    elif len(l1) < len(l2):\n",
    "        return entrelacement(l1, l2[:len(l1)]) + l2[len(l1):]\n",
    "    else:\n",
    "        return entrelacement(l1[:len(l2)], l2) + l1[len(l2):]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def entrelacement_general(l1 , l2):\n",
    "    \"\"\"Retourne la liste obtenue en intercalant les éléments de l1 et ceux de l2\"\"\"\n",
    "    #liste résultat\n",
    "    lres : List[T] = []\n",
    "    \n",
    "    i : int # indice courant\n",
    "    for i in range(max(len(l1), len(l2))):\n",
    "        if i < len(l1):\n",
    "            lres.append(l1[i])\n",
    "        if i < len(l2):\n",
    "            lres.append(l2[i])\n",
    "    return lres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert entrelacement_general([\"p\", \"t\", \"o\"], [\"y\", \"h\", \"n\"]) == ['p', 'y', 't', 'h', 'o', 'n']\n",
    "assert entrelacement_general([1, 2, 3], [4, 5, 6, 7, 8]) == [1, 4, 2, 5, 3, 6, 7, 8]\n",
    "assert entrelacement_general([1, 2, 3], []) == [1, 2, 3]\n",
    "assert entrelacement_general([1, 2, 3, 10, 11], [4, 5, 6]) == [1, 4, 2, 5, 3, 6, 10, 11]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/6.9.1.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def jonction(l , c : str) -> str:\n",
    "    \"\"\"Précondition : len(c) = 1\n",
    "    Retourne la chaîne composée de la jonction des\n",
    "    chaîne de L séparées deux-à-deux par le\n",
    "    caractère séparateur c.\n",
    "    \"\"\"\n",
    "    if len(l) == 0: # cas particulier, l est une liste vide\n",
    "        return ''\n",
    "    # chaîne résultat\n",
    "    r : str = l[0] # initialisation au premier élément de la liste\n",
    "    i : int = 1 # indice courant lors du parcours\n",
    "    while i < len(l):\n",
    "        r = r + c + l[i]\n",
    "        i = i +1\n",
    "    return r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "def jonction(l , c : str) -> str:\n",
    "    \"\"\"Précondition : len(c) = 1\n",
    "    Retourne la chaîne composée de la jonction des\n",
    "    chaîne de L séparées deux-à-deux par le\n",
    "    caractère séparateur c.\n",
    "    \"\"\"\n",
    "    if len(l) == 0: # cas particulier, l est une liste vide\n",
    "        return ''\n",
    "    # chaîne résultat\n",
    "    r : str = '' \n",
    "    i : int = 0 # indice courant lors du parcours\n",
    "    while i < len(l):\n",
    "        if i == 0:\n",
    "            r = r + l[i]\n",
    "            i = i + 1\n",
    "        else:\n",
    "            r = r + c + l[i]\n",
    "            i = i +1\n",
    "    return r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert jonction(['un', 'deux', 'trois', 'quatre'], '.') == 'un.deux.trois.quatre'\n",
    "assert jonction(['les', 'mots', 'de', 'cette', 'phrase'], ' ') == 'les mots de cette phrase'\n",
    "assert jonction(['un'], '+') == 'un'\n",
    "assert jonction([], '+') == ''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/6.9.2.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'uco'"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"coucou\"\n",
    "a[2:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ind_debut = 0\n",
      "ind_fin = 0\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : \n",
      "ind_debut = 0\n",
      "ind_fin = 1\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : u\n",
      "ind_debut = 0\n",
      "ind_fin = 2\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : un\n",
      "ind_debut = 3\n",
      "ind_fin = 3\n",
      "Résultat courant ['un']\n",
      "Sous-chaîne considérée à l'itération courante : \n",
      "ind_debut = 3\n",
      "ind_fin = 4\n",
      "Résultat courant ['un']\n",
      "Sous-chaîne considérée à l'itération courante : d\n",
      "ind_debut = 3\n",
      "ind_fin = 5\n",
      "Résultat courant ['un']\n",
      "Sous-chaîne considérée à l'itération courante : de\n",
      "ind_debut = 3\n",
      "ind_fin = 6\n",
      "Résultat courant ['un']\n",
      "Sous-chaîne considérée à l'itération courante : deu\n",
      "ind_debut = 3\n",
      "ind_fin = 7\n",
      "Résultat courant ['un']\n",
      "Sous-chaîne considérée à l'itération courante : deux\n",
      "ind_debut = 8\n",
      "ind_fin = 8\n",
      "Résultat courant ['un', 'deux']\n",
      "Sous-chaîne considérée à l'itération courante : \n",
      "ind_debut = 8\n",
      "ind_fin = 9\n",
      "Résultat courant ['un', 'deux']\n",
      "Sous-chaîne considérée à l'itération courante : r\n",
      "ind_debut = 8\n",
      "ind_fin = 10\n",
      "Résultat courant ['un', 'deux']\n",
      "Sous-chaîne considérée à l'itération courante : ro\n",
      "ind_debut = 8\n",
      "ind_fin = 11\n",
      "Résultat courant ['un', 'deux']\n",
      "Sous-chaîne considérée à l'itération courante : roi\n",
      "ind_debut = 8\n",
      "ind_fin = 12\n",
      "Résultat courant ['un', 'deux']\n",
      "Sous-chaîne considérée à l'itération courante : rois\n",
      "ind_debut = 13\n",
      "ind_fin = 13\n",
      "Résultat courant ['un', 'deux', 'rois']\n",
      "Sous-chaîne considérée à l'itération courante : \n",
      "ind_debut = 13\n",
      "ind_fin = 14\n",
      "Résultat courant ['un', 'deux', 'rois']\n",
      "Sous-chaîne considérée à l'itération courante : q\n",
      "ind_debut = 13\n",
      "ind_fin = 15\n",
      "Résultat courant ['un', 'deux', 'rois']\n",
      "Sous-chaîne considérée à l'itération courante : qu\n",
      "ind_debut = 13\n",
      "ind_fin = 16\n",
      "Résultat courant ['un', 'deux', 'rois']\n",
      "Sous-chaîne considérée à l'itération courante : qua\n",
      "ind_debut = 13\n",
      "ind_fin = 17\n",
      "Résultat courant ['un', 'deux', 'rois']\n",
      "Sous-chaîne considérée à l'itération courante : quat\n",
      "ind_debut = 13\n",
      "ind_fin = 18\n",
      "Résultat courant ['un', 'deux', 'rois']\n",
      "Sous-chaîne considérée à l'itération courante : quatr\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['un', 'deux', 'rois', 'quatre']"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def separation(s : str, c : str):\n",
    "    \"\"\"Precondition : len(c) == 1\n",
    "    retourne la liste de chaînes composées des sous-chaînes de s séparées par le caractère séparateur c.\n",
    "    Le séparateur c n'est pas présent dans la chaîne résultat.\"\"\"\n",
    "    lres : List[str] = []\n",
    "    ind_debut : int = 0\n",
    "    ind_fin : int = 0\n",
    "    e : str # caractère courant\n",
    "    for e in s:\n",
    "        print('ind_debut =',ind_debut)\n",
    "        print('ind_fin =', ind_fin)\n",
    "        print('Résultat courant',lres)\n",
    "        print(\"Sous-chaîne considérée à l'itération courante :\", s[ind_debut:ind_fin])\n",
    "        if e==c:\n",
    "            if ind_fin > ind_debut:\n",
    "                lres.append(s[ind_debut:ind_fin])\n",
    "            ind_debut = ind_fin + 1\n",
    "            ind_fin = ind_debut\n",
    "        else:\n",
    "            ind_fin = ind_fin + 1\n",
    "    if ind_fin > ind_debut:\n",
    "        lres.append(s[ind_debut:ind_fin])\n",
    "    return lres\n",
    "separation('un.deux.rois.quatre', '.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ind_debut = 0\n",
      "ind_fin = 0\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : \n",
      "ind_debut = 0\n",
      "ind_fin = 1\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : u\n",
      "ind_debut = 0\n",
      "ind_fin = 2\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : un\n",
      "ind_debut = 3\n",
      "ind_fin = 3\n",
      "Résultat courant ['un']\n",
      "Sous-chaîne considérée à l'itération courante : \n",
      "ind_debut = 3\n",
      "ind_fin = 4\n",
      "Résultat courant ['un']\n",
      "Sous-chaîne considérée à l'itération courante : d\n",
      "ind_debut = 3\n",
      "ind_fin = 5\n",
      "Résultat courant ['un']\n",
      "Sous-chaîne considérée à l'itération courante : de\n",
      "ind_debut = 3\n",
      "ind_fin = 6\n",
      "Résultat courant ['un']\n",
      "Sous-chaîne considérée à l'itération courante : deu\n",
      "ind_debut = 3\n",
      "ind_fin = 7\n",
      "Résultat courant ['un']\n",
      "Sous-chaîne considérée à l'itération courante : deux\n",
      "ind_debut = 8\n",
      "ind_fin = 8\n",
      "Résultat courant ['un', 'deux']\n",
      "Sous-chaîne considérée à l'itération courante : \n",
      "ind_debut = 8\n",
      "ind_fin = 9\n",
      "Résultat courant ['un', 'deux']\n",
      "Sous-chaîne considérée à l'itération courante : t\n",
      "ind_debut = 8\n",
      "ind_fin = 10\n",
      "Résultat courant ['un', 'deux']\n",
      "Sous-chaîne considérée à l'itération courante : tr\n",
      "ind_debut = 8\n",
      "ind_fin = 11\n",
      "Résultat courant ['un', 'deux']\n",
      "Sous-chaîne considérée à l'itération courante : tro\n",
      "ind_debut = 8\n",
      "ind_fin = 12\n",
      "Résultat courant ['un', 'deux']\n",
      "Sous-chaîne considérée à l'itération courante : troi\n",
      "ind_debut = 8\n",
      "ind_fin = 13\n",
      "Résultat courant ['un', 'deux']\n",
      "Sous-chaîne considérée à l'itération courante : trois\n",
      "ind_debut = 14\n",
      "ind_fin = 14\n",
      "Résultat courant ['un', 'deux', 'trois']\n",
      "Sous-chaîne considérée à l'itération courante : \n",
      "ind_debut = 14\n",
      "ind_fin = 15\n",
      "Résultat courant ['un', 'deux', 'trois']\n",
      "Sous-chaîne considérée à l'itération courante : q\n",
      "ind_debut = 14\n",
      "ind_fin = 16\n",
      "Résultat courant ['un', 'deux', 'trois']\n",
      "Sous-chaîne considérée à l'itération courante : qu\n",
      "ind_debut = 14\n",
      "ind_fin = 17\n",
      "Résultat courant ['un', 'deux', 'trois']\n",
      "Sous-chaîne considérée à l'itération courante : qua\n",
      "ind_debut = 14\n",
      "ind_fin = 18\n",
      "Résultat courant ['un', 'deux', 'trois']\n",
      "Sous-chaîne considérée à l'itération courante : quat\n",
      "ind_debut = 14\n",
      "ind_fin = 19\n",
      "Résultat courant ['un', 'deux', 'trois']\n",
      "Sous-chaîne considérée à l'itération courante : quatr\n",
      "ind_debut = 0\n",
      "ind_fin = 0\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : \n",
      "ind_debut = 0\n",
      "ind_fin = 1\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : l\n",
      "ind_debut = 0\n",
      "ind_fin = 2\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : le\n",
      "ind_debut = 0\n",
      "ind_fin = 3\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les\n",
      "ind_debut = 4\n",
      "ind_fin = 4\n",
      "Résultat courant ['les']\n",
      "Sous-chaîne considérée à l'itération courante : \n",
      "ind_debut = 4\n",
      "ind_fin = 5\n",
      "Résultat courant ['les']\n",
      "Sous-chaîne considérée à l'itération courante : m\n",
      "ind_debut = 4\n",
      "ind_fin = 6\n",
      "Résultat courant ['les']\n",
      "Sous-chaîne considérée à l'itération courante : mo\n",
      "ind_debut = 4\n",
      "ind_fin = 7\n",
      "Résultat courant ['les']\n",
      "Sous-chaîne considérée à l'itération courante : mot\n",
      "ind_debut = 4\n",
      "ind_fin = 8\n",
      "Résultat courant ['les']\n",
      "Sous-chaîne considérée à l'itération courante : mots\n",
      "ind_debut = 9\n",
      "ind_fin = 9\n",
      "Résultat courant ['les', 'mots']\n",
      "Sous-chaîne considérée à l'itération courante : \n",
      "ind_debut = 9\n",
      "ind_fin = 10\n",
      "Résultat courant ['les', 'mots']\n",
      "Sous-chaîne considérée à l'itération courante : d\n",
      "ind_debut = 9\n",
      "ind_fin = 11\n",
      "Résultat courant ['les', 'mots']\n",
      "Sous-chaîne considérée à l'itération courante : de\n",
      "ind_debut = 12\n",
      "ind_fin = 12\n",
      "Résultat courant ['les', 'mots', 'de']\n",
      "Sous-chaîne considérée à l'itération courante : \n",
      "ind_debut = 12\n",
      "ind_fin = 13\n",
      "Résultat courant ['les', 'mots', 'de']\n",
      "Sous-chaîne considérée à l'itération courante : c\n",
      "ind_debut = 12\n",
      "ind_fin = 14\n",
      "Résultat courant ['les', 'mots', 'de']\n",
      "Sous-chaîne considérée à l'itération courante : ce\n",
      "ind_debut = 12\n",
      "ind_fin = 15\n",
      "Résultat courant ['les', 'mots', 'de']\n",
      "Sous-chaîne considérée à l'itération courante : cet\n",
      "ind_debut = 12\n",
      "ind_fin = 16\n",
      "Résultat courant ['les', 'mots', 'de']\n",
      "Sous-chaîne considérée à l'itération courante : cett\n",
      "ind_debut = 12\n",
      "ind_fin = 17\n",
      "Résultat courant ['les', 'mots', 'de']\n",
      "Sous-chaîne considérée à l'itération courante : cette\n",
      "ind_debut = 18\n",
      "ind_fin = 18\n",
      "Résultat courant ['les', 'mots', 'de', 'cette']\n",
      "Sous-chaîne considérée à l'itération courante : \n",
      "ind_debut = 18\n",
      "ind_fin = 19\n",
      "Résultat courant ['les', 'mots', 'de', 'cette']\n",
      "Sous-chaîne considérée à l'itération courante : p\n",
      "ind_debut = 18\n",
      "ind_fin = 20\n",
      "Résultat courant ['les', 'mots', 'de', 'cette']\n",
      "Sous-chaîne considérée à l'itération courante : ph\n",
      "ind_debut = 18\n",
      "ind_fin = 21\n",
      "Résultat courant ['les', 'mots', 'de', 'cette']\n",
      "Sous-chaîne considérée à l'itération courante : phr\n",
      "ind_debut = 18\n",
      "ind_fin = 22\n",
      "Résultat courant ['les', 'mots', 'de', 'cette']\n",
      "Sous-chaîne considérée à l'itération courante : phra\n",
      "ind_debut = 18\n",
      "ind_fin = 23\n",
      "Résultat courant ['les', 'mots', 'de', 'cette']\n",
      "Sous-chaîne considérée à l'itération courante : phras\n",
      "ind_debut = 0\n",
      "ind_fin = 0\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : \n",
      "ind_debut = 0\n",
      "ind_fin = 1\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : l\n",
      "ind_debut = 0\n",
      "ind_fin = 2\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : le\n",
      "ind_debut = 0\n",
      "ind_fin = 3\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les\n",
      "ind_debut = 0\n",
      "ind_fin = 4\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les \n",
      "ind_debut = 0\n",
      "ind_fin = 5\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les m\n",
      "ind_debut = 0\n",
      "ind_fin = 6\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mo\n",
      "ind_debut = 0\n",
      "ind_fin = 7\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mot\n",
      "ind_debut = 0\n",
      "ind_fin = 8\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mots\n",
      "ind_debut = 0\n",
      "ind_fin = 9\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mots \n",
      "ind_debut = 0\n",
      "ind_fin = 10\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mots d\n",
      "ind_debut = 0\n",
      "ind_fin = 11\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mots de\n",
      "ind_debut = 0\n",
      "ind_fin = 12\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mots de \n",
      "ind_debut = 0\n",
      "ind_fin = 13\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mots de c\n",
      "ind_debut = 0\n",
      "ind_fin = 14\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mots de ce\n",
      "ind_debut = 0\n",
      "ind_fin = 15\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mots de cet\n",
      "ind_debut = 0\n",
      "ind_fin = 16\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mots de cett\n",
      "ind_debut = 0\n",
      "ind_fin = 17\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mots de cette\n",
      "ind_debut = 0\n",
      "ind_fin = 18\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mots de cette \n",
      "ind_debut = 0\n",
      "ind_fin = 19\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mots de cette p\n",
      "ind_debut = 0\n",
      "ind_fin = 20\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mots de cette ph\n",
      "ind_debut = 0\n",
      "ind_fin = 21\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mots de cette phr\n",
      "ind_debut = 0\n",
      "ind_fin = 22\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mots de cette phra\n",
      "ind_debut = 0\n",
      "ind_fin = 23\n",
      "Résultat courant []\n",
      "Sous-chaîne considérée à l'itération courante : les mots de cette phras\n"
     ]
    }
   ],
   "source": [
    "# Jeu de tests\n",
    "assert separation('un.deux.trois.quatre', '.') == ['un', 'deux', 'trois', 'quatre']\n",
    "assert separation('les mots de cette phrase', ' ') == ['les', 'mots', 'de', 'cette', 'phrase']\n",
    "assert separation('les mots de cette phrase', '.') == ['les mots de cette phrase']\n",
    "assert separation('', '+') == []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['un', 'deux', 'trois', 'quatre']"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'un.deux.trois.quatre'.split('.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## N-uplets et listes avancées : (équivalent au Cours/TD/TME 7)\n",
    "\n",
    "#### Rappels et éléments importants : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Tuple, List  # Important pour votre code et vos specs\n",
    "\n",
    "Produit = Tuple[str, str, List[int]]\n",
    "\n",
    "Base_Produits : List[Produit]\n",
    "\n",
    "Base_Produits = [(\"chanel\", \"no5\", [110, 120, 150]),\n",
    "                (\"Yves_Saint_Laurent\", \"Opium\", [80, 90, 110, 120]),\n",
    "                (\"Paco\", \"trucmuche\", [120, 150, 210, 250])]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('chanel', 'no5', [110, 120, 150]),\n",
       " ('Yves_Saint_Laurent', 'Opium', [80, 90, 110, 120]),\n",
       " ('Paco', 'trucmuche', [120, 150, 210, 250]),\n",
       " 'dsad']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Base_Produits + [(\"dsad\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('chanel', 'no5', [110, 120, 150]),\n",
       " ('Yves_Saint_Laurent', 'Opium', [80, 90, 110, 120]),\n",
       " ('Paco', 'trucmuche', [120, 150, 210, 250])]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Base_Produits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Notion importante la mutabilité/immutabilité\n",
    "Base_Produits = Base_Produits + [(\"Givenchi\", \"Truc\", [100, 120, 150, 160])]  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('chanel', 'no5', [110, 120, 150]),\n",
       " ('Yves_Saint_Laurent', 'Opium', [80, 90, 110, 120]),\n",
       " ('Paco', 'trucmuche', [120, 150, 210, 250]),\n",
       " ('Givenchi', 'Truc', [100, 120, 150, 160])]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Base_Produits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Givenchi\n",
      "Truc\n",
      "[100, 120, 150, 160]\n"
     ]
    }
   ],
   "source": [
    "marque : str\n",
    "nom : str\n",
    "    \n",
    "marque, nom, liste = Base_Produits[-1]\n",
    "print(marque)\n",
    "print(nom)\n",
    "print(liste)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.3.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def chargement_fichier(nom_fichier : str) -> List[str]:\n",
    "    \"\"\"Précondition : nom_fichier est le nom d'un fichier texte existant\n",
    "    Retourne le contenu du fichier texte identifié par nom_fichier\n",
    "    sous la forme d'une liste de lignes de texte.\n",
    "    \"\"\"\n",
    "    # Lignes contenues dans le fichier\n",
    "    l1 : list[str] = []\n",
    "    # Lignes sans retour charriot\n",
    "    l2 : list[str] = []\n",
    "    with open(nom_fichier, 'r') as f: # 'r' pour read (lecture)\n",
    "        l1 = f.readlines() # opération de lecture de lignes\n",
    "    # suppression des retours charriots\n",
    "    ligne : str\n",
    "    for ligne in l1:\n",
    "        if ligne != '' and ligne[-1] == '\\n':\n",
    "            l2.append(ligne[:-1])\n",
    "        else:\n",
    "            l2.append(ligne)\n",
    "    return l2\n",
    "\n",
    "def sauvegarde_fichier(nom_fichier : str, Contenu : List[str]) -> None:\n",
    "    \"\"\"Précondition : nom_fichier est un nom correct de fichier\n",
    "    Sauvegarde le Contenu comme lignes de texte dans le\n",
    "    fichier identifié par nom_fichier\n",
    "    Attention : si le fichier existe déjà son contenu sera\n",
    "    effacé.\n",
    "    \"\"\"\n",
    "    with open(nom_fichier, 'w') as f: # 'w' pour write (écriture)\n",
    "        ligne : str\n",
    "        for ligne in Contenu:\n",
    "            f.write(ligne) # écriture de la ligne\n",
    "            f.write('\\n') # ajout d'un retour charriot\n",
    "    return None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.3.1.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.3.1.1.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.3.2.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decoupage_mots(phrase : str) -> List[str]:\n",
    "    \"\"\"Précondition : phrase est composée de mots séparés par des espaces. Cette phrase peut être vide.\n",
    "    Renvoie la liste des mots de la phrase.\n",
    "    \"\"\"\n",
    "    lmot : List[str] = [] # liste résultat\n",
    "    mot : str = \"\"  # partie du mot que j'éxamine\n",
    "    curr_car : str # caractère courant dans mon for\n",
    "    for curr_car in phrase:\n",
    "        if curr_car == ' ':\n",
    "            if mot != \"\":\n",
    "                lmot.append(mot)\n",
    "                mot = \"\"\n",
    "        else:\n",
    "            mot = mot + curr_car\n",
    "    if mot != \"\":\n",
    "        lmot.append(mot)\n",
    "    return lmot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert decoupage_mots(\"Dans un monde\") == [\"Dans\", \"un\", \"monde\"]\n",
    "assert decoupage_mots(\"Bonjour       Hello    \") == [\"Bonjour\", \"Hello\"]\n",
    "assert decoupage_mots(\"\") == []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.3.3.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.3.3.1.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "220"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(\"220\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lecture_produit(ligne : str) -> Tuple[str, int, float]:\n",
    "    \"\"\"Précondition : la ligne de texte décrit une commande de produit.\n",
    "    Renvoie la commande produit (nom, quantité, prix unitaire).\n",
    "    \"\"\"\n",
    "    lmot : List[str] = decoupage_mots(ligne)\n",
    "    nom : str = lmot[0]\n",
    "    quantite : int = int(lmot[1])\n",
    "    prix_uni : float = float(lmot[2])\n",
    "    return (nom, quantite, prix_uni)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lait\n",
      "<class 'str'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "nom, qte, prix = decoupage_mots(\"Lait 12 2.0\")\n",
    "print(nom)\n",
    "print(type(qte))\n",
    "print(type(prix))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert lecture_produit(\"Lait 12 2.0\") == ('Lait', 12, 2.0)\n",
    "assert lecture_produit(\"Tomate 6   1.5\") == ('Tomate', 6, 1.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.3.4.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Lait', 12, 2.0), ('Thé', 8, 4.5), ('Tomate', 6, 1.5), ('Fromage', 9, 8.5)]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def lecture_commande(commande : List[str]) -> List[Tuple[str, int, float]]:\n",
    "    \"\"\"Précondition : la commande est dans le bon format\n",
    "    Renvoie la liste des produits commandés.\n",
    "    \"\"\"\n",
    "    lproduits : List[Tuple[str, int, float]] = [] # Liste résultat\n",
    "    commmand_curr : str\n",
    "    for commmand_curr in commande:\n",
    "        lproduits.append(lecture_produit(commmand_curr))\n",
    "    \n",
    "    return lproduits\n",
    "\n",
    "lecture_commande([\"Lait 12 2.0\", \"Thé 8 4.5\", \"Tomate 6 1.5\", \"Fromage 9 8.5\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.3.5.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.3.5.2.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_facture(lproduit : List[Tuple[str, int, float]]) -> List[str]:\n",
    "    \"\"\"Précondition : lproduits est une liste de produits commandés.\n",
    "    Renvoie une facture éditée sous la forme d'une liste\n",
    "    de lignes de texte.\n",
    "    \"\"\"\n",
    "    lfacture : List[str] = [\"Produit  Prix\",\n",
    "                            \"-------  ----\"]\n",
    "    total_HT : float = 0.0\n",
    "    \n",
    "    nom: str\n",
    "    qte : int\n",
    "    prix : float\n",
    "    for (nom, qte, prix) in lproduit:  # équivalent à nom,qte,prix = tuple_courant\n",
    "        lfacture.append(nom + \"  \" + str(qte*prix))\n",
    "        total_HT = total_HT + qte*prix\n",
    "    lfacture.append('')\n",
    "    lfacture.append(\"Total_HT    \" + str(total_HT))\n",
    "    lfacture.append(\"TVA_20%     \" + str(total_HT * 0.2))\n",
    "    lfacture.append(\"Total_TTC   \" + str(total_HT + total_HT * 0.2))\n",
    "    return lfacture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.3.5f.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.5.1.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert vecteur((1, 1), (2, 2)) == (1, 1)\n",
    "assert vecteur ((1, 0), (3, 1)) == (2, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.5.2.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert alignes((0,0), (1,1), (5,5)) == True\n",
    "assert alignes((0,0), (1,1), (1,2)) == False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.5.3.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert alignement([(0, 0), (1, 1), (5, 5)]) == True\n",
    "assert alignement([(0, 0), (1, 1), (5, 5), (2, 2), (10, 10)]) == True\n",
    "assert alignement([(0, 0), (1, 1), (5, 5), (1, 0)]) == False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.6.1.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Tuple\n",
    "Etudiant = Tuple[str, str, int, List[int]]\n",
    "BaseUPMC : List[Etudiant]\n",
    "BaseUPMC = [('GARGA', 'Amel', 20231343, [12, 8, 11, 17, 9]),\n",
    "            ('POLO', 'Marcello', 20342241, [9, 11, 19, 3]),\n",
    "            ('AMANGEAI', 'Hildegard', 20244229, [15, 11, 7, 14, 12]),\n",
    "            ('DENT', 'Arthur', 42424242, [8, 4, 9, 4, 12, 5]),\n",
    "            ('ALEZE', 'Blaise', 30012024, [17, 15, 20, 14, 18, 16, 20]),\n",
    "            ('D2', 'R2', 10100101, [10, 10, 10, 10, 10, 10])]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.6.1.1.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def note_moyenne(notes : List[int]) -> float:\n",
    "    \"\"\"Retourne la moyenne des notes de la liste Notes.\n",
    "    \"\"\"\n",
    "    somme : int = 0\n",
    "    if len(notes) == 0:\n",
    "        return 0.0\n",
    "    note_curr : int\n",
    "    for note_curr in notes:\n",
    "        somme = somme + note_curr\n",
    "    \n",
    "    return somme/len(notes) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([12, 8, 14, 6, 5, 15])  # PAS LE DROIT (NEVER EN LU1IN001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert note_moyenne([12, 8, 14, 6, 5, 15]) == 10.0\n",
    "assert note_moyenne([]) == 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.6.2.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.6.3.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def moyenne_generale(db : List[Etudiant]) -> float:\n",
    "    \"\"\"Retourne la moyenne générale des étudiants de la\n",
    "    base bd.\n",
    "    \"\"\"\n",
    "    somme_moyennes_etudiants :float = 0.0\n",
    "    if len(db) == 0:\n",
    "        return 0.0\n",
    "    nom : str\n",
    "    prenom : str\n",
    "    num_etud : int\n",
    "    listnotes : List[int]\n",
    "    for (nom, prenom, num_etud, listnotes) in db:\n",
    "        somme_moyennes_etudiants = somme_moyennes_etudiants + note_moyenne(listnotes)\n",
    "        \n",
    "    return somme_moyennes_etudiants/len(db)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.307142857142857"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "moyenne_generale(BaseUPMC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.6.3.1.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 3 : \n",
    "\n",
    "def top_etudiant(db : List[Etudiant]) -> Tuple[str, str]:\n",
    "    \"\"\"Précondition : len(bd) > 0\n",
    "    retourne un étudiant de la base bd avec la meilleure\n",
    "    moyenne. Si des étudiants sont ex-aequo alors on\n",
    "    retourne le premier dans l'ordre séquentiel de la liste.\"\"\"\n",
    "    \n",
    "    moyenne_max = -1.0\n",
    "    nom_top = \"\"\n",
    "    prenom_top = \"\"\n",
    "    \n",
    "    nom : str\n",
    "    prenom : str\n",
    "    num_etud : int\n",
    "    lnotes : List[int]\n",
    "    for (nom, prenom, num_etud, lnotes) in db:\n",
    "        if note_moyenne(lnotes) > moyenne_max:\n",
    "            moyenne_max = note_moyenne(lnotes)\n",
    "            nom_top = nom\n",
    "            prenom_top = prenom\n",
    "    \n",
    "    return (nom_top, prenom_top)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('ALEZE', 'Blaise')"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "top_etudiant(BaseUPMC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.6.4.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/7.6.4.1.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Optional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def recherche_moyenne(num_etu : int, db : List[Etudiant]) -> Optional[float]:\n",
    "    \"\"\"Retourne la moyenne de l'étudiant portant le numéro rnum ou None\n",
    "    si le numéro est absent de la base. En cas de doublon le\n",
    "    premier enregistrement trouvé est retourné.\n",
    "    \"\"\"\n",
    "    for (nom, prenom, num_etudiant, lnotes) in db:\n",
    "        if num_etu == num_etudiant:  #BINGO\n",
    "            return note_moyenne(lnotes)\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "# BaseUPMC : List[Etudiant] (cf. ci-dessus)\n",
    "assert recherche_moyenne(20244229, BaseUPMC) == 11.8\n",
    "assert recherche_moyenne(20342241, BaseUPMC) == 10.5\n",
    "assert recherche_moyenne(2024129111, BaseUPMC) == None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "---\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "97"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'x'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(120)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'b'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(((ord('z') - ord('a') + 2) % 26) + ord('a'))  # formule générique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def code_lettre(l : str, k : int) -> str:\n",
    "    \"\"\" Precondition : len(l) == 1\n",
    "    Retourne la n-ieme lettre suivante modulo 26\"\"\"\n",
    "    return chr(((ord(l) - ord('a') + k) % 26) + ord('a'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def chiffre_phrase(phrase : str, k : int) -> str:\n",
    "    \"\"\"\n",
    "    Retourne une nouvelle chaîne dans laquelle on remplace chacune  des  lettres  \n",
    "    par  la  n-iemesuivante de fa ̧con circulaire sur l’alphabet\"\"\"\n",
    "    phrase_chiff : str = \"\"  # stocker le résultat\n",
    "    curr_char : str          # caractère courant (utile pour notre for)\n",
    "    for curr_char in phrase:\n",
    "        phrase_chiff = phrase_chiff + code_lettre(curr_char, k)\n",
    "    return phrase_chiff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'psmhpaaylzilhbjlqvby'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chiffre_phrase(\"ilfaittresbeaucejour\",7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ilfaittresbeaucejour'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chiffre_phrase(\"ilfaittresbeaucejour\",26)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ucnwvecxcdkgp'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chiffre_phrase(\"salutcavabien\", 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ilfaittresbeaucejour'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chiffre_phrase('psmhpaaylzilhbjlqvby', -7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 7.7 : Correction détaillée\n",
    "\n",
    "Lien de la vidéo "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://youtu.be/NfIFGnYCQb8?t=4556"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rappel court sur les compréhensions de listes :\n",
    "L = [i for i in range(1,10)]\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('GARGA', 'Amel', 20231343, [12, 8, 11, 17, 9]),\n",
       " ('POLO', 'Marcello', 20342241, [9, 11, 19, 3]),\n",
       " ('AMANGEAI', 'Hildegard', 20244229, [15, 11, 7, 14, 12]),\n",
       " ('DENT', 'Arthur', 42424242, [8, 4, 9, 4, 12, 5]),\n",
       " ('ALEZE', 'Blaise', 30012024, [17, 15, 20, 14, 18, 16, 20]),\n",
       " ('D2', 'R2', 10100101, [10, 10, 10, 10, 10, 10])]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BaseUPMC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['GARGA', 'POLO', 'AMANGEAI', 'DENT', 'ALEZE', 'D2']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L2 = [nom for (nom, prenom, num_etu, notes) in BaseUPMC]\n",
    "L2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/8.1.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def moyenne(maL : List[int]) -> float:\n",
    "    \"\"\"Precondition : len(maL) > 0\n",
    "    Retourne la moyenne de la liste maL\"\"\"\n",
    "    somme : int = 0 # variable temporaire pour stocker la somme de maL\n",
    "    for e in maL:\n",
    "        somme = somme + e\n",
    "    return somme / len(maL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert moyenne([10,10,10]) == 10.0\n",
    "assert moyenne([0,10,20]) == 10.0\n",
    "assert moyenne([1,2]) == 3/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/8.2.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ecart_nombre(l : List[float], x : float) -> List[float]:\n",
    "    \"\"\"Retourne la liste de la valeur absolue de la différence avec des nombres de l avec x \n",
    "    en utilisant un compréhension de liste\"\"\"\n",
    "    return [abs(i-x) for i in l]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert ecart_nombre([10,10,10],10) == [0,0,0]\n",
    "assert ecart_nombre([0,10,20],10) == [10,0,10]\n",
    "assert ecart_nombre([1,2],1.5) == [0.5,0.5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/8.3.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def liste_carre(l : List[float]) -> List[float]:\n",
    "    \"\"\"Retourne la liste des carrés des éléments de l (en utilisant une compréhension)\"\"\"\n",
    "    return [n*n for n in l]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert liste_carre([0,0,0]) == [0,0,0]\n",
    "assert liste_carre([10,0,10]) == [100,0,100]\n",
    "assert liste_carre([0.5,0.5]) == [0.25,0.25]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/8.4.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def variance(l : List[float]) -> float:\n",
    "    \"\"\"Retourne la variance de l\"\"\"\n",
    "    L_ecarts_carre : List[float]= liste_carre(ecart_nombre(l, moyenne(l))) # liste des écarts par rapport à la moyenne\n",
    "                                                              # au carrré\n",
    "    return moyenne(L_ecarts_carre)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert variance([10,10,10]) == 0\n",
    "assert variance([0,10,20]) == 200/3\n",
    "assert variance([1,2]) == 0.25"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/8.5.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def variance_bis(l : List[int]) -> float:\n",
    "    \"\"\"Retourne la variance de l de manière plus efficace\"\"\"\n",
    "    moy : float = moyenne(l) # moyenne de la liste l\n",
    "    return moyenne([abs(e-moy)**2 for e in l])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert variance_bis([10,10,10]) == 0\n",
    "assert variance_bis([0,10,20]) == 200/3\n",
    "assert variance_bis([1,2]) == 0.25"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/8.5.1.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>\n",
    "\n",
    "<center>\n",
    "    <img src=\"./pics/8.5.2.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def liste_caracteres(machaine : str) -> List[str]:\n",
    "    \"\"\"Retourne la liste des charactères de machaine\"\"\"\n",
    "    return [e for e in machaine]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert liste_caracteres('les carottes') == ['l', 'e', 's', ' ', 'c', 'a', 'r', 'o','t', 't', 'e', 's']\n",
    "assert liste_caracteres('') == []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/8.5.3.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def chaine_de(liste_char : List[str]) -> str:\n",
    "    \"\"\"Retourne la chaîne de caractères correspondants aux caractères de liste_char\"\"\"\n",
    "    res : str = \"\" # variable résultat\n",
    "    e : str\n",
    "    for e in liste_char:\n",
    "        res = res + e\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert chaine_de(['s','a','l','u','t']) == 'salut'\n",
    "assert chaine_de([]) == ''\n",
    "assert chaine_de(liste_caracteres('les carottes')) == 'les carottes'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/8.5.5.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def num_car(c : str) -> int:\n",
    "    \"\"\"Precondition : len(c) == 1\n",
    "    Retourne le numéro du caractère passé en paramètre\"\"\"\n",
    "    return ord(c) - ord('a')  # ord(c) - 97 marche aussi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert num_car('a') == 0\n",
    "assert num_car('b') == 1\n",
    "assert num_car('z') == 25"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/8.6.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert car_num(0) == 'a'\n",
    "assert car_num(1) == 'b'\n",
    "assert car_num(25) == 'z'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/8.7.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>\n",
    "\n",
    "<center>\n",
    "    <img src=\"./pics/8.7.2.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Partie 3 : Ensemble et Dictionnaires :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('apple', 2), ('orange', 3), ('grapes', 4)])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sales = { 'apple': 2, 'orange': 3, 'grapes': 4 }\n",
    "sales.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/9.5.1.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Sabre Laser': 229.0,\n",
       " 'Mitendo DX': 127.3,\n",
       " 'Coussin Linux': 74.5,\n",
       " 'Slip Goldorak': 29.9,\n",
       " 'Station Nextpresso': 184.6}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{'Sabre Laser': 229.0,\n",
    "'Mitendo DX': 127.30,\n",
    "'Coussin Linux': 74.50,\n",
    "'Slip Goldorak': 29.90,\n",
    "'Station Nextpresso': 184.60}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/9.5.2.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "BasePrix : Dict[str, float]\n",
    "BasePrix = {'Sabre Laser': 229.0,\n",
    "            'Mitendo DX': 127.30,\n",
    "            'Coussin Linux': 74.50,\n",
    "            'Slip Goldorak': 29.90,\n",
    "            'Station Nextpresso': 184.60}\n",
    "assert prix_moyen(BasePrix) == 129.06\n",
    "assert prix_moyen({'pas cher': 10.0}) == 10.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/9.5.3.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>\n",
    "\n",
    "<center>\n",
    "    <img src=\"./pics/9.5.4.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert fourchette_prix(50.0, 200.0, BasePrix) == {'Coussin Linux', 'Mitendo DX', 'Station Nextpresso'}\n",
    "assert fourchette_prix(250.0, 300.0, BasePrix) == set()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/9.5.5.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/9.5.6.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/9.5.7.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "\n",
    "PanierExemple: Dict[str, int]\n",
    "PanierExemple = {'Sabre Laser': 3,\n",
    "'Coussin Linux': 2,\n",
    "'Slip Goldorak': 1}\n",
    "assert tous_disponibles(PanierExemple, BasePrix) == True\n",
    "assert tous_disponibles({'Sabre laser': 3, 'Slip kangourou':9}, BasePrix)== False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/9.5.8.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "\n",
    "assert prix_achats(PanierExemple, BasePrix) == 865.90\n",
    "assert prix_achats({'Slip Goldorak': 5}, BasePrix) == 5 * 29.90"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/9.6.1.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Dict, List, Tuple\n",
    "Dict_Ang_Fra : Dict[str, str]\n",
    "Dict_Ang_Fra = {'the': 'le', 'cat': 'chat','fish': 'poisson', 'catches': 'attrape'}\n",
    "Dict_Fra_Ita : Dict[str, str]\n",
    "Dict_Fra_Ita = {'le': 'il', 'chat': 'gatto','poisson': 'pesce', 'attrape': 'cattura'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def traduction_mot_a_mot(l : List[str], dico : Dict[str,str]) -> List[str]:\n",
    "    \"\"\"Precondition : toutes les chaînes de l sont une clé de dico\n",
    "    Retourne la traduction mot à mot de l à partir de dico.\n",
    "    \"\"\"\n",
    "    # Liste résultat\n",
    "    lres : List[str] = []\n",
    "    m : str\n",
    "    for m in l:\n",
    "        lres.append(dico[m])\n",
    "    return lres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert traduction_mot_a_mot([\"the\", \"cat\", \"catches\", \"the\", \"fish\"],Dict_Ang_Fra) == ['le', 'chat', 'attrape', 'le', 'poisson']\n",
    "assert traduction_mot_a_mot([\"cat\"],Dict_Ang_Fra) == [\"chat\"]\n",
    "assert traduction_mot_a_mot([\"chat\"],Dict_Fra_Ita) == [\"gatto\"]\n",
    "assert traduction_mot_a_mot([],Dict_Ang_Fra) == []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'chien'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-0ba9717b186b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mDict_Fra_Ita\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"chien\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'chien'"
     ]
    }
   ],
   "source": [
    "Dict_Fra_Ita[\"chien\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/9.6.2.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "le\n",
      "chat\n",
      "poisson\n",
      "attrape\n"
     ]
    }
   ],
   "source": [
    "for a in Dict_Fra_Ita:\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "le il\n",
      "chat gatto\n",
      "poisson pesce\n",
      "attrape cattura\n"
     ]
    }
   ],
   "source": [
    "for key,value in Dict_Fra_Ita.items():\n",
    "    print(key,value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dictionnaire_inverse(dico : Dict[str,str]) -> Dict[str,str]:\n",
    "    \"\"\"Précondition : une même valeur n'apparaît pas plusieurs fois dans dico\n",
    "    Retourne le dictionnaire inverse de dico\n",
    "    \"\"\"\n",
    "    dico_inverse : Dict[str,str] = dict()\n",
    "    m : str\n",
    "    for m in dico:\n",
    "        tmp : str = dico[m]\n",
    "        dico_inverse[tmp] = m\n",
    "    return dico_inverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dictionnaire_inverse(dico : Dict[str,str]) -> Dict[str,str]:\n",
    "    \"\"\"Précondition : une même valeur n'apparaît pas plusieurs fois dans dico\n",
    "    Retourne le dictionnaire inverse de dico\n",
    "    \"\"\"\n",
    "    dico_inverse : Dict[str,str] = dict()\n",
    "    m : str\n",
    "    for m in dico:\n",
    "        dico_inverse[dico[m]] = m\n",
    "    return dico_inverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dictionnaire_inverse(dico : Dict[str,str]) -> Dict[str,str]:\n",
    "    \"\"\"Précondition : une même valeur n'apparaît pas plusieurs fois dans dico\n",
    "    Retourne le dictionnaire inverse de dico\n",
    "    \"\"\"\n",
    "    dico_inverse : Dict[str,str] = dict()\n",
    "    return {mot_traduit : m for m,mot_traduit in dico.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert dictionnaire_inverse(Dict_Fra_Ita) == {'pesce': 'poisson', 'il': 'le', 'gatto': 'chat', 'cattura': 'attrape'}\n",
    "assert dictionnaire_inverse(Dict_Ang_Fra) == {'poisson': 'fish', 'le': 'the', 'chat': 'cat', 'attrape': 'catches'}\n",
    "assert traduction_mot_a_mot(traduction_mot_a_mot([\"the\", \"cat\", \"catches\", \"the\", \"fish\"], Dict_Ang_Fra),\n",
    "dictionnaire_inverse(Dict_Ang_Fra)) == [\"the\", \"cat\", \"catches\", \"the\", \"fish\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./pics/9.6.3.png\"\n",
    "         width=\"700\"\n",
    "         heigth=\"700\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def composition_dico(dico1:Dict[str,str],dico2:Dict[str,str])-> Dict[str,str]:\n",
    "    cle:str\n",
    "    dico3:[str,str]=dict()\n",
    "    for cle in dico1:\n",
    "        dico3[cle] = dico2[dico1[cle]]\n",
    "    return dico3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jeu de tests\n",
    "assert composition_dico(Dict_Ang_Fra, Dict_Fra_Ita) == {'fish': 'pesce', 'catches': 'cattura', 'the': 'il', 'cat': 'gatto'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## TUPLES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "mon_tuple = (12,10,\"quinze\",20,[chr(a) for a in range(97,110)],[i for i in range(15,20)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(12,\n",
       " 10,\n",
       " 'quinze',\n",
       " 20,\n",
       " ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm'],\n",
       " [15, 16, 17, 18, 19])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mon_tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "var1 , var2, var3 , var4, var5, var6 = mon_tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm']\n"
     ]
    }
   ],
   "source": [
    "print(var5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--- \n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "BaseTuplesPerso = [(\"Kernizan\", \"alia\", 17,\"anglais\" , [\"Espagne\", \"France\"]),\n",
    "                  (\"Sutha\", \"Ad\", 18, \"Maths\", [\"Allemagne\",\"Suisse\",\"Sri Lanka\",\"Croatie\"]),\n",
    "                  (\"Wijayenthiran\", \"Thiruni\",19,\"maths\",[\"rien\"]),\n",
    "                  (\"akmaz\",\"naz\",19,\"biologie\",[\"Espagne\",\"Grece\"])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "L : List[str] = []\n",
    "for nom,prenom,age,mat_pref,L_pays in BaseTuplesPerso:\n",
    "    L.append(mat_pref)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['anglais', 'Maths', 'maths', 'biologie']"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "L_age_nom : List[Tuple[int,str]] = []\n",
    "\n",
    "for nom,prenom,age,mat_pref,L_pays in BaseTuplesPerso:\n",
    "    L_age_nom.append(tuple(age,nom))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(17, 'Kernizan'), (18, 'Sutha'), (19, 'Wijayenthiran'), (19, 'akmaz')]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L_age_nom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "L_age_nom = [(age,nom) for nom,prenom,age,mat_pref,L_pays in BaseTuplesPerso]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(17, 'Kernizan'), (18, 'Sutha'), (19, 'Wijayenthiran'), (19, 'akmaz')]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L_age_nom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "L_pays_mat_pren = [(L_pays, mat_pref, prenom) for nom,prenom,age,mat_pref,L_pays in BaseTuplesPerso]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(['Espagne', 'France'], 'anglais', 'alia'),\n",
       " (['Allemagne', 'Suisse', 'Sri Lanka', 'Croatie'], 'Maths', 'Ad'),\n",
       " (['rien'], 'maths', 'Thiruni'),\n",
       " (['Espagne', 'Grece'], 'biologie', 'naz')]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L_pays_mat_pren"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.7 64-bit ('base')",
   "language": "python",
   "name": "python37764bitbasef6fd1bea82ee4fe7adc69a0c0d7a90e7"
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}