TP5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "830d81ef",
   "metadata": {},
   "source": [
    "# ITC - MPSI\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "774447f3",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "70fc3df654fb3843d26748976bec2db3",
     "grade": false,
     "grade_id": "cell-daaf03a1dd123c4c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "# TP5 : Retour sur les listes\n",
    "Ce TP revient sur les notions vues depuis le début de l'année et les complète. C'est pour vous l'occasion de vous rendre compte si vous les avez bien assimilées. Sinon n'hésitez pas à reprendre les anciens TP."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a4c07e4",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "3ad7389337654335083a870b3e92f92a",
     "grade": false,
     "grade_id": "cell-3599dc12500f711b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exo 1 : Calculatrice\n",
    "Dans cet exercice, il faut implémenter une fonction `calculatrice` qui prend en argument une liste décrivant un calcul à faire entre entiers et qui renvoie le résultat (en supposant, sans avoir à le vérifier, que la liste est admissible).\n",
    "\n",
    "Les listes admissibles et leurs évaluations sont les suivantes :\n",
    "* `[n]`, où `n` est un entier, est une liste admissible; son évaluation est la valeur de `n`<br />\n",
    "exemple : `calculatrice([5])` renvoie 5\n",
    "* `[L1, '+', L2]`, où `L1` et `L2` sont des listes admissibles, est une liste admissible; son évaluation est `e1 + e2`, où `e1` est l'évaluation de `L1` et `e2` celle de `L2`<br />\n",
    "exemples :\n",
    "  * `calculatrice([[5], '+', [-1]])` renvoie 4\n",
    "  * `calculatrice([[3], '+', [[5], '+', [-1]] ])` renvoie 7\n",
    "  \n",
    "* de même pour `[L1, '-', L2]` et `[L1, '*', L2]`\n",
    "* `[L1, '/', L2]`, où `L1` et `L2` sont des listes admissibles, est une liste admissible; son évaluation est `e1 // e2`, où `e1` est l'évaluation de `L1` et `e2` celle de `L2`<br />\n",
    "    exemple : `calculatrice([[3], '/', [[5], '+', [-1]] ])` renvoie 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a86f4f5",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "414f925903a53b9d9a0f666f47a8ce29",
     "grade": false,
     "grade_id": "cell-4fc794c06ac8dcb3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "1. Écrire une fonction `eval` qui prend trois arguments : un nombre, un caractère dont on suppose (sans avoir à le vérifier) que c'est `+`, `-`, `*` ou `/`, et un autre nombre, et renvoie le résultat de l'opération correspondante entre entiers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65986962",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e1cc34e563c275dc63ba3c126bd2035a",
     "grade": false,
     "grade_id": "cell-b569a17d50ad8b35",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfd4732c",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f8a0552832afd91798844c9bdf2c0d78",
     "grade": true,
     "grade_id": "cell-a09344605aa754e2",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert(eval(3, '*', 15) == 45)\n",
    "assert(eval(3, '+', 15) == 18)\n",
    "assert(eval(3, '-', 15) == -12)\n",
    "assert(eval(6, '/', 4) == 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c97ce78",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "3ef96c52ae39fb54d30c4714ff9d3a47",
     "grade": false,
     "grade_id": "cell-a3487c24789ff1c5",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "2. Écrire et documenter la fonction `calculatrice`. Remarquez qu'une liste admissible est soit de longueur 1 et dans ce cas le contenu de cette case fournit immédiatement son évaluation, soit de longueur 3, et dans ce cas il faut évaluer les cases 0 et 2, puis faire la bonne opération entre les deux."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c71f2d69",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "cbb21be40e1234eb5171b6b2cb02108d",
     "grade": false,
     "grade_id": "cell-a7e5ba15c8b50cde",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d43e83e7",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6e82990ac334ad0c88fec6309da668da",
     "grade": true,
     "grade_id": "cell-ddffc9dac4e5de8d",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert(calculatrice([5]) == 5)\n",
    "assert(calculatrice([[5], '+', [-1]]) == 4)\n",
    "assert(calculatrice([[3], '+', [[5], '+', [-1]] ]) == 7)\n",
    "assert(calculatrice([[3], '/', [[5], '+', [-1]] ]) == 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b78b9469",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "6769527bb34fc0d51673d7f73db12bd8",
     "grade": false,
     "grade_id": "cell-5abb53063f43ae45",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Ajout et suppression d'éléments dans une liste\n",
    "Nous avons vu qu'une liste en `python` se note entre crochets : `[1, 2, 3, -4]`. Jusqu'à présent, une fois une liste créée, les seules modifications que nous avons faites sont la modification de la valeur d'une case de cette liste :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51971aa7",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "49382a09c9405f0dc7a128ff06d8d6ac",
     "grade": false,
     "grade_id": "cell-5abb53063f43ae46",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "L = ['a', 'b', 'c', 'd']\n",
    "print(str(L) + '\\t# valeur initiale de L')\n",
    "\n",
    "L[0] = 'z'\n",
    "print(str(L) + '\\t# L après la modification de la case 0')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a606f174",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "265f7398a6d3c27edf2233e8174a1102",
     "grade": false,
     "grade_id": "cell-075901cd80351356",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "En fait, on peut ajouter un élément à la fin d'une liste en utilisant une _méthode_ (le fait de comprendre ce qu'est une méthode et comment en écrire une est hors programme, mais il faut savoir utiliser une méthode qui vous est fournie). Une méthode se comporte comme une fonction, mais la syntaxe pour l'invoquer est différente. Pour ajouter un élément à la fin d'une liste, on utilise la méthode `append` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6974399e",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "db4efaf01436b5e329fd58a5b9667ab7",
     "grade": false,
     "grade_id": "cell-1c8c02ef971cd355",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "L = ['a', 'b', 'c', 'd']\n",
    "\n",
    "print(str(L) + '\\t\\t# valeur initiale de L')\n",
    "\n",
    "L.append(2)  # observezez ici : nom de la liste, caractère point, nom de la méthode, \n",
    "             #                  arguments pour la méthode entre parenthèses\n",
    "    \n",
    "print(str(L) + \"\\t\\t# L apres l'ajout de 2\")\n",
    "\n",
    "L.append('toto')\n",
    "\n",
    "print(str(L) + \"\\t# L apres l'ajout de 'toto'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "900b2696",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a506c8020d34b1f55ea67ddd43cc28c6",
     "grade": false,
     "grade_id": "cell-fbbdc5a805e2ebc3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "On peut aussi suprrimer le dernier élément d'une liste, tout en récupérant sa valeur grâce à la méthode `pop` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e14f3c7",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5857d875eb416c685e15d79f88f9bfde",
     "grade": false,
     "grade_id": "cell-7d5eadc6128d02aa",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "L = ['a', 'b', 'c', 'd']\n",
    "\n",
    "print(str(L) + '\\t# valeur initiale de L')\n",
    "\n",
    "n = L.pop()  # observez ici : il faut des parenthèses même en l'absence d'argument\n",
    "\n",
    "print(n + '\\t\\t\\t# valeur renvoyée par pop')\n",
    "print(str(L) + \"\\t\\t# L après l'appel à pop\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7a648f3",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "1dbef67aafb5a73d34b270c88fc94272",
     "grade": false,
     "grade_id": "cell-17418e221dd2c251",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Attention à ce qui se passe si on essaie de faire un `pop` sur une liste vide :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d5be4a1",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "791ffd4ffdc39595376c2ce3b727a370",
     "grade": false,
     "grade_id": "cell-87fa3d8c5d9996f7",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "[].pop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e0117f1",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "0da08a33375635bb14e37ad35de00e71",
     "grade": false,
     "grade_id": "cell-5328ab4eddaf8f2d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Il faut donc toujours tester si une liste est non vide (par exemple en utilisant la fonction `len` qui donne sa longueur) avant d'essayer de récupérer un élément de la liste.\n",
    "\n",
    "(À noter que les programmeurs `python` ne le font pas comme ça, mais utilise `try... catch` qui est hors programme. Cette remarque est donc là uniquement pour votre culture.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9a0f31a",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "452253030c71d705baee041aa0db4f48",
     "grade": false,
     "grade_id": "cell-78c03a772ffb43a1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Le comportement d'une liste avec les méthodes `append` et `pop` est le comportement d'une _pile_ : on ajoute des éléments et on récupère systématiquement l'élément le plus récent qui appartient à la pile. Cette structure de données est une structure de données classique en informatique et elle apparaît dans de nombreux algorithmes (un exemple d'utilisation à l'exercice 4 ci-dessous).\n",
    "\n",
    "Le vocabulaire associé à ces opérations est _empiler_ quand on ajoute un nouvel élément et _dépiler_ quand on retire l'élément le plus récent de la pile."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e7314d5",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a3e93976459dd3465a6edb9af11ef254",
     "grade": false,
     "grade_id": "cell-cc3e47e09143bf44",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Tester l'appartenance à une liste\n",
    "Vous avez écrit dans un TP une fonction qui teste si un élément appartient à une liste. Cette fonctionnalité est en fait présente nativement en `python`, grâce à l'opérateur `in` : `x in L`, où `x` est une expression (par exemple une valeur ou une variable) et `L` une liste, vaut `True` si et seulement si l'évaluation de `x` est un élément de `L`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63eea3f7",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1c63983b7482b2d2f2f46c53066e8d11",
     "grade": false,
     "grade_id": "cell-6a202649c92afc34",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "'a' in L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "924034a3",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1582758b4a2b3f281989387a1af89422",
     "grade": false,
     "grade_id": "cell-26fac7622d936b12",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "L = [2, 'a']\n",
    "1+1 in L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68ffd980",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "93d8053fc24d4ed5212b3c70e87c0870",
     "grade": false,
     "grade_id": "cell-c706df6786164d45",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "'b' in L"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a52fda65",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "204f9ff51b72f3627afc9c23bb8aa9d8",
     "grade": false,
     "grade_id": "cell-3ec53a7458caa242",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exo 2 : Concaténation de listes\n",
    "Écrire et documenter une fonction `concat` qui prend en argument deux listes et modifie la première en lui ajoutant le contenu de la deuxième à la fin (dans l'ordre), en vous servant de la méthode `append`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7fea6586",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "74fd8fe871b4db69d1ac63ae1e0a42dc",
     "grade": false,
     "grade_id": "cell-8009abb96b81614b",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1973dfd2",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "771048faf9335d5dc36738b936921445",
     "grade": true,
     "grade_id": "cell-dca253d7919dfc43",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "L = []\n",
    "concat(L, [1, 4, 7, -2])\n",
    "assert(L == [1, 4, 7, -2])\n",
    "\n",
    "concat(L, [])\n",
    "assert(L == [1, 4, 7, -2])\n",
    "\n",
    "L2 = ['b', 'n']\n",
    "concat(L, L2)\n",
    "assert(L == [1, 4, 7, -2, 'b', 'n'])\n",
    "assert(L2 == ['b', 'n'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d035c3a1",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8f2a85ffce18b5b7d49061e3733afb92",
     "grade": false,
     "grade_id": "cell-fed21f40d15c0cf3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exo 3 : Extraction des consonnes\n",
    "Écrire et documenter une fonction `consonantique` qui prend en argument une liste de chaînes de caractères de longueur 1 qui sont toutes des lettres minuscules sans accents ou des espaces (sans avoir à le vérifier) et renvoie une nouvelle liste de chaînes de caractères de longueur 1 contenant uniquement les consonnes de la liste d'origine (dans le même ordre)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39b80372",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "235608541bde3725beab7ec2d74d2836",
     "grade": false,
     "grade_id": "cell-cd5ad0a4a75f3a86",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b681b469",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "72dbffb110830be5196351590632a995",
     "grade": true,
     "grade_id": "cell-50bb483547b3e1ac",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert(consonantique([]) == [])\n",
    "\n",
    "assert(consonantique(['a']) == [])\n",
    "\n",
    "assert(consonantique(['b']) == ['b'])\n",
    "\n",
    "phrase = list(\"ceci est une phrase pour faire un test\")\n",
    "assert(consonantique(phrase) == ['c', 'c', ' ', 's', 't', ' ', 'n', ' ', 'p', 'h', 'r', 's', ' ', \n",
    "                    'p', 'r', ' ', 'f', 'r', ' ', 'n', ' ', 't', 's', 't'])\n",
    "assert(phrase == list(\"ceci est une phrase pour faire un test\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8375fc07",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "088b1f4c2b9385332eb41f9fdb7532b4",
     "grade": false,
     "grade_id": "cell-dae3550da65c91dd",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exo 4 : Une calculatrice plus sophistiquée\n",
    "On désire maintenant écrire une fonction `calculatrice_scientifique` qui prend en argument une liste représentant une expression supposée bien formée (sans avoir à le vérifier) et renvoie le résultat du calcul entre entiers.\n",
    "\n",
    "Une expression bien formée est composée de la manière suivante :\n",
    "* $n$, où $n$ est un entier, est une expression bien formée, son évaluation est la valeur de $n$<br />\n",
    "exemple : 5 est une expression bien formée, elle s'évalue en $5$\n",
    "* $(e_1 + e_2)$, où $e_1$ et $e_2$ sont des expressions bien formées, est une expression bien formée, elle s'évalue en la somme des évaluations de $e_1$ et $e_2$<br />\n",
    "exemple :\n",
    "  * $(5 + -1)$ est une expression bien formée, elle s'évalue en $4$\n",
    "  * $(3 + (5 + -1))$ est une expression bien formée, elle s'évalue en $7$\n",
    "* de même pour $(e_1 - e_2)$ et $(e_1 * e_2)$\n",
    "* $(e_1 / e_2)$, où $e_1$ et $e_2$ sont des expressions bien formées, est une expression bien formée, elle s'évalue en le quotient entier des évaluations de $e_1$ et $e_2$<br />\n",
    "exemples :\n",
    "  * $(5 / -1)$ est une expression bien formée, elle s'évalue en $-5$\n",
    "  * $(3 / (5 + -1))$ est une expression bien formée, elle s'évalue en $0$\n",
    "\n",
    "À partir d'une expression bien formée, on obtient une liste contenant des entiers et les caractères '(', ')', '+', '-', '*' et '/' assez naturellement.\n",
    "\n",
    "exemples:\n",
    "* `[ -5, '*', '(', 13, '+', '(', 6, '/', '(', 1, '+', 2, ')', ')', ')' ]` est une liste admissible pour la fonction `calculatrice_scientifique`, elle s'évalue en -75 car elle correspond au calcul `-5*(13+(6//(1+2)))` en `python`\n",
    "* `['-', 5]` n'est pas une liste admissible (car on n'autorise pas le `-` unaire`)\n",
    "* `['(', 3, '+', 2 ]` n'est pas une liste admissible (car elle est mal parenthésée)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8b46b75",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "e9d81e66d5d05cc78abf84d917267b04",
     "grade": false,
     "grade_id": "cell-d3d0c3bdc7875f83",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "L'algorithme à suivre pour implémenter une telle calculatrice est le suivant :\n",
    "* si la liste fournie est de longueur 1, on renvoie tout de suite le résultat\n",
    "* on ajoute une parenthèse droite à la liste fournie\n",
    "* on crée une pile vide `operateurs`\n",
    "* on crée une pile vide `nombres`\n",
    "* on parcourt la liste donnée en argument de gauche à droite :\n",
    "  * si le caractère courant est une parenthèse gauche, on l'ignore,\n",
    "  * sinon :\n",
    "    * si c'est un opérateur, on l'empile dans `operateurs`\n",
    "    * si c'est un nombre, on l'empile dans `nombres`\n",
    "    * si c'est une parenthèse droite, on dépile les deux derniers nombres et le dernier opérateur, et on empile le résultat de l'opération correspondante dans `nombres`\n",
    "* on supprime la parenthèse qu'on avait ajoutée à la liste transmise en argument\n",
    "* le résultat attendu est au sommet de la pile `nombres`\n",
    "\n",
    "\n",
    "Écrire la fonction `calculatrice_scientifique` (vous pouvez et même devez s'il y a besoin réutiliser la fonction `eval` de l'exercice 1).\n",
    "\n",
    "N'hésitez pas à faire du pas à pas dans [python tutor](https://pythontutor.com/) pour vous aider."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "547f4dac",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e2ab3088955871e84a3143eda8eb356a",
     "grade": false,
     "grade_id": "cell-df37fc4c5e693bf1",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac462252",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "930543c101f359837991ee9e39ee878c",
     "grade": true,
     "grade_id": "cell-d72806137cbd9e50",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert(calculatrice_scientifique([5]) == 5)\n",
    "\n",
    "L = [-5, '*', '(', 13, '+', '(', 6, '/', '(', 1, '+', 2, ')', ')', ')']\n",
    "L2 = L[:] # pour faire une copie de la liste\n",
    "assert(calculatrice_scientifique(L) == -75)\n",
    "assert(L == L2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc4c1676",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "4768bbe2a4caf2795e85a41d3add474f",
     "grade": false,
     "grade_id": "cell-7d8354bdb9ff8851",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "    <h2>Les points à retenir</h2>\n",
    "    \n",
    "* syntaxe pour utiliser une méthode\n",
    "* méthode `append` pour ajouter un élément à la fin d'une liste\n",
    "* méthode `pop` pour récupérer et supprimer le dernier élément d'une liste non vide\n",
    "* erreur de `pop` si la liste est vide\n",
    "* opérateur `in` pour tester l'appartenance d'un élément à une liste\n",
    "* structure de pile implémentée par une liste / empiler / dépiler\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}