TP_2_optimisations_corrections.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TP 2 : Optimisations et corrections\n",
    "Dans le TP 1, nous avons proposé un petit morceau de code pour calculer un caractère de contrôle. Il marche, il peut même servir tel quel. Mais on peut peaufiner tout cela pour en faire quelque chose de plus performant, plus conforme aux bonnes pratiques de programmation python et d'appelable sous forme de script.\n",
    "\n",
    "Un très grand merci à [mon cher collègue Thomas Ledoux](https://github.com/tledoux) pour l'accueil encourageant fait à cette petite initiative et ses suggestions constructives. Les évolutions décrites ici découlent pour une bonne partie de ses remarques.\n",
    "## Le problème\n",
    "### Appliquer les bonnes pratiques de style\n",
    "Coder, c'est comme écrire : chacun a son style, lié à sa connaissance du langage et de ses subtilités, à ses préférences, à son expérience. Certains ont un style laconique jusqu'à l'ellipse, d'autres inutilement chargé. Bien entendu, lorsque l'on code à un certain niveau, il est souhaitable d'uniformiser un peu tout cela par des conventions qui aident à trouver un compromis entre concision et limpidité.\n",
    "\n",
    "Certaines recommandations ont pour but d'éviter des problèmes très concrets, d'autres visent simplement à ce qu'un futur réutilisateur (soi-même, dans la majorité des cas) comprenne rapidement le sens du code et puisse le modifier adéquatement.\n",
    "\n",
    "Le créateur de python, Guido van Rossum, a proposé un [guide de style](https://www.python.org/dev/peps/pep-0008/) qui traite à la fois de conventions orthographiques (des conventions de nommage) et de syntaxe. A sa lecture, vous devriez être capable de trouver toutes les fois (et elles sont nombreuses) où j'ai violé les règles...\n",
    "### Corriger les problèmes de syntaxe\n",
    "L'utilitaire, [PyLint](https://www.pylint.org/) permet d'analyser son code au regard des bonnes pratiques de style et de syntaxe. Si vous le lancez sur mon code, non seulement il relève certaines violations de règles citées ci-dessus, mais il fait aussi remonter quelques problèmes de syntaxe. Saurez-vous les identifier, les comprendre et les régler ?\n",
    "\n",
    "Et juste pour le plaisir, il m'attribue la note infâmante de 2,9 sur 10. Bonnet d'âne, Bertrand.\n",
    "\n",
    "En tout cas, je prendrai l'habitude de toujours lancer PyLint sur mon code avant de publier...\n",
    "### Gérer les exceptions\n",
    "Dans les fonctions de calcul d'indice d'un caractère de l'alphabet ARK et de calcul du caractère de contrôle, j'utilise une structure conditionnelle 'if' pour vérifier que l'entrée est acceptable. Dans la seconde fonction pa rexemple, il faut que tous les caractères fassent partie de l'alphabet. Cela fonctionne, mais n'est pas très efficace : à chaque appel de la fonction, la structure sera exécutée. Or il est probable que dans la majorité des cas, la chaîne sera conforme. On exécutera donc un 'if' systématiquement pour ne l'utiliser que dans une minorité de cas.\n",
    "\n",
    "Il est en réalité plus efficace de considérer les cas inacceptables comme l'exception. Je vous propose donc de modifier le code pour utiliser les blocs try... except... comme décrit dans le chapitre [Gérer les exceptions](https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/231688-gerez-les-exceptions) du cours OpenClassrooms. \n",
    "### Ajouter commentaires et docstrings\n",
    "Notre code n'est pas commenté du tout. Logique, puisque les notebooks en font office. Mais c'est toujours bien de rajouter des commentaires, voire des docstrings (des commentaires sur des fonctions ou méthodes qui seront renvoyés si l'utilisateur appelle à l'aide avec la fonction 'help(nom_de_ma_fonction)'. Il existe [une proposition](https://www.python.org/dev/peps/pep-0257/) (PEP, pour _Python Enhancement Proposal_) qui suggère une série de bonnes pratiques pour rédiger des docstrings, mais je me suis contenté du [digest](https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/235263-de-bonnes-pratiques) fait dans le cours d'OpenClassrooms.\n",
    "### Utiliser des méthodes adaptées aux séquences \n",
    "Si vous consultez la [proposition PEP 20 _The Zen of python_](https://www.python.org/dev/peps/pep-0020/#the-zen-of-python) vous tomberez sur cet aphorisme : \"Flat is better than nested\". A plat, c'est mieux qu'imbriqué. N'y voyez aucun sous-entendu : c'est un principe d'écriture de code lisible qui rappelle que les boucles et les structures conditionnelles sont moins lisibles que le code \"à plat\", particulièrement si on les enchâsse les unes dans les autres.\n",
    "\n",
    "Or certaines fonctions et méthodes dont j'ignorais l'existence quand j'ai écrit mon code permettent d'éviter ces structures, notamment la boucle qui me fournissait l'index d'un élément dans une séquence (une chaîne de caractères, une liste, un tuple). Cette méthode applicable aux séquences est 'index()'. Essayez de réécrire la méthode qui trouve l'indice d'un caractère dans l'alaphabet ARK BnF avec cette méthode.\n",
    "\n",
    "De même, j'ignorais que la fonction 'enumerate()' s'appliquait à toutes les séquences, donc aux chaînes de caractères autant qu'aux listes. Assez pratique pour parcourir la chaîne de caractères ARK et faire des calculs qui prennent en compte l'index de chaque caractère. Essayez aussi de modifier la méthode de calcul en utilisant cette méthode.\n",
    "### Utiliser le fichier en ligne de commande\n",
    "Notre fichier est utilisable en l'état : si on l'ouvre avec IDLE (l'éditeur fourni par défaut avec python) par exemple et qu'on clique sur Run > Run module, on pourra entrer la commande 'chaineArkBnf('cb36251435').calculCaracControle()' et on obtiendra le résultat attendu. On peut aussi imaginer l'importer et appeler ses méthodes depuis un autre module python. Mais ce serait bien de pouvoir l'appeler par un script du type 'python ark.py cb33873627'. Si vous pataugez, les ressources suivantes devraient vous débloquer : [une section du cours OpenClassrooms](https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/231571-avancez-pas-a-pas-vers-la-modularite-2-2#/id/r-2231874) et [une de la documentation python](https://docs.python.org/fr/3.8/tutorial/modules.html#executing-modules-as-scripts).\n",
    "## Solutions\n",
    "A nouveau, vous trouverez le fichier final dans le même dossier, sous le nom 'ark_2.py'.\n",
    "### Appliquer les bonnes pratiques de style\n",
    "Je précise déjà qu'une des recommandations est d'écrire en anglais, et que je vais volontairement la violer, parce que l'objectif de mon code est davantage pédagogique que fonctionnel. Donc, nos noms de variables et de fonctions seront en français, tout comme nos commentaires et docstrings.\n",
    "\n",
    "Les points problématiques sont les suivants :\n",
    "* Quand on assigne une valeur à une variable, le signe '=' doit être entouré d'espaces. Il en manque un dans la déclaration de la variable de l'alphabet...\n",
    "* Il n'y a pas à proprement parler de constantes dans python (des variables qu'on n'a pas vocation à changer). Néanmoins, il existe une convention de nommage pour ces variables globales déclarées au début du module, ce qui est le cas de la variable alphabet : on les écrit en majuscules..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "ALPHABET = '0123456789bcdfghjkmnpqrstvwxz'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La longueur des lignes est soumise à une exigence également : 79 caractères maximum (car la plupart des éditeurs semblent avoir adopté une largeur de fenêtre égale à 80 caractères, ce qui permet d'ouvrir deux fenêtres et de les juxtaposer), et 72 caractères pour les blocs de texte comme les docstrings. Or ma ligne 25 est trop longue ; on peut la raccourcir de plusieurs manières, l'une d'entre elles étant de segmenter le message en deux chaînes de caractères entre parenthèses, qui seront automatiquement concaténées :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "msg = (\"La chaîne n'est pas valide, \"\n",
    "       \"les caractères {} ne figurent pas dans l'alphabet BnF.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* les conventions de nommage des variables, des fonctions et des classes sont bien définies.\n",
    "  * Les variables et les fonctions doivent être en snake case (minuscules avec des mots séparées par des underscores) : 'calcul_carac_controle', 'carac_invalides', etc.\n",
    "  * Les classes en Pascal case (première lettre de chaque mot en majuscule, puis minuscules : 'ChaineArkBnf', ou plutôt 'ChaineARKBnF' puisque les sigles et acronymes doivent avoir des majuscules - quant à la bizarrerie du sigle BnF avec le 'n' minuscule, je ne m'étendrai pas dessus).\n",
    "  * Les modules (autrement dit, les fichiers) doivent n'avoir que des minuscules et éventuellement des underscores. Je vais donc renommer mon fichier en 'ark_2.py'. \n",
    "* Pour séparer les classes, fonctions et variables de plus haut niveau, les règles nous suggèrent d'utiliser deux lignes blanches.\n",
    "* J'ai utilisé des barres obliques inversées dans les chaînes de caractères pour échapper des apostrophes. C'est vrai que ça nuit un peu à la lisibilité, d'où le fait que l'on nous recommande d'utiliser les _double quotes_ pour encadrer une chaîne qui comporte des apostrophes sous forme de _simple quotes_.\n",
    "* Dans le cas d'opérations mathématiques, on ne met pas d'espaces autour des opérateurs lorsqu'il s'agit d'une opération prioritaire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2*4 + 6 - (4+2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "est préférable à"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2 * 4 + 6 - (4 + 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Une séquence vide est considérée comme \"fausse\" par python. Du coup, plutôt que d'écrire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Liste vide\n"
     ]
    }
   ],
   "source": [
    "sequence = []\n",
    "if len(sequence) == 0:\n",
    "    print('Liste vide')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "il est plus concis d'écrire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Liste vide\n"
     ]
    }
   ],
   "source": [
    "if not sequence:\n",
    "    print('Liste vide')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Semblablement, si je compare à un booléen, je n'ai pas besoin d'écrire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C'est vrai\n"
     ]
    }
   ],
   "source": [
    "valide = True\n",
    "if valide == True:\n",
    "    print(\"C'est vrai\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "je peux me contenter (et c'est tout aussi clair à la lecture) de"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C'est vrai\n"
     ]
    }
   ],
   "source": [
    "valide = True\n",
    "if valide:\n",
    "    print(\"C'est vrai\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Corriger les problèmes de syntaxe\n",
    "Pour illustrer les deux problèmes principaux relevés par PyLint, on va revoir la méthode 'valider()'. PyLint nous renvoie la remarque suivante :\n",
    "\n",
    "'R: 22, 8: Unnecessary \"else\" after \"return\" (no-else-return)'\n",
    "\n",
    "Il s'agit d'un avertissement assez récent, dont l'utilité est controversée. Il faut savoir que dans une fonction ou une méthode, le mot-clé 'return' coupe court à l'exécution de la fonction ; si vous mettez du code après, il ne sera pas exécuté. Donc dans le morceau de code suivant, le mot-clé 'else' est inutile puisque si la condition est vraie la fonction cesse d'exécuter le code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = False\n",
    "\n",
    "def fonction():\n",
    "    if test:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il suffit donc d'écrire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fonction():\n",
    "    if test:\n",
    "        return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mais plus globalement, cela montre un problème de mon code : mes fonctions ont une fâcheuse tendance à renvoyer des choses de nature différente selon la branche de la structure conditionnelle dans laquelle je me trouve. PyLint nous le fait savoir ainsi :\n",
    "\n",
    "'Either all return statements in a function should return an expression, or none of them should. (inconsistent-return-statements)'\n",
    "\n",
    "Je vais donc plutôt faire la chose suivante : je place le mot-clé 'return' à la fin de ma fonction et, dans les structures conditionnelles, je ne fais que définir la valeur de variables que je dois renvoyer. Ainsi, pour la méthode 'valider()', je renvoie un tuple avec un booléen et un message."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ChaineARKBnF():\n",
    "    def __init__(self, valeur=''):\n",
    "        self.valeur = valeur\n",
    "\n",
    "    def valider(self):\n",
    "        invalides = []\n",
    "        for carac in self.valeur:\n",
    "            if carac not in ALPHABET:\n",
    "                invalides.append(carac)\n",
    "        if not invalides:\n",
    "            valide = True\n",
    "            msg = \"La chaîne est valide au regard de l'alphabet BnF.\"\n",
    "        else:\n",
    "            valide = False\n",
    "            msg = (\"La chaîne n'est pas valide, les caractères {} \"\n",
    "            \"ne figurent pas dans l'alphabet BnF.\").format(set(invalides))\n",
    "        return (valide, msg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Au passage, vous remarquerez que j'ai changé ma manière d'insérer des variables dans les chaînes de caractères. J'écrivais, à l'ancienne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Les caractères ['i', 'o'] ne figurent pas dans l'alphabet BnF.\""
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "invalides = ['i', 'o']\n",
    "\n",
    "\"Les caractères %s ne figurent pas dans l'alphabet BnF.\" % invalides"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Selon la nouvelle manière, on utilise la méthode 'format()' qui permet la même chose (mais aussi des opérations de formatage fort utiles sur les chaînes de caractère, par exemple ajouter des zéros de tête à des nombres)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Les caractères ['i', 'o'] ne figurent pas dans l'alphabet BnF.\""
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "invalides = ['i', 'o']\n",
    "\n",
    "\"Les caractères {} ne figurent pas \\\n",
    "dans l'alphabet BnF.\".format(invalides)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Appliquer les méthodes de séquences\n",
    "La méthode 'index()' rend ma méthode pour trouver l'index d'un caractère ARK BnF obsolète : il suffit d'appliquer 'index()' à une séquence pour obtenir l'indice d'un élément passé en paramètre. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ALPHABET.index('b')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On va pouvoir revoir ainsi la méthode calculCaracControle (renommée en 'calculer_controle') :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ChaineARKBnF():\n",
    "    def __init__(self, valeur=''):\n",
    "        self.valeur = valeur\n",
    "\n",
    "    def valider(self):\n",
    "        invalides = []\n",
    "        for carac in self.valeur:\n",
    "            if carac not in ALPHABET:\n",
    "                invalides.append(carac)\n",
    "        if not invalides:\n",
    "            valide = True\n",
    "            msg = \"La chaîne est valide au regard de l'alphabet BnF.\"\n",
    "        else:\n",
    "            valide = False\n",
    "            msg = (\"La chaîne n'est pas valide, les caractères {} \"\n",
    "            \"ne figurent pas dans l'alphabet BnF.\").format(set(invalides))\n",
    "        return (valide, msg)\n",
    "        \n",
    "    def calculer_controle(self):\n",
    "        valide = self.valider()\n",
    "        if valide[0]:\n",
    "            addition = 0\n",
    "            for indice, carac in enumerate(self.valeur):\n",
    "                addition += ALPHABET.index(carac) * (indice+1)\n",
    "            controle = ALPHABET[addition % 29]\n",
    "            return controle\n",
    "        return valide[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gérer les exceptions\n",
    "On reprend la méthode 'calculer_controle' ci-dessus pour essayer ('try') de calculer notre caractère de contrôle. Si on tombe sur une erreur, on appelle la méthode 'valider()' qui se chargera de renvoyer un message explicite d'erreur.\n",
    "\n",
    "Le mot-clé 'except' est ici suivi de 'ValueError' qui indique le type d'erreur qu'on s'attend à obtenir si l'utilisateur tente de calculer un caractère de contrôle sur une chaîne dont un des caractères ne fait pas partie de l'alphabet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "class ChaineARKBnF():\n",
    "    def __init__(self, valeur=''):\n",
    "        self.valeur = valeur\n",
    "\n",
    "    def valider(self):\n",
    "        invalides = []\n",
    "        for carac in self.valeur:\n",
    "            if carac not in ALPHABET:\n",
    "                invalides.append(carac)\n",
    "        if not invalides:\n",
    "            valide = True\n",
    "            msg = \"La chaîne est valide au regard de l'alphabet BnF.\"\n",
    "        else:\n",
    "            valide = False\n",
    "            msg = (\"La chaîne n'est pas valide, le(s) caractère(s) {} \"\n",
    "            \"ne figurent pas dans l'alphabet BnF.\").format(set(invalides))\n",
    "        return (valide, msg)\n",
    "        \n",
    "    def calculer_controle(self):\n",
    "        try:\n",
    "            addition = 0\n",
    "            for indice, carac in enumerate(self.valeur):\n",
    "                addition += ALPHABET.index(carac) * (indice+1)\n",
    "            controle = ALPHABET[addition % 29]\n",
    "            return controle\n",
    "        except ValueError:\n",
    "            valide = self.valider()\n",
    "            if not valide[0]:\n",
    "                print(valide[1], file=sys.stderr)\n",
    "            return ''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous remarquerez qu'on importe le module 'sys' pour pouvoir renvoyer les erreurs vers un canal standard. Je ne m'étendrai pas là-dessus parce que je n'ai pas encore bien compris ce mécanisme."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Utiliser le fichier en ligne de commande\n",
    "Je vous donne tout de suite le résultat, et je le commente ensuite."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pour -f, le caractère de contrôle est \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "La chaîne n'est pas valide, le(s) caractère(s) {'-'} ne figurent pas dans l'alphabet BnF.\n"
     ]
    }
   ],
   "source": [
    "def main(args):\n",
    "    valeur = args[1] if len(args) > 1 else \"t3st\"\n",
    "    chaine = ChaineARKBnF(valeur)\n",
    "    controle = chaine.calculer_controle()\n",
    "    msg = \"Pour {}, le caractère de contrôle est {}\"\n",
    "    print(msg.format(valeur, controle))\n",
    "\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    main(sys.argv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Commençons par la structure conditionnelle finale. Comme indiqué dans la ressource que je vous ai signalée, on définit une structure conditionnelle de haut niveau qui va tester si le fichier est exécuté (à la différence d'un module qui serait simplement importé). Si c'est le cas - et ça l'est si on appelle le fichier en ligne de commande par 'python ark_2.py' -, il exécute un morceau de code.\n",
    "\n",
    "Regardons ensuite la fonction principale ('main'). 'sys.argv' nous a envoyé en paramètre de la fonction une liste dont le premier élément est le nom du script. Les arguments sont les éléments suivants. On va donc récupérer le premier argument si l'utilisateur a bien spécifié une chaîne, sinon on utilise par défaut la chaîne 't3st'. Puis on instancie la classe 'ChaineARKBnF' avec pour attribut 'valeur' l'argument de la ligne de commande. On appelle la fonction de calcul du caractère de contrôle, on définit un message et on le renvoie en lui intégrant la chaîne et le caractère de contrôle.\n",
    "\n",
    "Vous remarquerez d'ailleurs que, lorsque ce code est exécuté via le notebook Jupyter, il l'est avec en premier argument '-f', ce qui donne le résultat un peu étrange que vous avez sous les yeux, puisque notre fichier est prévu pour être exécuté avec une chaîne ARK comme paramètre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}