tnsi_Poo_1.ipynb

{
 "metadata": {
  "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-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python37364bit201329ed7ee849b4a43ad7bb610f5989",
   "display_name": "Python 3.7.3 64-bit"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# POO : Programmation Orientée Objet\n",
    "\n",
    "L'objectif final de cette activité est de réaliser une horloge.\n",
    "\n",
    "## 1- La classe Temps :\n",
    "\n",
    "On propose dans un premier temps de créer une classe capable de gérer des données temporelles. On l'appellera la classe **Temps**\n",
    "\n",
    "Un objet instancié sur cette classe aura trois attributs pour représenter :\n",
    "  - les heures : __heures\n",
    "  - les minutes : __minutes\n",
    "  - les secondes : __secondes\n",
    "\n",
    "Ces trois attributs pourront être choisis au moment de l'instanciation (= la création de l'objet) sinon ils prendront chacun la valeur 0 par défaut.\n",
    "\n",
    "**Nous allons en fait créer un nouveau type de données : le type Temps**\n",
    "\n",
    "### 1.1- Constructeur de la classe :\n",
    "\n",
    "La toute première **méthode** à écrire dans la définition d'une classe est celle qui permet d'initialiser l'objet. Elle se note \\__init\\__(self) ou \\__init\\__(self, param1, param2, ...). Elle est nommée le **constructeur** de la classe ; c'est cette méthode qui est appelée dès que l'on crée l'objet\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 1.1.1 : première définition de la classe Temps\n",
    "\n",
    "class Temps:\n",
    "    \"\"\" une classe pour gérer des données temporelles \"\"\"\n",
    "\n",
    "    def __init__(self, hh=0, mm=0, ss=0):\n",
    "        \"\"\" constructeur de la classe Temps. Définit les trois attibuts privés pour gérer les\n",
    "        heures, minutes et secondes\n",
    "        \"\"\"\n",
    "        self.__heures = hh \n",
    "        self.__minutes = mm \n",
    "        self.__secondes = ss \n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#CELLULE 1.1.2\n",
    "# demander le contenu de la classe Temps :\n",
    "???"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 1.1.3\n",
    "# demander de l'aide sur la classe Temps :\n",
    "???"
   ]
  },
  {
   "source": [
    "### 1.2- Création d'objets de type Temps :\n",
    "\n",
    "Dans la cellule ci-dessous, on crée un objet *horaire_1* de type Temps (on dit aussi un objet instancié sur la classe Temps) représentant la donnée horaire 12 heures 45 minutes et 32 secondes.\n",
    "\n",
    "Essayer d'afficher *horaire_1* avec la fonction print() bien connue.\n",
    "\n",
    "Afficher également le *type* de *horaire_1* :"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 1.2 : instanciation d'objets\n",
    "\n",
    "horaire_1 = Temps(12, 45, 32)\n",
    "\n",
    "???\n",
    "...\n",
    "???\n"
   ]
  },
  {
   "source": [
    "...la fonction print appliquée à un objet affiche en fait l'emplacement mémoire auquel se situe l'objet.\n",
    "\n",
    "TEST : créer dans la cellule ci-dessus un deuxième objet *horaire_2* instancié sur la classe Temps et en demander l'affichage avec print. Comparer avec le résultat obtenu pour *horaire_1*\n",
    "\n",
    "### 1.3- Une première méthode pour manipuler l'objet :\n",
    "\n",
    "Pour afficher une chaîne de caractères représentative de notre objet, on va devoir ajouter à la classe une **méthode magique** : \\__str__\n",
    "\n",
    "Dans cette méthode **c'est nous** qui allons définir la façon dont on veut afficher un objet de type Temps.\n",
    "\n",
    "Par exemple on pourrait souhaiter un affichage du type **12 : 45 : 32** ou bien **12H 45M 32S** ou **12h 45min 32 sec** etc...\n",
    "\n",
    "Pour afficher cette chaîne de caractères, on appelera **comme précedemment la fonction print sur notre objet Temps**, mais la présence de la méthode magique \\__str__ va en modifier le comportement"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 1.3.1 : ajout de la méthode __str__ \n",
    "\n",
    "class Temps:\n",
    "    \"\"\" une classe pour gérer des données temporelles \"\"\"\n",
    "\n",
    "    def __init__(self, hh=0, mm=0, ss=0):\n",
    "        \"\"\" constructeur de la classe Temps. Définit les trois attibuts privés pour gérer les\n",
    "        heures, minutes et secondes\n",
    "        \"\"\"\n",
    "        self.__heures = hh \n",
    "        self.__minutes = mm \n",
    "        self.__secondes = ss \n",
    "\n",
    "    def __str__(self):\n",
    "        return str(self.__heures) + ' : ' + str(self.__minutes) + ' : ' + str(self.__secondes)\n",
    "\n",
    "    "
   ]
  },
  {
   "source": [
    " Dans la cellule ci-dessous, instancier deux objets de type Temps : \n",
    "   - l'un avec les attibuts heures, minutes et secondes définis à la création\n",
    "   - le deuxième sans précision de ces attributs. \n",
    "   \n",
    "Demander l'affichage de ces deux objets avec la classique fonction print()"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 1.3.2 : test de la méthode print avec la classe Temps modifiée\n",
    "\n",
    "# !!! LA CELLULE 1.3.1 DOIT ÊTRE EXECUTÉE   AVANT CELLE-CI  sinon la méthode __str__ ne sera pas connue de l'interpréteur !!!\n",
    "#\n",
    "\n",
    "???\n",
    "...\n",
    "???\n"
   ]
  },
  {
   "source": [
    "**A TESTER** : modifier la méthode magique \\__str__(self) de la cellule 1.3.1 pour obtenir un affichage différent des objets de la cellule 1.3.2 (**penser à ré-exécuter** la cellule 1.3.1 avant pour que les modifications soient prises en compte)\n",
    "\n",
    "**AMELIORATION** : il y a un problème de présentation pour une donnée horaire telle que \n",
    "```Python\n",
    "horaire_2 = Temps()\n",
    "```\n",
    "car son affichage donne : **horaire_2 =  0 : 0 : 0** alors qu'il serait préférable d'avoir **horaire_2 =  00 : 00 : 00**\n",
    "\n",
    "On peut résoudre ce problème avec la fonction format (voir  $4.1.2 du chapitre **Langages et Programmation : Découvrir Python en programmant un microcontrôleur** du cours de 1ère).\n",
    "\n",
    "On donne ci-dessous un autre code pour la méthode magique \\__str__ , ce qui va vous permettre de remplacer le code de la méthode \\__str\\__ dans la définition de la classe ( qui se trouve en cellule 1.3.1) et de le tester en réexécutant la cellule 1.3.2"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def __str__(self):\n",
    "    return \"{:02d} : {:02d} : {:02d}\".format(self.__heures, self.__minutes ,self.__secondes)"
   ]
  },
  {
   "source": [
    "### 1.4: Accéder aux attributs de l'objet\n",
    "\n",
    "On a un objet de type Temps, *heure_paris* qui donne l'heure à Paris. \n",
    "On veut créer un nouvel objet *heure_new_york* qui donne l'heure correspondante à New-York (décalage de 6H en moins).\n",
    "On a donc besoin : \n",
    "  - **d'accéder** à l'attribut **\\__heures** de l'objet *heure_paris*, \n",
    "  - de le récupérer, \n",
    "  - de lui soustraire la valeur 6 \n",
    "  - et de passer ce résultat en paramètre lors de la création de l'objet *heure_new_york*.\n",
    "\n",
    "Essayons tout d'abord de récupérer l'attribut \\__heures de l'objet *heure_paris* :\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "error",
     "ename": "AttributeError",
     "evalue": "'Temps' object has no attribute '__heure'",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-2-64a75d8f218c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# CELLULE 1.4.1 : tentative d'accès à un attribut, par exemple pour obtenir l'attribut __heures\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mheure_paris\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mTemps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m12\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m45\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m32\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mheure_paris\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__heure\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Temps' object has no attribute '__heure'"
     ]
    }
   ],
   "source": [
    "# CELLULE 1.4.1 : tentative d'accès à un attribut, par exemple pour obtenir l'attribut __heures\n",
    "heure_paris = Temps(12, 45, 32)\n",
    "print(heure_paris.__heure)"
   ]
  },
  {
   "source": [
    "L'interpréteur nous renvoie une erreur : AttributeError: 'Temps' object has no attribute '__heure' \n",
    "\n",
    "Les attributs de la classe Temps ont été préfixés par deux **underscores : __** ce qui les rend **privés** : ils ne sont **accessibles que de l'intérieur de la classe**, par des méthodes qui y sont définies (on vient de le voir avec la méthode magique \\__str__)\n",
    "\n",
    "Les méthodes permettant d'accéder aux attributs d'un objet sont appelées **les accesseurs**. Il y en a deux types :\n",
    "  - celles qui permettent de **récupérer** un attribut : les **getters** (de l'anglais *to get* : obtenir)\n",
    "  - celles qui permettent de **modifier** un attribut : les **setters** (de l'anglais *to set* : régler, ajuster)\n",
    "\n",
    "L'usage fréquent est de préfixer le nom des getters par **get** et des setters par ... **set**\n",
    "\n",
    "Par exemple ici on pourrait l'appeler get_heures (Remarque : l'utilisation du préfixe anglais *get* incite à choisir un nom complet en anglais comme par exemple get_hours.)\n",
    "\n",
    "Dans le code applicatif, pour récupérer l'attribut \\__heures de l'objet *heure_paris* on utilisera la **notation pointée** :\n",
    "\n",
    "```Python\n",
    "heure_paris.get_heures()\n",
    "```"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 1.4.2 : ajout d'un getter pour obtenir l'attribut __heures\n",
    "\n",
    "class Temps:\n",
    "    \"\"\" une classe pour gérer des données temporelles \"\"\"\n",
    "\n",
    "    def __init__(self, hh=0, mm=0, ss=0):\n",
    "        \"\"\" constructeur de la classe Temps. Définit les trois attibuts privés pour gérer les\n",
    "        heures, minutes et secondes\n",
    "        \"\"\"\n",
    "        self.__heures = hh \n",
    "        self.__minutes = mm \n",
    "        self.__secondes = ss \n",
    "\n",
    "    def get_heures(self):\n",
    "        return self.__heures\n",
    "\n",
    "    def __str__(self):\n",
    "        return \"{:02d} : {:02d} : {:02d}\".format(self.__heures, self.__minutes ,self.__secondes)"
   ]
  },
  {
   "source": [
    "Tester la cellule ci-dessous :"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 1.4.3 : test du getter get_heures :\n",
    "heure_paris = Temps(12, 45, 32)\n",
    "hp = heure_paris.get_heures()\n",
    "print(hp)\n"
   ]
  },
  {
   "source": [
    "Sur le même principe, compléter la cellule 1.4.4 ci-dessous pour y écrire les deux autres méthodes permettant de récupérer les minutes et les secondes :"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 1.4.4 : ajout des getters pour obtenir les attributs __minutes et __secondes :\n",
    "\n",
    "class Temps:\n",
    "    \"\"\" une classe pour gérer des données temporelles \"\"\"\n",
    "\n",
    "    def __init__(self, hh=0, mm=0, ss=0):\n",
    "        \"\"\" constructeur de la classe Temps. Définit les trois attibuts privés pour gérer les\n",
    "        heures, minutes et secondes\n",
    "        \"\"\"\n",
    "        self.__heures = hh \n",
    "        self.__minutes = mm \n",
    "        self.__secondes = ss \n",
    "\n",
    "    def get_heures(self):\n",
    "        return self.__heures\n",
    "\n",
    "   def __str__(self):\n",
    "        return \"{:02d} : {:02d} : {:02d}\".format(self.__heures, self.__minutes ,self.__secondes)"
   ]
  },
  {
   "source": [
    "Ecrire le programme qui permet de créer un objet Temps *heure_new_york* à partir d'un objet Temps *heure_paris* :"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 1.4.5 : \n",
    "heure_paris = Temps(12, 45, 32)    # création de l'objet heure_paris\n",
    "heure_new_york = ???               \n",
    "print(heure_new_york)"
   ]
  },
  {
   "source": [
    "### 1.5- Utilisation et création d'objets à partir d'une fonction.\n",
    "\n",
    "Le code précédent nous permet d'envisager l'écriture d'une fonction :\n",
    "  - prenant en premier paramètre un objet de Type Temps\n",
    "  - prenant en second paramètre un entier représentant un décalage horaire\n",
    "  - renvoyant un **nouvel** objet de type Temps ayant subi le décalage horaire\n",
    "\n",
    "Remarque : cette fonction ne fait pas partie de la classe Temps. Ce n'est pas une **méthode**\n",
    "\n",
    "L'écrire et la tester :"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 1.5 : fonction utilisant des objets de type Temps :\n",
    "\n",
    "def horaire_decale(horaire, decal):\n",
    "    \"\"\" fonction qui permet de recalculer un horaire après décalge horaire\n",
    "    :param horaire: (Temps) une donnée horaire de type Temps\n",
    "    :param decal: (int) le décalage horaire (donné en positif ou en négatif)\n",
    "    :return: (Temps) le nouvel horaire décalé\n",
    "    \"\"\"\n",
    "    return ???\n",
    "\n",
    "heure_paris = Temps(14, 45, 32)\n",
    "heure_new_york = horaire_decale(heure_paris, -6)\n",
    "print(heure_new_york)"
   ]
  },
  {
   "source": [
    "### 1.6- Accéder aux attributs de l'objet : suite\n",
    "\n",
    "Après avoir vu l'utilisation de **getters** pour *récupérer* la valeur d'un attribut, on va s'intéresser aux **setters** pour *modifier* la valeur d'un attribut.\n",
    "\n",
    "En effet il peut être utile de modifier une donnée horaire : par exemple pour régler l'heure d'une horloge\n",
    "\n",
    "On a un objet de type Temps initialisé avec des valeurs particulières pour les trois attributs \\__heures, \\__minutes, \\__secondes.\n",
    "Comment faire pour modifier l'une ou l'autre de ces valeurs ? La réponse : à l'aide de méthodes de type **setters**"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 1.6.1 : ajout des setters pour modifier les attributs __heures, __minutes ou __secondes :\n",
    "\n",
    "class Temps:\n",
    "    \"\"\" une classe pour gérer des données temporelles \"\"\"\n",
    "\n",
    "    def __init__(self, hh=0, mm=0, ss=0):\n",
    "        \"\"\" constructeur de la classe Temps. Définit les trois attibuts privés pour gérer les\n",
    "        heures, minutes et secondes\n",
    "        \"\"\"\n",
    "        self.__heures = hh \n",
    "        self.__minutes = mm \n",
    "        self.__secondes = ss \n",
    "\n",
    "    # !!! Ajouter les getters  !!!\n",
    "\n",
    "\n",
    "\n",
    "    # méthodes à compléter :\n",
    "    \n",
    "    def set_heures(self, heure):\n",
    "        ???\n",
    "    \n",
    "    def set_minutes(self, minute):\n",
    "        ???\n",
    "\n",
    "    def set_secondes(self, seconde):\n",
    "        ???\n",
    "\n",
    "    def __str__(self):\n",
    "        return \"{:02d} : {:02d} : {:02d} \".format(self.__heures, self.__minutes ,self.__secondes)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 1.6.2 : test des setters : modifier successivement les valeurs des différents attributs de l'objet horaire_1 :\n",
    "\n",
    "horaire_1 = Temps(12, 45, 32)\n",
    "\n",
    "# modification de l'attribut __heures (régler l'heure à la valeur 14) :\n",
    "???\n",
    "print(horaire_1)\n",
    "\n",
    "# modification de l'attribut __minutes (régler les minutes la valeur 3 ):\n",
    "???\n",
    "print(horaire_1)\n",
    "\n",
    "# modification de l'attribut __secondes (régler les secondes à la valeur 15) :\n",
    "???\n",
    "print(horaire_1)\n"
   ]
  },
  {
   "source": [
    "### 1.7- Un début d'horloge\n",
    "\n",
    "Le module **time** de Python possède une fonction **sleep()**. Aller voir sa documentation.\n",
    "\n",
    "Compléter le code de la cellule suivante pour réaliser un début de programme affichant une horloge *battant* la seconde.\n",
    "\n",
    "*Remarques* : \n",
    "  - dans ce programme de test, on limite avec une boucle for la durée d'exécution du programme pour qu'il tourne pendant 10 secondes.\n",
    "  - modifier l'objet initial *horloge* en fournissant des valeurs différentes aux attributs (par exemple pour avoir au démmarage l'attribut \\__secondes égal à 55).\n",
    "\n",
    "Quels nouveaux problèmes fait apparaître ce programme de test ?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 1.7 : une horloge rudimentaire\n",
    "import time\n",
    "\n",
    "horloge = Temps(12, 45, 55)\n",
    "print(horloge)\n",
    "for _ in range(10):\n",
    "    ???\n",
    "    ...\n",
    "    ???\n",
    "    "
   ]
  },
  {
   "source": [
    "### 1.8- Gérer les incréments de temps dans un format horaire.\n",
    "\n",
    "On demande ici de répondre au problème soulevé par l'incrément d'une seconde qui peut avoir des répercussions en chaîne :\n",
    "  - \"12 : 45 : 55\" + 1 seconde doit donner \"12 : 45 : 56\"\n",
    "\n",
    "mais:\n",
    "  - \"12 : 45 : 59\" + 1 seconde doit donner \"12 : 46 : 00\"\n",
    "\n",
    "et :\n",
    "  - \"12 : 59 : 59\" + 1 seconde doit donner \"13 : 0 : 0\"\n",
    "  \n",
    "et :\n",
    "  - \"23 : 59 : 59\" + 1 seconde doit donner \"0 : 0 : 0\"\n",
    "\n",
    "Ecrire trois méthodes pour gérer respectivement l'incrément des heures, celui des minutes et celui des secondes"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 1.8.1 : gestion de l'incrémentation des secondes, minutes ou heures\n",
    "\n",
    "class Temps:\n",
    "    \"\"\" une classe pour gérer des données temporelles \"\"\"\n",
    "\n",
    "    def __init__(self, hh=0, mm=0, ss=0):\n",
    "        \"\"\" constructeur de la classe Temps. Définit les trois attibuts privés pour gérer les\n",
    "        heures, minutes et secondes\n",
    "        \"\"\"\n",
    "        self.__heures = hh \n",
    "        self.__minutes = mm \n",
    "        self.__secondes = ss \n",
    "\n",
    "    # !!! Ajouter les getters et setters !!!\n",
    "\n",
    "\n",
    "    # méthodes à compléter :\n",
    "\n",
    "    def incrementer_heures(self):\n",
    "        \"\"\" méthode pour gérer l'incrément des heures\n",
    "        23h + 1 -> 0\n",
    "        \"\"\"\n",
    "        ???\n",
    "        ...\n",
    "        ???\n",
    "\n",
    "    def incrementer_minutes(self):\n",
    "        \"\"\" méthode pour gérer l'incrément des minutes :\n",
    "        59min + 1 -> +1h et 0 min\n",
    "        \"\"\"\n",
    "        ???\n",
    "        ...\n",
    "        ???\n",
    "\n",
    "    def incrementer_secondes(self):\n",
    "        \"\"\" méthode pour incrémenter des secondes\n",
    "        59s + 1 -> +1min et 0 sec\n",
    "        \"\"\"\n",
    "        ???\n",
    "        ...\n",
    "        ???\n",
    "\n",
    "    def __str__(self):\n",
    "        return \"{:02d} : {:02d} : {:02d} \".format(self.__heures, self.__minutes ,self.__secondes)\n"
   ]
  },
  {
   "source": [
    "Reprendre en le modifiant le code de l'horloge rudimentaire de façon à ce que la gestion des incréments temporels donne un affichage convenable :"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 1.8.2 : une horloge rudimentaire...mais qui tourne !\n",
    "import time\n",
    "\n",
    "horloge = Temps(23, 59, 55)\n",
    "print(horloge)\n",
    "for _ in range(10):\n",
    "    ???\n",
    "    ...\n",
    "    ???"
   ]
  },
  {
   "source": [
    "### 1.9- Prolongements...\n",
    "\n",
    "A ce stade on dispose d'une classe Temps qui peut être utilisée dans différents projets. \n",
    "\n",
    "On peut encore l'enrichir avec d'autres méthodes, comme par exemple :\n",
    "  - la possibilité de *décrémenter le temps* (compte à rebours)\n",
    "  - la *conversion* des heures/minutes/secondes en secondes\n",
    "  - ...\n",
    "\n",
    "**Conseils :**\n",
    "  - écrire les **docstrings** pour toutes les méthodes\n",
    "  - faire un help(Temps) et vérifier si l'aide apportée est **bien compréhensible** pour chacune de ces méthodes et rend l'utilisation de ces méthodes aisées **sans avoir besoin de lire leur code source**\n",
    "  - **ne jamais modifier le nom d'une méthode !!!** (les programmes s'appuyant sur cette classe Temps, et écrits avant la modification ne fonctionneraient plus convenablement...)\n",
    "  - **en cas de modification du code d'une méthode**, s'assurer de la **compatibilité avec la version initiale** (là aussi les programmes s'appuyant sur cette classe Temps, et écrits avant la modification ne fonctionneraient plus convenablement...))\n",
    "\n",
    "La suite naturelle de cette étude va nous amener à la conception d'une **horloge dans un programme graphique...**\n",
    "\n",
    "![horloge_numerique.png](images/horloge_numerique.png)\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  }
 ]
}