NSIT_03a_POO.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%;\">e03a</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;\">Initiation</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = \"alert alert-success\">\n",
    "    \n",
    "**Objectifs de la séquence:** \n",
    "- Vocabulaire de la programmation objet : classes, attributs, méthodes, objets.\n",
    "- Écrire la définition d’une classe. Accéder aux attributs et méthodes d’une classe.\n",
    "\n",
    "Remarque: On n’aborde pas ici deux notions clefs de la POO: le polymorphisme et l’héritage."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = \"alert alert-info\">\n",
    "    \n",
    "**Sommaire :**\n",
    "\n",
    "- <a href=#Presentation>La POO: un nouveau paradigme</a>  \n",
    "- <a href=#Objet_reel>Un objet réel: La télécommande</a> \n",
    "- <a href=#Deja_vu>Un air de déjà-vu</a>    \n",
    "- <a href=#Fable>Premier exemple: Un lièvre et une tortue (sans et avec POO)</a>  \n",
    "- <a href=#Tournoi>Tournoi</a>    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Presentation\"></div>\n",
    "\n",
    "## La POO: un nouveau paradigme\n",
    "\n",
    "Jusqu'ici nous avons abordé la programmation de façon <b>impérative</b> (Séquences d'instructions à exécuter).  \n",
    "Nous allons présenter ici une nouvelle façon d'aborder la résolution de problème informatique.  \n",
    "Pour désigner une approche radicalement différente, on parle de <b>paradigme</b>.  \n",
    "\n",
    "La <b>programmation orientée objet</b> consiste à construire de nouveaux types de données.  \n",
    "Les objets sont caractérisés par leurs caractéristiques (<b>attributs</b>) et les actions (<b>méthodes</b>) qu'ils peuvent réaliser.  \n",
    "Les objets sont créés à partir de modèles que l'on appelle <b>classes</b>. \n",
    "\n",
    "<div id=\"Objet_reel\"></div>\n",
    "\n",
    "## Un objet réel: La télécommande\n",
    "\n",
    "Essayons de décrire un objet réel avec ce vocabulaire: La télécommande.  \n",
    "![Objet_telecommande](https://github.com/ebuonocore/NSIT_03_POO/blob/master/telecommande.png?raw=true)\n",
    "<span style=\"font-family:Comic Sans MS; color:gray; font-size: x-small;float:right \">Source: D'après <a href =\"https://pixabay.com/illustrations/remote-control-white-background-4556468/ \">pixabay.com/</a></span> \n",
    "\n",
    "<div style=\"width:100%;\">\n",
    "    <div style=\"display:flex;\">\n",
    "        <div style=\"display:inline;width:50%;\"><br>\n",
    "            Imaginons une description générique de cet objet: <br>\n",
    "            C'est un objet physique qui a des <u>dimensions</u> (longueur, largeur, hauteur), elle dispose d'un certian nombre de <u>boutons</u> et chaque bouton permet de déclencher l'<u>émission d'un signal</u> en direction d'un appareil récepteur.<br><br>\n",
    "            Sur certains modèles une petite lumière rouge permet un retour visuel vers l'utilisateur.<br><br>\n",
    "            Un très grand nombre d'objets peut correspondre à cette description.<br>\n",
    "            Même des télécommandes de portail par exemple.<br>\n",
    "        </div>\n",
    "        <div style=\"display:inline;width:50%;\"><img src=\"https://github.com/ebuonocore/NSIT_03_POO/blob/master/lot_telecommandes-v1.png?raw=true\"></div>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "On représente schématiquement la description d'une classe de la façon suivante:\n",
    "<table style=\"width:600px;\">\n",
    "    <tr>\n",
    "        <td style=\"width:200px;background-color:#FFF\">\n",
    "            <i>Nom de la classe</i>\n",
    "        </td>\n",
    "        <td style=\"width:200px;background-color:#CCD;text-align:left\">\n",
    "            <big>\n",
    "            <b>Telecommande</b>\n",
    "            </big>\n",
    "        </td>\n",
    "        <td style=\"width:200px;background-color:#FFF\">\n",
    "        </td>\n",
    "    </tr> \n",
    "    <tr>\n",
    "        <td style=\"width:200px;background-color:#FFF\">   \n",
    "        </td>\n",
    "        <td style=\"width:200px;background-color:#EEF;text-align:left\">\n",
    "            <big>\n",
    "            <i><u>Attributs :</u></i><br>\n",
    "            dimensions<br>\n",
    "            liste_boutons<br>\n",
    "            liste_signaux_IR<br>\n",
    "            </big>\n",
    "        </td>\n",
    "        <td style=\"width:200px;background-color:#FFF\">\n",
    "        </td>\n",
    "    </tr> \n",
    "    <tr>\n",
    "        <td style=\"width:200px;background-color:#FFF\">\n",
    "        </td>\n",
    "        <td style=\"width:200px;background-color:#CCD;text-align:left\">\n",
    "            <big>\n",
    "            <i><u>Méthodes:</u></i><br>\n",
    "            lire_bouton()<br>\n",
    "            emettre_signal_IR()<br>\n",
    "            allumer_DEL()<br>\n",
    "            eteindre_DEL()<br>\n",
    "            </big>\n",
    "        </td>\n",
    "        <td style=\"width:200px;background-color:#FFF\">\n",
    "        </td>\n",
    "    </tr> \n",
    "</table>\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Toutes nos télécommandes respecteront la strucuture de cette classe.  \n",
    "Pour créer un nouvel objet selon une classe, on parle d'<b>instanciation</b>.    \n",
    "\n",
    "Cette première écriture correspondra à l'instanciation d'une télécommande avec tous les paramètres par défaut.  \n",
    "<code>zapette_salon = Telecommande()</code>  \n",
    "\n",
    "Cette seconde précise, le paramètre 'dimensions' du nouvel objet 'commande_portail'.  \n",
    "<code>commande_portail = Telecommande((5, 3, 1))</code>  \n",
    "\n",
    " \n",
    "  \n",
    "Pour accéder aux attributs des objets on respecte la syntaxe suivante:  \n",
    "<div style=\"width:50%;margin: auto;border-collapse:separate;border:solid 2px;border-radius:14px;\">\n",
    "<center><code>nom_objet.nom_attribut</code></center>\n",
    "</div>\n",
    "\n",
    "Exemples:  \n",
    "<div style=\"width:50%;margin: auto;background-color:#555; color: #FFF;\">\n",
    ">>>zapette_salon.dimensions<br>\n",
    " (15, 5, 2)<br>\n",
    "<br>\n",
    ">>>commande_portail.dimensions<br>\n",
    " (5, 3, 1)<br>\n",
    "</div>\n",
    "\n",
    "  \n",
    "Pour appeler une méthode, la syntaxe est la suivante:  \n",
    "<div style=\"width:50%;margin: auto;border-collapse:separate;border:solid 2px;border-radius:14px;\">\n",
    "<center><code>nom_objet.nom_méthode()</code></center>\n",
    "</div>\n",
    "\n",
    "Exemples:  \n",
    "<div style=\"width:50%;margin: auto;background-color:#555; color: #FFF;\">\n",
    "<i># Allume la DEL de la télécommande 'zapette_salon'<br>\n",
    "    # Et renvoie l'état logique de cette lumière<br></i>\n",
    "    >>>zapette_salon.allumer_DEL()<br>\n",
    "    True<br>\n",
    "<br>\n",
    "    <i># Renvoie l'indice du bouton appuyé sur la 'commande_portail'<br></i>\n",
    ">>>commande_portail.lire_bouton()<br>\n",
    " 1<br>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Deja_vu\"></div>\n",
    "\n",
    "## Un air de déjà-vu\n",
    "\n",
    "En réalité, nous avons déjà croisé la POO et manipulé des objets.  \n",
    "Le type de donnée 'list' par exemple est une classe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_liste = [5, 7, -2]\n",
    "print(type (ma_liste))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En tant qu'instance de la classe 'list', 'ma_liste' dispose des méthodes de cette classe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_liste.sort() # Méthode sort(): Tri les éléments de la liste selon un ordre croissant\n",
    "ma_liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_liste.append(8) # Méthode append(): Ajoute l'élément placé en paramètre\n",
    "ma_liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction 'dir()' permet de lister l'ensemble des méthodes associées à un objet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(ma_liste)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il y a beaucoup de monde!  \n",
    "Mais en fin de liste nous reconnaissons des méthodes connues: append(), count(), index(), sort()..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Fable\"></div>\n",
    "\n",
    "## Premier exemple: Un lièvre et une tortue (sans et avec POO)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Illustration_fable](https://github.com/ebuonocore/NSIT_03_POO/blob/master/fable_tortue_piles.png?raw=true)\n",
    "<span style=\"font-family:Comic Sans MS; color:gray; font-size: x-small;float:right \">Source: D'après <a href =\"https://images8.alphacoders.com/477/477593.png\">alphacoders.com/</a></span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le programme suivant simule la course entre deux athlètes ('lievre' et 'tortue').  \n",
    "Chacun est caractérisé par sa position (initialement 0), sa vitesse (nombre de cases par tour) et le retard (nombre de tours passés à dormir avant de partir).  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arrivee = 50 # Initialisation des variables\n",
    "tour = 0\n",
    "lievre_position = 0 # Caractéristiques de Lièvre\n",
    "lievre_vitesse = 6\n",
    "lievre_retard = 17\n",
    "tortue_position = 0 # Caractéristiques de la Tortue\n",
    "tortue_vitesse = 2\n",
    "tortue_retard = 0\n",
    "\n",
    "# On lance la course\n",
    "while (lievre_position < arrivee and tortue_position < arrivee):  # Tant que personne n'est arrivé\n",
    "    if tour >= lievre_retard: # Le lièvre avance s'il à fini de dormir\n",
    "        lievre_position += lievre_vitesse\n",
    "    if tour >= tortue_retard:\n",
    "        tortue_position += tortue_vitesse\n",
    "    tour += 1 # On passe au tour suivant\n",
    "\n",
    "# Affichage des résultats\n",
    "print(\"Positions finales des participants:\")\n",
    "print(\"Le lièvre :\", lievre_position,\"et la tortue:\", tortue_position)\n",
    "\n",
    "if lievre_position > tortue_position:\n",
    "    print(\"Le lièvre a gagné!\")\n",
    "elif lievre_position < tortue_position:\n",
    "    print(\"La tortue a gagné!\")\n",
    "else: \n",
    "    print(\"Egalité\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant, reprenez ce programme et ajoutez dans la course:  \n",
    "- le renard, qui part au tour 0 avec une vitesse de 4  \n",
    "- et l'escargot qui part aussi au tour 0 avec une vitesse de 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arrivee = 50 # Initialisation des variables\n",
    "tour = 0\n",
    "lievre_position = 0 # Caractéristiques de Lièvre\n",
    "lievre_vitesse = 6\n",
    "lievre_retard = 17\n",
    "tortue_position = 0 # Caractéristiques de la Tortue\n",
    "tortue_vitesse = 2\n",
    "tortue_retard = 0\n",
    "renard_position = ... # Caractéristiques du Renard\n",
    "renard_vitesse = ...\n",
    "renard_retard = ...\n",
    "escargot_position = ... # Caractéristiques de l'Escargot\n",
    "...\n",
    "...\n",
    "\n",
    "# On lance la course\n",
    "while (lievre_position < arrivee and tortue_position < arrivee and ... and ...):\n",
    "    if tour >= lievre_retard:\n",
    "        lievre_position += lievre_vitesse\n",
    "    if tour >= tortue_retard:\n",
    "        tortue_position += tortue_vitesse\n",
    "    if tour >= renard_retard:\n",
    "        renard_position += renard_vitesse\n",
    "    if tour >= escargot_retard:\n",
    "        ...\n",
    "    tour += 1\n",
    "\n",
    "# Affichage des résultats\n",
    "print(\"Positions finales des participants:\")\n",
    "    \n",
    "positions = [lievre_position, tortue_position, renard_position, escargot_position]\n",
    "athletes = [\"Le Lièvre\", \"La Tortue\", \"Le Renard\", \"L'Escargot\"]\n",
    "for i in range(len(athletes)):\n",
    "    print(athletes[i], positions[i])\n",
    "\n",
    "print(\"Et le ganant est ...\", end=\"\")\n",
    "indice_du_gagnant = positions.index(max(positions))\n",
    "print(athletes [indice_du_gagnant])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le programme commence a être long.  \n",
    "Et encore, on ne traite pas bien les cas d'égalité en fin de course.  \n",
    "On se répète beaucoup. Que va-t-il se passer si nous devons rajouter 10 autres participants ?\n",
    "\n",
    "Nous allons plutôt voir comment on peut s'en sortir avec la programmation orientée objet.  \n",
    "Nous allons créer la classe, instancier les objets. Ensuite, nous mettrons en place la résolution de la course."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La vitesse de pointe de l'escargot est 1\n",
      "Le lièvre va dormir pendant 17 tours avant de se réveiller\n"
     ]
    }
   ],
   "source": [
    "# Création de la classe Athlete\n",
    "class Athlete:\n",
    "    # Constructeur\n",
    "    def __init__(self, nom, vitesse, retard = 0, position = 0):\n",
    "        self.nom = nom\n",
    "        self.vitesse = vitesse\n",
    "        self.retard = retard\n",
    "        self.position = position\n",
    "    # Méthodes de la classe\n",
    "    def avance(self,tour):\n",
    "        # Si l'athlète est réveillé, il court: Sa position est incrémentée de la valeur de 'self.vitesse' \n",
    "        # Cette méthode prend l'entier 'tour' en paramètre\n",
    "        if tour > self.retard:\n",
    "            self.position += self.vitesse\n",
    "    def fin(self,arrivee):\n",
    "        # Est-ce que l'athlete a atteint la ligne d'arrivée ?\n",
    "        # Cette méthode a besoin de prendre l'entier 'arrivee' en paramètre\n",
    "        return self.position >= arrivee # S'il a dépassé l'arrivée, la valeur renvoyée est 'True'\n",
    "\n",
    "# Instanciation des objets selon la classe 'Athlete'\n",
    "lievre = Athlete(\"Le lièvre\", 6, 17)\n",
    "tortue = Athlete(\"la tortue\", 2)\n",
    "renard = Athlete(\"Le renard\", 4)\n",
    "escargot = Athlete(\"L'escargot\", 1)\n",
    "\n",
    "print(\"La vitesse de pointe de l'escargot est\", escargot.vitesse)\n",
    "print(\"Le lièvre va dormir pendant\", lievre.retard,\"tours avant de se réveiller\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'écriture de la classe se compose:  \n",
    "- de l'intitulé <code>class Athlete</code>: par convention, le nom de la classe prend une majuscule.\n",
    "- le constructeur <code>def \\__init\\__(self, nom, vitesse, retard = 0, position = 0)</code>\n",
    "- de definition de méthodes <code> def avance(self,tour)</code> et  <code> def fin(self,arrivee)</code>\n",
    "\n",
    "La variable 'self' fait référence à l'objet 'lui-même'.  \n",
    "Dans les lignes suivantes, on instancie par exemple l'objet 'lievre':  \n",
    "<code>lievre = Athlete(\"Le lièvre\", 6, 17)</code>   \n",
    "On voit que seuls 3 paramètres sont renseignés: \"Le lièvre\", 6 et 17.  \n",
    "Il faut les mettre en relation avec la définition du constructeur qui est lancé lors de l'instanciation:\n",
    "\n",
    "![constructeur_et_instanciation](https://github.com/ebuonocore/NSIT_03_POO/blob/master/init_vs_instanciation.png?raw=true)\n",
    " \n",
    "- 'self' fait référence à l'objet 'lievre'. Dans tout le code qui concerne l'instanciaiton de l'objet 'lievre', vous pouvez remplacer 'self' par 'lievre'.  \n",
    "Ainsi, 'self.position' sera compris comme 'lievre.position'  \n",
    "- le premier paramètre \"Le lièvre\" est associé à la variable 'nom'  \n",
    "- 6 est affecté à la variable 'vitesse'\n",
    "- le 17 correspond au retard. Mais s'il n'avait pas été renseigné, il aura pris la valeur par défaut 0.\n",
    "- la variable 'position' n'est pas renseignée: Elle prend donc la valeur par défaut. Ici, 0.\n",
    "\n",
    "En allant au bout de cette idée, on peut imaginer réécrire le constructeur sous cette forme:\n",
    "![paramètres_constructeur](https://github.com/ebuonocore/NSIT_03_POO/blob/master/init_variables.png?raw=true)\n",
    "\n",
    "Tous les attributs de ce nouvel objet sont donc créés et initialisés.  \n",
    "\n",
    "Dans les dernières lignes, on voit comment il est possible d'accéder aux attributs des objets:  \n",
    "<code>print(\"La vitesse de pointe de l'escargot est\", escargot.vitesse)</code>    \n",
    "ici 'escargot.vitesse' désigne l'attribut 'vitesse' de l'objet 'escargot'.  \n",
    "Il renvoie donc la valeur '1'.  \n",
    "\n",
    "On peut compléter le schéma de la classe:"
   ]
  },
  {
   "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>Athlete</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",
    "            nom<br>\n",
    "            vitesse<br>\n",
    "            ...<br>\n",
    "            ...<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",
    "            avance()<br>\n",
    "            ...<br>\n",
    "            </big>\n",
    "        </td>\n",
    "    </tr> \n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arrivee = 50 # Initialisation des variables\n",
    "tour = 0\n",
    "fin_course = False\n",
    "\n",
    "class Athlete:\n",
    "    def __init__(self, nom, vitesse, retard = 0, position = 0):\n",
    "        self.nom = nom\n",
    "        self.vitesse = vitesse\n",
    "        self.retard = retard\n",
    "        self.position = position\n",
    "    def avance(self,tour):\n",
    "        if tour > self.retard:\n",
    "            self.position += self.vitesse\n",
    "    def fin(self,arrivee):\n",
    "        return self.position >= arrivee \n",
    "            \n",
    "lievre = Athlete(\"Le lièvre\", 6, 17)\n",
    "tortue = Athlete(\"la tortue\", 2)\n",
    "renard = Athlete(\"Le renard\", 4)\n",
    "escargot = Athlete(\"L'escargot\", 1)\n",
    "\n",
    "participants = [lievre, tortue, renard, escargot]\n",
    "\n",
    "while fin_course == False: # Tant qu'aucun participant n'est arrivé\n",
    "    for participant in participants:\n",
    "        participant.avance(tour)\n",
    "        fin_course = fin_course or participant.fin(arrivee) # Si ce participant est arrivé, on arrête la course.\n",
    "    tour += 1 # Passe au tour suivant\n",
    "\n",
    "# Affichage des résultats\n",
    "record = 0\n",
    "vainqueur = \"\"\n",
    "for participant in participants:\n",
    "    print(participant.nom, participant.position)\n",
    "    if participant.position > record:\n",
    "        record = participant.position\n",
    "        vainqueur = participant.nom\n",
    "\n",
    "print(\"Le vainqueur est\", vainqueur)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une petite explication s'impose concernant la résolution de la course:  \n",
    "\n",
    "<code>participants = [lievre, tortue, renard, escargot]</code>  \n",
    "Nous avons vu qu'une liste est un objet.  \n",
    "'participants' est donc un objet, constitué d'objets.  \n",
    "On appelle aussi cela un <b>agrégateur</b>.\n",
    "\n",
    "Lorsque nous allons appeler 'participants[2].vitesse' par exemple, nous obtiendrons la valeur de l'attribut 'vitesse' de l'objet 'renard'. Ici, 4.  \n",
    "\n",
    "<code>while fin_course == False:</code> La variable 'fin_course' sert de \"drapeau\" pour suivre l'état de la course.  \n",
    "<code>for participant in participants:</code> L'itérateur 'participant' va désigner à tour de rôle les objets 'lievre', 'tortue' ...  \n",
    "<code>participant.avance(tour)</code> Lorsque 'participant' désigne 'lievre' par exemple au tour 18, cette ligne permet de lancer la méthode avance(18) de l'objet lievre: lievre.avance(18)  \n",
    "<code>fin_course = fin_course or participant.fin(arrivee)</code> participant.fin(arrivee) s'interprète comme lievre.fin(50) dans le cas où participant désigne le 'lievre'. Cette méthode renvoie 'True' s'il a dépassé la case '50'.  \n",
    "Ainsi, la variable 'fin_course' passerait à 'True' et on sortirait de la boucle 'while'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Soyons fous!  \n",
    "On peut rajouter plusieurs participants, le code ne sera pas beaucoup plus compliqué."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arrivee = 50 # Initialisation des variables\n",
    "tour = 0\n",
    "fin_course = False\n",
    "\n",
    "class Athlete:\n",
    "    def __init__(self, nom, vitesse, retard = 0, position = 0):\n",
    "        self.nom = nom\n",
    "        self.vitesse = vitesse\n",
    "        self.retard = retard\n",
    "        self.position = position\n",
    "    def avance(self,tour):\n",
    "        if tour > self.retard:\n",
    "            self.position += self.vitesse\n",
    "    def fin(self,arrivee):\n",
    "        return self.position >= arrivee \n",
    "            \n",
    "lievre = Athlete(\"Le lièvre\", 6, 17)\n",
    "tortue = Athlete(\"la tortue\", 2)\n",
    "renard = Athlete(\"Le renard\", 4)\n",
    "escargot = Athlete(\"L'escargot\", 1)\n",
    "suricate = Athlete(\"Le suricate\", 3)\n",
    "couleuvre = Athlete(\"La couleuvre\", 3, 5)\n",
    "aigle_royal = Athlete(\"L'aigle royal\", 10, 4)\n",
    "panda = Athlete(\"Le panda\", 3, 6)\n",
    "\n",
    "participants = [lievre, tortue, renard, escargot, suricate, couleuvre, aigle_royal, panda]\n",
    "\n",
    "while fin_course == False:\n",
    "    for participant in participants:\n",
    "        participant.avance(tour)\n",
    "        fin_course = fin_course or participant.fin(arrivee)\n",
    "    tour += 1\n",
    "\n",
    "record = 0\n",
    "vainqueur = \"\"\n",
    "for participant in participants:\n",
    "    print(participant.nom, participant.position)\n",
    "    if participant.position > record:\n",
    "        record = participant.position\n",
    "        vainqueur = participant.nom\n",
    "\n",
    "print(\"Le vainqueur est\", vainqueur)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'escargot est un tricheur.  \n",
    "Que faut-il changer dans l'instanciation de ce participant pour le faire débuté la course à la case 42?  \n",
    "Relancez le programme: Qui gagane ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### <div id=\"Tournoi\"></div>\n",
    "\n",
    "## Le tournoi\n",
    "\n",
    "On souhaite créer la classe 'Course' pour gérer déiiférentes rencontres sportives.  \n",
    "Elle a pour attibuts:  \n",
    "- 'reference': La référence de la rencontre (son nom)  \n",
    "- Un booléen 'fin_de_course': pour indiquer si la course est en cours 'True' ou terminée 'False'\n",
    "- participants: la liste des participants (Une liste d'objets 'Athlete')  \n",
    "- positions: La liste des positions des participants (Une liste d'entiers: La position d'indice 1 correspond à la position du participant d'indice 1...)\n",
    "- Le numéro de la case d'arrivée (50 par défaut)\n",
    "Elle dispose d'une méthode course_terminee() qui parcourt la liste des participants: elle renvoie True, si l'un d'eux est arrivé et d'une autre premier() qui désigne l'indice du participant qui a la position la plus élevée (on ne gère pas des cas d'égalité pour simplifier)"
   ]
  },
  {
   "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>Course</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<br>\n",
    "            fin_de_course<br>\n",
    "            participants<br>\n",
    "            positions<br>\n",
    "            arrivee<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",
    "            course_terminee()<br>\n",
    "            premier()<br>\n",
    "            </big>\n",
    "        </td>\n",
    "    </tr> \n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instanciez 2 ou trois courses pour valider votre classe."
   ]
  },
  {
   "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
}