{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Le bloc try except"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons maintenant aborder le concept des exceptions.\n",
    "Une exception est levée par l'interpréteur Python lorsqu'il rencontre une erreur.\n",
    "Le langage Python permet au programmeur de gérer ces exceptions et de pouvoir réagir lorsqu'elles se produisent.\n",
    "Prenons l'exemple suivant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=8\n",
    "y=int(input())\n",
    "z=x/y\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si l'on saisie la valeur 4 pour y, la valeur 2 s'affiche naturellement.\n",
    "En revanche, si l'on saisie la valeur 0 pour y, une exception se déclenche :\n",
    "\n",
    "ZeroDivisionError                         Traceback (most recent call last)\n",
    "<ipython-input-5-e8e3b2ef1769> in <module>()\n",
    "      1 x=8\n",
    "      2 y=input()\n",
    "----> 3 z=x/y\n",
    "      4 print z\n",
    " \n",
    "ZeroDivisionError: integer division or modulo by zero\n",
    "\n",
    "Cette exception est ZeroDivisionError. Lorsqu'elle se déclenche, le programme s'arrête en affichant les informations ci-dessus. Python vous offre alors la possibilité de traiter cette exception, c'est-à-dire de pouvoir effectuer un traitement lorsque cette exception est levée. Ceci s'effectue à l'aide de deux instructions particulières, try et except, de la façon suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=8\n",
    "try:\n",
    "    y=int(input())\n",
    "    z=x/y\n",
    "except ZeroDivisionError:\n",
    "    print(\"tu t'es planté vieux\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans l'exemple précédent, une erreur de saisie (valeur 0 ou une chaîne alphabétique par exemple), provoque la levée d'une exception qui est capturée pour se traduire par l'affichage d'un texte intelligible."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est possible de ne pas spécifiquement réagir à un exception particulière. Dans ce cas, il suffit de créer un bloc except sans nommer d'exception, de la façon suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=8\n",
    "try:\n",
    "    y=int(input())\n",
    "    z=x/y\n",
    "except :\n",
    "    print(\"Erreur survenue\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est également possible de réaliser un traitement fin des exceptions et de réagir à chacun de celle que l'on peut imaginer être levée a priori. Cela se traduit par la création de plusieurs blocs except, chacun consacré à une exception particuière, de la façon suivante :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "try:\n",
    "    bloc de code\n",
    "except Exception1:\n",
    "    code1\n",
    "except Exception 2:\n",
    "    code2\n",
    "..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=8\n",
    "try :\n",
    "   y=int(input())\n",
    "   z=x/y\n",
    "except ZeroDivisionError :\n",
    "    print(\"Zero Error\")\n",
    "except ValueError :\n",
    "    print(\"Value Error\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le code ci-dessus permet de traiter plusieurs types d'exceptions qui peuvent se produire. Testez-le et déclenchez chacune des exceptions. Identifiez le type de l'exception ainsi que l'instruction qui l'a déclenchée."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## L'instruction else"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est également possible d'ajouter une instruction else dans le bloc try, après le traitement des exceptions. Si le code concerné par le bloc try ne produit pas d'erreur, alors, les instructions suivant l'instruction else seront exécutées. A noter qu'il est aussi possible d'insérer ces instructions directement après l'instruction qui est susceptible de lever une exception dans le bloc try. Mais il est cependant plus lisible de ne mettre dans le boc try que les instructions susceptibles de lever des exceptions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=8\n",
    "try : \n",
    "   y=int(input())\n",
    "   z=x/y\n",
    "except ZeroDivisionError :\n",
    "    print (\"Zero Error\")\n",
    "except ValueError :\n",
    "    print (\"Value Error\")\n",
    "else :\n",
    "    print (\"ca gaze\", z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## L'instruction finally"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est possible d'ajouter l'instruction finally dans le bloc try, après les instructions except et else. Que le code du bloc try ait généré ou non une exception, le code suivant l'instruction finally sera exécuté.  Ceci le différentie du code que l'on insère après le bloc try, qui peut ne pas être exécuté du tout si par exemple, il y a une instruction de sortie de programme dans le traitement des exceptions. Le code situé après l'instruction finally, sera lui, exécuté de toutes façons. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=8\n",
    "try :\n",
    "  y=int(input())\n",
    "  z=x/y\n",
    "except ZeroDivisionError :\n",
    "    print(\"Zero Error\")\n",
    "except ValueError :\n",
    "    print(\"Value Error\")\n",
    "else :\n",
    "    print(\"ca gaze\", z)\n",
    "finally :\n",
    "    print(\"bloc try termine\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le bloc finally prend plus de sens lors de la manipulation de fichiers. Que le traitement se déroule correctement ou lève une exception, le bloc finally peut forcer la fermeture propre du fichier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## L'instruction raise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enfin, le programmteur python peut lui-même lever de exceptions et ceci à l'aide de l'instruction raise. L'intérêt de tout cela peut sembler difficile à comprendre à première vue. Cependant, cela peut être utile pour 2 choses. L'utilisateur peut choisir de créer ses propres exceptions et dans ce cas, il devra les lever lui-même. Par ailleurs, il est tout à fait possible qu'un traitement d'exception se fasse à plusieurs niveaux de profondeur du code et pas seulement au niveau le plus proche du code qui provoque l'exception. Si par exemple, une instruction dans une fonction f provoque une exception, on peut très bien envisager de traiter cette exception localement dans le bloc try except mais on peut aussi propager cette exception à la fonction qui a appelé la fonction f pour qu'à son tour, elle puisse réagir à cette exception à son niveau d'abstraction à elle. Ainsi dans le traitement local d'une exception, on peut à la fin du traitement utiliser l'instruction raise qui va provoquer de nouveau l'exception et provoquer un déroutement à la fonction appeleante qui pourra, à son tour, traiteir l'exception. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=8;\n",
    "y=int(input())\n",
    "if y==0 :\n",
    "    raise ZeroDivisionError(\"faut pas deconner\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=8\n",
    "try :\n",
    "  y=int(input())\n",
    "  z=x/y\n",
    "except ZeroDivisionError :\n",
    "    print(\"Zero Error\")\n",
    "    raise\n",
    "except ValueError :\n",
    "    print(\"Value Error\")\n",
    "else :\n",
    "    print(\"ca gaze\", z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous vous proposons un exercice permettant de mettre en valeur les exceptions. Il s'agit de coder un programme qui réalise les opérations suivantes :\n",
    "- récupération du premier paramètre du programme qui représente un nom de fichier\n",
    "- ouverture du fichier\n",
    "- lecture d'une ligne dans le fichier\n",
    "\n",
    "Imaginez toutes les exceptions qui peuvent survenir dans l'exécution de ce programme et définissez des blocs try en conséquence. En particulier, si le fichier est vide, on vous propose de lever vous-même l'exception IOError avec le texte 'fichier vide'.\n"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}