NSIT_03c_POO_encapsulation .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"width:100%;border-collapse:separate;border:solid 2px;border-radius:14px;\">\n",
    "    <div style=\"display:flex;\">\n",
    "        <div style=\"display:inline;width:5%;\"></div>\n",
    "        <div style=\"display:inline;width:15%;\">NSIT</div>\n",
    "        <div style=\"display:inline;width:15%;\">e03c</div>\n",
    "        <div style=\"display:inline;width:70%;text-align:right;\"><b>Structures de données</b></div>\n",
    "        <div style=\"display:inline;width:5%;\"></div>\n",
    "    </div>\n",
    "    <div  style=\"display: flex;background-color:#EEE\">\n",
    "        <p style=\"width:100%;text-align:center;\">Programmation orientée objet (POO)</p>\n",
    "    </div>\n",
    "    <div  style=\"display: flex;\">\n",
    "        <p style=\"width:100%;text-align:center;\">Encapsulation</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = \"alert alert-success\">\n",
    "    \n",
    "Dans la partie précédente, nous avons vu la définitoin d'une classe. L'instanciation d'objet et l'accès aux attributs et aux méthodes d'un objet.\n",
    "    \n",
    "**Objectifs** \n",
    "- Encapsulation\n",
    "- Accesseurs, mutateurs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = \"alert alert-info\">\n",
    "    \n",
    "**Sommaire :**\n",
    "\n",
    "- <a href=#Intro>Création de classe et manipulation d'attributs</a>  \n",
    "- <a href=#Prive_publique>Attributs privés</a> \n",
    "- <a href=#Encapsulation>Encapsulation</a>    \n",
    "- <a href=#Exercice_1>Premier exercie: Instanciation et manipulation d'attributs</a>  \n",
    "- <a href=#Exercice_2>Second exercice: Modifiacation et création de méthodes</a>    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Intro\"></div>\n",
    "\n",
    "## Création de classe et manipulation d'attributs\n",
    "\n",
    "![MF88](https://github.com/ebuonocore/NSIT_03_POO/blob/master/ticket_metro.png?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Afin de suivre l'évolution du nombre de passagers dans des rames de métro, nous allons créer une classe <b>Rame_metro</b>.  \n",
    "Chaque instance de cette classe désigne une rame (ensemble de wagons) du métro parisien: L'illustration ci-dessus présente une rame du modèle MF88.  \n",
    "\n",
    "<b> Compléter la classe</b>.  \n",
    "Elle doit comporter les attributs suivants:\n",
    "- <b>reference_rame</b>: Nom ou référence de la rame de métro\n",
    "- <b>nb_passagers</b>: Nombre de passagers à un instant donné. (0 par défaut)\n",
    "- <b>nb_passagers_max</b>: Capacité d'accueil maximale (500 par défaut). Même en se poussant, on considère qu'il n'est pas possible de dépasser cette limite.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rame_metro:\n",
    "    def __init__(self, reference_rame, nb_passagers = 0, nb_passagers_max = 500):\n",
    "        self.reference_rame = reference_rame\n",
    "        self.nb_passagers = ...\n",
    "        ... = ...\n",
    "        \n",
    "# Instanciation de trois rames\n",
    "rame_1 = Rame_metro(\"MF88_1\")\n",
    "rame_2 = Rame_metro(\"MF88_2\", 100)\n",
    "rame_3 = Rame_metro(\"MF88_3\", 200, 800)\n",
    "\n",
    "# Affichages\n",
    "print(rame_2.nb_passagers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comment afficher l'attribut 'nb_passagers_max' de 'rame_3'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rame_3.nb_passagers_max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On ajoute maintenant à la classe 'Rame_metro', deux méthodes (à compléter):\n",
    "- <b>depose():</b> Elle prend 'en_moins' pour paramètre.  \n",
    "Il désigne le nombre de passagers qui descendent de la rame.  \n",
    "Biensûr, il ne peut pas rester un nombre négatif de passagers dans le métro.  \n",
    "La fonction renvoie le nombre de passagers qui restent dans la rame.\n",
    "- <b>charge()</b>: Elle prend 'en_plus' pour paramètre.  \n",
    "Il désigne le nombre de passagers qui montent dans la rame sans pouvoir dépasser 'nb_passagers_max'  \n",
    "La fonction renvoie le nombre de passagers qui n'ont pas pu monter dans le métro.\n",
    "\n",
    "La représentation graphique de notre classe doit donner cela:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"width:200px;\">\n",
    "    <tr>\n",
    "        <td style=\"width:200px;background-color:#CCD;text-align:left\">\n",
    "            <big>\n",
    "            <b>Rame_metro</b>\n",
    "            </big>\n",
    "        </td>\n",
    "    </tr> \n",
    "    <tr>\n",
    "        <td style=\"width:200px;background-color:#EEF;text-align:left\">\n",
    "            <big>\n",
    "            <i><u>Attributs :</u></i><br>\n",
    "            reference_rame<br>\n",
    "            nb_passagers<br>\n",
    "            nb_passagers_max<br>\n",
    "            </big>\n",
    "        </td>\n",
    "    </tr> \n",
    "    <tr>\n",
    "        <td style=\"width:200px;background-color:#CCD;text-align:left\">\n",
    "            <big>\n",
    "            <i><u>Méthodes:</u></i><br>\n",
    "            charge()<br>\n",
    "            depose()<br>\n",
    "            </big>\n",
    "        </td>\n",
    "    </tr> \n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rame_metro:\n",
    "    def __init__(self, reference_rame, nb_passagers = 0, nb_passagers_max = 500):\n",
    "        self.reference_rame = reference_rame\n",
    "        self.nb_passagers = nb_passagers\n",
    "        self.nb_passagers_max = nb_passagers_max\n",
    "        \n",
    "    def depose(self, en_moins:int)->int:\n",
    "        \"\"\" Les personnes 'en_moins' descendent du métro\n",
    "            Pre-condition: 'en_moins' ne devrait pas être supérieur au nombre actuel de passagers.\n",
    "            La fonction renvoie le nombre actuel de passagers.\n",
    "        \"\"\"\n",
    "        self.nb_passagers -= en_moins\n",
    "        if self.nb_passagers < 0:\n",
    "            self.nb_passagers = 0\n",
    "        return self.nb_passagers\n",
    "    \n",
    "    def charge(self, en_plus:int)->int:\n",
    "        \"\"\" Les personnes 'en plus' tentent de rentrer dans le métro\n",
    "            Post-condition: 'nb_passagers' ne pourra pas dépasser 'self.nb_passagers_max'\n",
    "            La fonction renvoie le nombre de personnes restées sur le quai\n",
    "        \"\"\"\n",
    "        self.nb_passagers += en_plus\n",
    "        if self.nb_passagers > self.nb_passagers_max : \n",
    "            reste_sur_le_quai = self.nb_passagers - self.nb_passagers_max\n",
    "            self.nb_passagers = self.nb_passagers_max\n",
    "            return ...  # Ces gens n'ont pas pu rentrer.\n",
    "        return ... # Tout le monde est rentré dans le métro. Plus personne sur le quai\n",
    "        \n",
    "# Instanciation d'une rame\n",
    "rame_3 = Rame_metro(\"MF88_3\", 200, 800)\n",
    "\n",
    "# On regarde ce qui se passe si on tente de faire descendre 210 personnes alors qu'il n'y en a que 200 dedans\n",
    "rame_3.depose(...)\n",
    "# Normalement, nous ne devrions pas obtenir un nombre négatif de passagers\n",
    "print(\"On tente de déposer 210 personnes. Il en reste\",rame_3.nb_passagers)\n",
    "# On faire remonter 500 personnes\n",
    "sur_le_premier_quai = rame_3...\n",
    "print(\"500 personnes montent. Il y en a maintenant\",rame_3.nb_passagers,\"dans le métro\")\n",
    "sur_le_second_quai =rame_3...\n",
    "print(\"600 de plus. Il y en a maintenant\",rame_3.nb_passagers,\"dans le métro, et\", sur_le_second_quai,\"sont restés sur le quai\")\n",
    "\n",
    "# Maintenant je change un peu brutalement le nombre de passagers sans passer par la méthode 'charge()''\n",
    "rame_3.nb_passagers = 20000\n",
    "print(\"Il y a maintenant\", rame_3.nb_passagers,\"personnes dans ce métro!\")\n",
    "# Mais cela ne devrait pas pouvoir être possible !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette dernière manipulation devrait pouvoir être interdite.  \n",
    "A aucun moment, le nombre de passagers ne devrait pouvoir dépasser la limite.  \n",
    "Il faudrait imposer le passage par une méthode permettant de contrôler les actions sur les attributs.  \n",
    "\n",
    "<div id=\"Prive_publique\"></div>\n",
    "\n",
    "## Attributs privés\n",
    "\n",
    "Cela peut être résolu en rendant les attributs <b>privés</b>.  \n",
    "En Python, par défaut, tous les attributs sont <b>publiques</b>: c'est-à-dire visibles et modifiables par tout autre objet ou programme extérieur.  \n",
    "Dans certains cas, cela peut devenir dangeureux et provoquer des incohérences (Comme ci-dessus).\n",
    "\n",
    "S'il on veut les rendre <b>privés</b> ,on peut placer un <b>double tiret bas</b> (ou <i>underscrore</i> en anglais) devant le nom de la variable.  \n",
    "Par exemple: '\\__nb_passagers' serait la version privée de l'attribut 'nb_passagers'.  \n",
    "De la même façon, on peut rendre des méthodes privées: Dans le code ci-dessous, on ajoute la méthode '\\__places_libres()'. Elles ne peut être appelée que par l'objet lui-même.    \n",
    "Voila à quoi ressemble alors notre classe avec ce filet de sécurité."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rame_metro2:\n",
    "    def __init__(self, reference_rame, nb_passagers = 0, nb_passagers_max = 500):\n",
    "        self.__reference_rame = reference_rame\n",
    "        self.__nb_passagers = nb_passagers\n",
    "        self.__nb_passagers_max = nb_passagers_max\n",
    "    def depose(self, en_moins:int)->int:\n",
    "        \"\"\" Les personnes 'en_moins' descendent du métro\n",
    "            Pre-condition: 'en_moins' ne devrait pas être supérieur au nombre actuel de passagers.\n",
    "            La fonction renvoie le nombre actuel de passagers.\n",
    "        \"\"\"\n",
    "        self.__nb_passagers -= en_moins\n",
    "        if self.__nb_passagers < 0:\n",
    "            self.__nb_passagers = 0\n",
    "        print(\"il reste\", self.__places_libres(),\"places libres\")\n",
    "        return self.__nb_passagers\n",
    "    \n",
    "    def charge(self, en_plus:int)->int:\n",
    "        \"\"\" Les personnes 'en plus' tentent de rentrer dans le métro\n",
    "            Post-condition: 'nb_passagers' ne pourra pas dépasser 'self.nb_passagers_max'\n",
    "            La fonction renvoie le nombre de personnes restées sur le quai\n",
    "        \"\"\"\n",
    "        self.__nb_passagers += en_plus\n",
    "        if self.__nb_passagers > self.__nb_passagers_max : \n",
    "            reste_sur_le_quai = self.__nb_passagers - self.__nb_passagers_max\n",
    "            self.__nb_passagers = self.__nb_passagers_max\n",
    "            return reste_sur_le_quai  # Ces gens n'ont pas pu rentrer.\n",
    "        return 0 # Tout le monde est rentré dans le métro. Plus personne sur le quai\n",
    "    \n",
    "    def __places_libres(self)->int:\n",
    "        \"\"\" Renvoie la différence entre le nombre de place max et les places prises.\n",
    "        \"\"\"\n",
    "        return self.__nb_passagers_max - self.__nb_passagers\n",
    "        \n",
    "# Instanciation d'une rame\n",
    "rame_3 = Rame_metro2(\"MF88_3\", 200, 800)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jusqu'ici, en apparence rien de nouveau.  \n",
    "En chargeant 100 personnes, il ne reste personne sur le quai (La fonction revoie bien 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rame_3.charge(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si on tente de faire débarquer 50. Tous se passe correctement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rame_3.depose(50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La  méthode 'depose()' renvoie ici 250.  \n",
    "En effet, la rame est instanciée avec 200 passagers auxquels nous avons précédemment ajouté 100 personnes, et nous venons d'en déposer 50.  \n",
    "200 + 100 - 50 =  250  \n",
    "De plus nous voyons que cette méthode fait appel à '\\__places_libres()' et elle affiche qu'il reste 550 places lilbres.  \n",
    "800 - 250 = 550\n",
    "\n",
    "Mais, si on souhaite lancer la méthode '\\__places_libres()' depuis l'extérieur de l'objet, il ne va pas se montrer coopératif:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rame_3.__places_libres()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si maintenant on tente d'interroger la valeur de l'attribut \\__nb_passagers, l'interpréteur se comporte comme si elle n'exitait pas!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rame_3.__nb_passagers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "'depose()' et 'charge()' sont deux méthodes qui, en interne, ont accès aux attributs, et on le droit de les modifier: Ce type de méthode porte le nom de <b>mutateur</b> (ou <b>setters</b> en anglais).  \n",
    "\n",
    "Si l'on souhaite rendre ces attibuts visibles, nous devons créer des méthodes spécifiques qui en interne ont le droit de voir ces valeurs, pour les afficher: On appelle ces méthodes des <b>accesseurs</b> (ou <b>getters</b> en anglais)\n",
    "\n",
    "\n",
    "<div id=\"Encapsulation\"></div>\n",
    "\n",
    "## Encapsulation\n",
    "\n",
    "Voila , finalement, à quoi ressemble un code un peu plus sécurisé de notre classe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rame_ligne_7bis:\n",
    "    def __init__(self, reference_rame, nb_passagers = 0, nb_passagers_max = 500):\n",
    "        self.__reference_rame = reference_rame\n",
    "        self.__nb_passagers = nb_passagers\n",
    "        self.__nb_passagers_max = nb_passagers_max\n",
    "    def depose(self, en_moins:int)->int:\n",
    "        \"\"\" Les personnes 'en_moins' descendent du métro\n",
    "            Pre-condition: 'en_moins' ne devrait pas être supérieur au nombre actuel de passagers.\n",
    "            La fonction renvoie le nombre actuel de passagers.\n",
    "        \"\"\"\n",
    "        self.__nb_passagers -= en_moins\n",
    "        if self.__nb_passagers < 0:\n",
    "            self.__nb_passagers = 0\n",
    "        return self.__nb_passagers\n",
    "    \n",
    "    def charge(self, en_plus:int)->int:\n",
    "        \"\"\" Les personnes 'en plus' tentent de rentrer dans le métro\n",
    "            Post-condition: 'nb_passagers' ne pourra pas dépasser 'self.nb_passagers_max'\n",
    "            La fonction renvoie le nombre de personnes restées sur le quai\n",
    "        \"\"\"\n",
    "        self.__nb_passagers += en_plus\n",
    "        if self.__nb_passagers > self.__nb_passagers_max : \n",
    "            reste_sur_le_quai = self.__nb_passagers - self.__nb_passagers_max\n",
    "            self.__nb_passagers = self.__nb_passagers_max\n",
    "            return reste_sur_le_quai  # Ces gens n'ont pas pu rentrer.\n",
    "        return 0 # Tout le monde est rentré dans le métro. Plus personne sur le quai\n",
    "    \n",
    "    def get_nb_passagers(self)->int:\n",
    "        \"\"\" Accesseur de l'attribut privé __nb_passagers\n",
    "        \"\"\"\n",
    "        return self.__nb_passagers\n",
    "    \n",
    "    def get_nb_passagers_max(self)->int:\n",
    "        \"\"\" Accesseur de l'attribut privé __nb_passagers_max\n",
    "        \"\"\"\n",
    "        return self.__nb_passagers_max\n",
    "        \n",
    "# Instanciation d'une rame\n",
    "rame_3 = Rame_ligne_7bis(\"MF88_3\", 200, 800)\n",
    "\n",
    "# On regarde ce qui se passe si on tente de faire descendre 210 personnes alors qu'il n'y en a que 200 dedans\n",
    "rame_3.depose(210)\n",
    "# Normalement, nous ne devrions pas obtenir un nombre négatif de passagers\n",
    "print(\"On tente de déposer 210 personnes. Il en reste\",rame_3.get_nb_passagers())\n",
    "# On faire remonter 500 personnes\n",
    "sur_le_premier_quai = rame_3.charge(500)\n",
    "print(\"500 personnes montent. Il y en a maintenant\",rame_3.get_nb_passagers(),\"dans le métro\")\n",
    "# Puis 600 personnes de plus se présentent sur le quai\n",
    "sur_le_second_quai =rame_3.charge(600)\n",
    "print(\"600 de plus. Il y en a maintenant\",rame_3.get_nb_passagers(),\n",
    "      \"dans le métro, et\", sur_le_second_quai,\"sont restés sur le quai\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voilà!  \n",
    "Les <b>accesseurs</b> me permettent de voir certains attributs, mais je ne peux plus les modifier sans passer par les <b>mutateurs</b>.\n",
    "\n",
    "Cette protection illustre le principe d'<b>encapsulation</b>:  \n",
    "Nos données sont bien empactées dans une capsule protectrice.\n",
    "\n",
    "Dans notre cas, je peux être certain que le nombre de passagers sera maîtrisé, et, toujours compris en 0 et '\\__nb_passagers_max'.  \n",
    "\n",
    "Si l'on compare les représentations graphiques des deux classes, la nuances est subtile, mais on voit bien apparaitre le double tiret bas (\\__) devant les attributs et la méthode privés. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"width:100%\">\n",
    "    <div style=\"display:inline-flex;width:49%\">\n",
    "        <table style=\"width:200px;\">\n",
    "            <tr>\n",
    "                <td style=\"width:200px;background-color:#CCD;text-align:left\">\n",
    "                    <big>\n",
    "                    <b>Rame_metro</b>\n",
    "                    </big>\n",
    "                </td>\n",
    "            </tr> \n",
    "            <tr>\n",
    "                <td style=\"width:200px;background-color:#EEF;text-align:left\">\n",
    "                    <big>\n",
    "                    <i><u>Attributs :</u></i><br>\n",
    "                    reference_rame<br>\n",
    "                    nb_passagers<br>\n",
    "                    nb_passagers_max<br>\n",
    "                    </big>\n",
    "                </td>\n",
    "            </tr> \n",
    "            <tr>\n",
    "                <td style=\"width:200px;background-color:#CCD;text-align:left\">\n",
    "                    <big>\n",
    "                    <i><u>Méthodes:</u></i><br>\n",
    "                    charge()<br>\n",
    "                    depose()<br>\n",
    "                    </big>\n",
    "                </td>\n",
    "            </tr> \n",
    "        </table>\n",
    "    </div>\n",
    "    <div style=\"display:inline-flex;width:49%\">\n",
    "        <table style=\"width:200px\">\n",
    "            <tr>\n",
    "                <td style=\"width:200px;background-color:#CCD;text-align:left\">\n",
    "                    <big>\n",
    "                    <b>Rame_metro2</b>\n",
    "                    </big>\n",
    "                </td>\n",
    "            </tr> \n",
    "            <tr>\n",
    "                <td style=\"width:200px;background-color:#EEF;text-align:left\">\n",
    "                    <big>\n",
    "                    <i><u>Attributs :</u></i><br>\n",
    "                    __reference_rame<br>\n",
    "                    __nb_passagers<br>\n",
    "                    __nb_passagers_max<br>\n",
    "                    </big>\n",
    "                </td>\n",
    "            </tr> \n",
    "            <tr>\n",
    "                <td style=\"width:200px;background-color:#CCD;text-align:left\">\n",
    "                    <big>\n",
    "                    <i><u>Méthodes:</u></i><br>\n",
    "                    charge()<br>\n",
    "                    depose()<br>\n",
    "                    get_nb_passagers()<br>\n",
    "                    get_nb_passagers_max()<br>\n",
    "                    __places_libres()<br>\n",
    "                    </big>\n",
    "                </td>\n",
    "            </tr> \n",
    "        </table>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous remarquez que cela rend un peu plus lourde l'écriture d'une classe.  \n",
    "Cette notion est importante pour le programme de terminale, mais dans la pratique, pour de petits exercices, nous ne le mettrons pas en place systématiquement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Exercice_1\"></div>\n",
    "\n",
    "## Premier exercie: Instanciation et manipulation d'attributs\n",
    "\n",
    "Instanciez l'objet 'rame_4' avec les paramètres par défaut et le nom 'MF88_4'.  \n",
    "Puis, à 8 reprises, 50 personnes desendent(*) et 200 personnes se présentent sur le nouveau quai pour monter.  \n",
    "A chaque étape, affichez le nombre de personnes dans la rame.  \n",
    "\n",
    "(*) S'il n'y a pas 50 personnes dans la rame, la méthode depose() devrait bloquer le nombre de passagers à 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rame_4 = Rame_ligne_7bis(\"MF88_4\")\n",
    "\n",
    "for i in range(8): # La rame se présente sur 8 quais différents.\n",
    "    ... # S'ils existent dans le métro, 50 personnes en descendent.\n",
    "    ... # 120 personnes souhaitent monter.\n",
    "    ... # On affiche le nombre de passagers dans la rame."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Exercice_2\"></div>\n",
    "\n",
    "## Second exercice: Modification et création de méthodes "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous souhaitons créer la classe 'Rame_ligne7bis' afin de suivre le trajet de plusieurs rames sur cette ligne.  \n",
    "Lors de la simulation, deux rames ne doivent jamais être sur le même quai de la même station: Attention à l'accident!  \n",
    "La classe devra contenir les attributs suivants:  \n",
    "- <b>reference_rame</b>: Nom ou référence de la rame de métro.  \n",
    "- <b>__station</b>: Indice de la station où se trouve la rame dans une liste de stations (Attribut privé)  \n",
    "\n",
    "Et elle dispose des méthodes suivantes:   \n",
    "- <b>station_suivante()</b>: Détermine l'indice de la station suivante.  \n",
    "Remarque: La liste des stations est cyclique: Arrivé au dernier élément de la liste, on repart sur l'élément d'indice 0. \n",
    "- <b>avance()</b>: La rame passe à la station suivante."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"width:200px;\">\n",
    "    <tr>\n",
    "        <td style=\"width:200px;background-color:#CCD;text-align:left\">\n",
    "            <big>\n",
    "            <b>Rame_metro</b>\n",
    "            </big>\n",
    "        </td>\n",
    "    </tr> \n",
    "    <tr>\n",
    "        <td style=\"width:200px;background-color:#EEF;text-align:left\">\n",
    "            <big>\n",
    "            <i><u>Attributs :</u></i><br>\n",
    "            reference_rame<br>\n",
    "            __station<br>\n",
    "            </big>\n",
    "        </td>\n",
    "    </tr> \n",
    "    <tr>\n",
    "        <td style=\"width:200px;background-color:#CCD;text-align:left\">\n",
    "            <big>\n",
    "            <i><u>Méthodes:</u></i><br>\n",
    "            station_suivante()<br>\n",
    "            avance()<br>\n",
    "            get_station()<br>\n",
    "            </big>\n",
    "        </td>\n",
    "    </tr> \n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Métro_ligne_7bis](https://github.com/ebuonocore/NSIT_03_POO/blob/master/plan_metro_7bis.png?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans le code ci-dessous, vous pouvez voir que la liste des stations se trouve juste avant le constructeur (\\__init__):  \n",
    "Il s'agit d'un <b>attribut de classe</b>: Cette liste est commune à chaque instance de la classe.  \n",
    "Si il est modifié, il le sera pour tous les autres objets 'Rame_ligne_7bis'.  \n",
    "\n",
    "Par rapport au schéma de la ligne 7bis au dessus, on retrouve à l'indice 0 de la liste 'stations' 'Louis Blanc_1'.  \n",
    "Certaines stations apparaissent suivies d'un nombre '1' ou '2' qui correspond au quai.  \n",
    "Des métros peuvent se croiser dans la même gare, s'ils ne vont pas dans le même sens.  \n",
    "D'autres stations ne peuvent être traversées que dans un sens. Elles n'ont qu'un seul quai ('Danube' par exemple).  \n",
    "\n",
    "En fin de cycle, arrivée à 'Louis Blanc_2', la rame retourne à la station d'indice 0 : Le quai numéro 1 de 'Louis Blanc'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rame_ligne_7bis:\n",
    "    stations = [\"Louis Blanc_1\", \"Jaurès_1\", \"Bolivar_1\", \"Buttes Chaumont_1\", \"Botzaris_1\", \"Place des fêtes\",\n",
    "                \"Pré Saint-Gervais\", \"Danube\", \"Botzaris_2\", \"Buttes Chaumont_2\",\"Bolivar_2\",\n",
    "                \"Jaurès_2\", \"Louis Blanc_2\"]\n",
    "    def __init__(self, reference_rame, station = 0):\n",
    "        \"\"\" reference_rame: Nom ou référence de la rame de métro\n",
    "            station: Indice de la sation dans la liste 'stations'\n",
    "        \"\"\"\n",
    "        self.reference_rame = reference_rame\n",
    "        self.__station = station\n",
    "        \n",
    "    def station_suivante(self, indice_station:list)->int:\n",
    "        \"\"\" Renvoie l'indice de la prochaine station.\n",
    "            Retourne à l'indice 0 si on arrive en fin de liste pour éviter un débordement.\n",
    "        \"\"\"\n",
    "        if indice_station  < len(self.stations) - 1:\n",
    "            return ...\n",
    "        else:\n",
    "            return ...\n",
    "        \n",
    "    def avance(self,liste_rames:list)->bool:\n",
    "        \"\"\" Si l'une des autres rame se trouve sur la prochaine station, notre rame ne peut pas partir.\n",
    "            La sation ne change pas et la fonction renvoie False.\n",
    "            Sinon, la station passe à l'indice suivante et la fonction renvoie True\n",
    "        \"\"\"\n",
    "        for autre_rame in liste_rames:\n",
    "            if autre_rame.get_station() == self.station_suivante(self.__station):\n",
    "                print(\"Ca coince.\")\n",
    "                return False\n",
    "        self.__station = self.station_suivante(self.__station)\n",
    "        return True\n",
    "    \n",
    "    def get_station(self)->int:\n",
    "        \"\"\" Accesseur de l'attribut privé '__station'.\n",
    "        \"\"\"\n",
    "        return ...\n",
    "\n",
    "MF88_1 = Rame_ligne_7bis(\"MF88_1\")\n",
    "MF88_2 = Rame_ligne_7bis(\"MF88_2\")\n",
    "MF88_3 = Rame_ligne_7bis(\"MF88_3\")\n",
    "\n",
    "rames = [ MF88_1, MF88_2, MF88_3]\n",
    "\n",
    "for i in range(30):\n",
    "    for rame in rames: # On tente de faire avancer chaque rame.\n",
    "        rame.avance(rames)\n",
    "    for rame in rames: # On affiche la station de chaque rame sur une ligne\n",
    "        print(...,end=\" \")\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On souhaite maintenant prendre une station de marge en plus pour des raisons de sécurité.  \n",
    "La rame ne peut avancer que si les deux stations suivantes sont libres.  \n",
    "Et pour corser le tout, on fait partir 5 rames de la première station, on en rajoute une sixième puis, plus tard, une septième pour voir si ça rentre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rame_ligne_7bis:\n",
    "    stations = [\"Louis Blanc_1\", \"Jaurès_1\", \"Bolivar_1\", \"Buttes Chaumont_1\", \"Botzaris_1\", \"Place des fêtes\",\n",
    "                \"Pré Saint-Gervais\", \"Danube\", \"Botzaris_2\", \"Buttes Chaumont_2\",\"Bolivar_2\",\n",
    "                \"Jaurès_2\", \"Louis Blanc_2\"]\n",
    "    def __init__(self, reference_rame, station = 0):\n",
    "        \"\"\" reference_rame: Nom ou référence de la rame de métro\n",
    "            station: Indice de la sation dans la liste 'stations'te'\n",
    "        \"\"\"\n",
    "        self.reference_rame = reference_rame\n",
    "        self.__station = station\n",
    "        \n",
    "    def station_suivante(self, indice_station:list)->int:\n",
    "        \"\"\" Renvoie l'indice de la prochaine station.\n",
    "            Retourne à l'indice 0 si on arrive en fin de liste pour éviter un débordement.\n",
    "        \"\"\"\n",
    "        if indice_station  < len(self.stations) - 1:\n",
    "            return indice_station + 1\n",
    "        else:\n",
    "            return 0\n",
    "        \n",
    "    def avance(self,liste_rames:list)->bool:\n",
    "        \"\"\" Si l'une des autres rame se trouve sur la prochaine station, notre rame ne peut pas partir.\n",
    "            La sation ne change pas et la fonction renvoie False.\n",
    "            Sinon, la station passe à l'indice suivante et la fonction renvoie True\n",
    "        \"\"\"\n",
    "        for autre_rame in liste_rames:\n",
    "            if autre_rame.get_station() == self.station_suivante(self.__station):\n",
    "                print(\"Ca coince.\")\n",
    "                return False\n",
    "        for autre_rame in liste_rames:\n",
    "            if autre_rame.get_station() == self.station_suivante(self.station_suivante(self.__station)):\n",
    "                print(\"Ca coince plus loin.\")\n",
    "                return False\n",
    "        self.__station = self.station_suivante(self.__station)\n",
    "        return True\n",
    "    \n",
    "    def get_station(self)->int:\n",
    "        \"\"\" Accesseur de l'attribut privé '__station'.\n",
    "        \"\"\"\n",
    "        return self.__station\n",
    "\n",
    "MF88_1 = Rame_ligne_7bis(\"MF88_1\")\n",
    "MF88_2 = Rame_ligne_7bis(\"MF88_2\")\n",
    "MF88_3 = Rame_ligne_7bis(\"MF88_3\")\n",
    "MF88_4 = ...\n",
    "...\n",
    "\n",
    "rames = [ MF88_1, MF88_2, MF88_3, ... , ... ]\n",
    "\n",
    "for i in range(20):\n",
    "    for rame in rames:\n",
    "        rame.avance(rames)\n",
    "    for rame in rames:\n",
    "        print(rame.get_station(),end=\" \")\n",
    "    print(\"\")\n",
    "\n",
    "# On ajoute une sixième rame en cours de route\n",
    "print(\"MF88_6 arrive sur les rails\")\n",
    "MF88_6 = Rame_ligne_7bis(\"MF88_6\")\n",
    "rames.append(...)\n",
    "\n",
    "for i in range(20):\n",
    "    for rame in rames:\n",
    "        rame.avance(rames)\n",
    "    for rame in rames:\n",
    "        print(rame.get_station(),end=\" \")\n",
    "    print(\"\")\n",
    "    \n",
    "# On ajoute une sixième rame en cours de route\n",
    "print(\"MF88_7 arrive sur les rails\")\n",
    "MF88_7 = Rame_ligne_7bis(\"MF88_7\")\n",
    "rames.append(...)\n",
    "\n",
    "for i in range(20):\n",
    "    for rame in rames:\n",
    "        rame.avance(rames)\n",
    "    for rame in rames:\n",
    "        print(rame.get_station(),end=\" \")\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ce code se répète 3 fois. C'est môche.  \n",
    "Définissez une fonction 'manege()' qui prend en paramètre le nombre d'itérations de la boucle.  \n",
    "Inutile de reprendre le code de la classe qui est en mémoire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<p style=\"font-family:Comic Sans MS; text-align: center; color:gray; font-size: x-small; \">- Eric Buonocore. Septembre 2020 -</p>\n",
    "\n",
    "![Licence CC BY NC SA](https://licensebuttons.net/l/by-nc-sa/3.0/88x31.png)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}