notebooks/02_python_from_scratch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapitre 2 - Les bases de Python / Python from scratch\n",
    "\n",
    "Ce notebooks reprend les exemples de l'ouvrage Python pour le data scientist publié en 2018 chez Dunod. Il s'agit d'un notebook d'accompagnement que vous pourrez réutiliser.\n",
    "\n",
    "Ce chapitre consiste en un rappel des grands principes du langage Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.2 Version de Python\n",
    "\n",
    "Dans le cadre de ces notebooks (comme dans le cadre de l'ouvrage), nous faisons le choix d'utiliser Python 3 plutôt que Python 2.\n",
    "\n",
    "Si vous désirez comprendre les différences entre ces versions, je vous invite à consulter ce site :\n",
    "\n",
    "https://wiki.python.org/moin/Python2orPython3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Utilisation de IPython\n",
    "\n",
    "Comme nous utilisons des notebooks Jupyter, nous utilisons l'interpréteur IPython par défaut.\n",
    "\n",
    "Celui-ci nous apporte de nombreux avantages :\n",
    "    \n",
    "    - Utilisation de la tabulation pour la complétion\n",
    "    - Utilisation des clés magiques\n",
    "    - Accès simplifié aux aides"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accès aux aides\n",
    "\n",
    "Vous pouvez accéder aux aides en utilisant la combinaison Shift + Tab mais aussi en utilisant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et pour accéder au code source d'une fonction lorsqu'il est disponible :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les clés magiques de IPython\n",
    "\n",
    "IPython possède de nombreuses clés magiques, elles sont appelées dans un Notebook en utilisant le symbole %. Une clé magique avec un % s'applique à une ligne, une clé magique avec %% s'applique à toute une cellule.\n",
    "\n",
    "Pour obtenir la liste des clés magiques, on peut utiliser :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/json": {
       "cell": {
        "!": "OSMagics",
        "HTML": "Other",
        "SVG": "Other",
        "bash": "Other",
        "capture": "ExecutionMagics",
        "cmd": "Other",
        "debug": "ExecutionMagics",
        "file": "Other",
        "html": "DisplayMagics",
        "javascript": "DisplayMagics",
        "js": "DisplayMagics",
        "latex": "DisplayMagics",
        "markdown": "DisplayMagics",
        "perl": "Other",
        "prun": "ExecutionMagics",
        "pypy": "Other",
        "python": "Other",
        "python2": "Other",
        "python3": "Other",
        "ruby": "Other",
        "script": "ScriptMagics",
        "sh": "Other",
        "svg": "DisplayMagics",
        "sx": "OSMagics",
        "system": "OSMagics",
        "time": "ExecutionMagics",
        "timeit": "ExecutionMagics",
        "writefile": "OSMagics"
       },
       "line": {
        "alias": "OSMagics",
        "alias_magic": "BasicMagics",
        "autoawait": "AsyncMagics",
        "autocall": "AutoMagics",
        "automagic": "AutoMagics",
        "autosave": "KernelMagics",
        "bookmark": "OSMagics",
        "cd": "OSMagics",
        "clear": "KernelMagics",
        "cls": "KernelMagics",
        "colors": "BasicMagics",
        "config": "ConfigMagics",
        "connect_info": "KernelMagics",
        "copy": "Other",
        "ddir": "Other",
        "debug": "ExecutionMagics",
        "dhist": "OSMagics",
        "dirs": "OSMagics",
        "doctest_mode": "BasicMagics",
        "echo": "Other",
        "ed": "Other",
        "edit": "KernelMagics",
        "env": "OSMagics",
        "gui": "BasicMagics",
        "hist": "Other",
        "history": "HistoryMagics",
        "killbgscripts": "ScriptMagics",
        "ldir": "Other",
        "less": "KernelMagics",
        "load": "CodeMagics",
        "load_ext": "ExtensionMagics",
        "loadpy": "CodeMagics",
        "logoff": "LoggingMagics",
        "logon": "LoggingMagics",
        "logstart": "LoggingMagics",
        "logstate": "LoggingMagics",
        "logstop": "LoggingMagics",
        "ls": "Other",
        "lsmagic": "BasicMagics",
        "macro": "ExecutionMagics",
        "magic": "BasicMagics",
        "matplotlib": "PylabMagics",
        "mkdir": "Other",
        "more": "KernelMagics",
        "notebook": "BasicMagics",
        "page": "BasicMagics",
        "pastebin": "CodeMagics",
        "pdb": "ExecutionMagics",
        "pdef": "NamespaceMagics",
        "pdoc": "NamespaceMagics",
        "pfile": "NamespaceMagics",
        "pinfo": "NamespaceMagics",
        "pinfo2": "NamespaceMagics",
        "pip": "BasicMagics",
        "popd": "OSMagics",
        "pprint": "BasicMagics",
        "precision": "BasicMagics",
        "prun": "ExecutionMagics",
        "psearch": "NamespaceMagics",
        "psource": "NamespaceMagics",
        "pushd": "OSMagics",
        "pwd": "OSMagics",
        "pycat": "OSMagics",
        "pylab": "PylabMagics",
        "qtconsole": "KernelMagics",
        "quickref": "BasicMagics",
        "recall": "HistoryMagics",
        "rehashx": "OSMagics",
        "reload_ext": "ExtensionMagics",
        "ren": "Other",
        "rep": "Other",
        "rerun": "HistoryMagics",
        "reset": "NamespaceMagics",
        "reset_selective": "NamespaceMagics",
        "rmdir": "Other",
        "run": "ExecutionMagics",
        "save": "CodeMagics",
        "sc": "OSMagics",
        "set_env": "OSMagics",
        "store": "StoreMagics",
        "sx": "OSMagics",
        "system": "OSMagics",
        "tb": "ExecutionMagics",
        "time": "ExecutionMagics",
        "timeit": "ExecutionMagics",
        "unalias": "OSMagics",
        "unload_ext": "ExtensionMagics",
        "who": "NamespaceMagics",
        "who_ls": "NamespaceMagics",
        "whos": "NamespaceMagics",
        "xdel": "NamespaceMagics",
        "xmode": "BasicMagics"
       }
      },
      "text/plain": [
       "Available line magics:\n",
       "%alias  %alias_magic  %autoawait  %autocall  %automagic  %autosave  %bookmark  %cd  %clear  %cls  %colors  %config  %connect_info  %copy  %ddir  %debug  %dhist  %dirs  %doctest_mode  %echo  %ed  %edit  %env  %gui  %hist  %history  %killbgscripts  %ldir  %less  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %ls  %lsmagic  %macro  %magic  %matplotlib  %mkdir  %more  %notebook  %page  %pastebin  %pdb  %pdef  %pdoc  %pfile  %pinfo  %pinfo2  %popd  %pprint  %precision  %prun  %psearch  %psource  %pushd  %pwd  %pycat  %pylab  %qtconsole  %quickref  %recall  %rehashx  %reload_ext  %ren  %rep  %rerun  %reset  %reset_selective  %rmdir  %run  %save  %sc  %set_env  %store  %sx  %system  %tb  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmode\n",
       "\n",
       "Available cell magics:\n",
       "%%!  %%HTML  %%SVG  %%bash  %%capture  %%cmd  %%debug  %%file  %%html  %%javascript  %%js  %%latex  %%markdown  %%perl  %%prun  %%pypy  %%python  %%python2  %%python3  %%ruby  %%script  %%sh  %%svg  %%sx  %%system  %%time  %%timeit  %%writefile\n",
       "\n",
       "Automagic is ON, % prefix IS NOT needed for line magics."
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%lsmagic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voici quelques clés magiques utiles :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Interactive namespace is empty.\n"
     ]
    }
   ],
   "source": [
    "# Liste des objets chargés en mémoire\n",
    "%whos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.9 ns ± 0.699 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "# Timer pour mesurer le temps de traitement\n",
    "%timeit 2**10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 Les bases du langage pour commencer à coder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.1 Les principes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Typage des variables\n",
    "On commence par définir l'opérateur d'allocation qui est le ="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "var1=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le typage étant automatique (duck typing), on définit le type en utilisant la valeur alouée :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'> <class 'float'> <class 'str'> <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "var1=10\n",
    "var2=3.5\n",
    "var3=\"Python\"\n",
    "var4=True\n",
    "print(type(var1),type(var2),type(var3),type(var4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.2 Un langage tout objet\n",
    "En Python, tous ce que nous allons utiliser sont des objets issus de classes. Ainsi ces objets ont les attributs et les méthodes liées aux classes.\n",
    "\n",
    "Ainsi pour une chaîne de caractères :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PYTHON\n"
     ]
    }
   ],
   "source": [
    "chaine1=\"Python\"\n",
    "# on utilise une méthode de la classe str :\n",
    "print(chaine1.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.3 Les commentaires\n",
    "\n",
    "En Python les commentaires sont indiqué par le signe #.\n",
    "\n",
    "Ils peuvent être sur une ligne complète ou après le code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.6 Les opérateurs logiques\n",
    "\n",
    "Pour tester un type, on peut utiliser :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(chaine1) is str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "entier1=44"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(chaine1) is type(entier1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 Les structures en Python\n",
    "\n",
    "Il existe plusieurs structures en Python : les tuples, les listes et les dictionnaires en sont les pricipales."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.1 Les tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# on définit un tuple avec ()\n",
    "tup1=(1, True, 7.5,9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.5"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# on accède à un élément d'un tuple (et de n'importe quelle structure) avec []\n",
    "tup1[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# les tuples possèdent peu de méthodes\n",
    "tup1.count(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.2 Les listes\n",
    "\n",
    "Les listes sont définies avec des [] et peuvent être constitués de tous les types d'objets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1=[3,5,6, True]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On accède à un élément d'une liste en utilisant []:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# On peut facilement accéder à plusieurs éléments de différentes façons\n",
    "list1[0:2] == list1[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extraire le dernier élément\n",
    "list1[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, True]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extraire les 3 derniers éléments\n",
    "list1[-3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voici un exemple de listes avec des chaînes de caractères\n",
    "\n",
    "La liste possède de nombreuses méthodes, ici on utilise une inversion des éléments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Chine', 'Inde', 'Etats-Unis']\n",
      "['France', 'Espagne', 'Suisse']\n",
      "['Suisse', 'Espagne', 'France', 'Etats-Unis', 'Inde', 'Chine']\n"
     ]
    }
   ],
   "source": [
    "liste_pays=[\"Chine\",\"Inde\",\"Etats-Unis\",\"France\",\"Espagne\",\"Suisse\"]\n",
    "print(liste_pays[:3])\n",
    "print(liste_pays[-3:])\n",
    "liste_pays.reverse()\n",
    "print(liste_pays)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les *list comprehension* sont des générateurs de listes qui utilisent des conditions et des boucles.\n",
    "\n",
    "Dans cet exemple, on va extraire le carré des éléments pairs de la list_init"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "list_init=[4,6,7,8]\n",
    "list_comp=[val**2 for val in list_init if val % 2 == 0]\n",
    "print(list_comp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.3 Les chaînes de caratères\n",
    "\n",
    "On a trois façons équivalentes de définir des chaînes de caractères"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "chaine1=\"Python pour le data scientist\"\n",
    "chaine2='Python pour le data scientist'\n",
    "chaine3=\"\"\"Python pour le data scientist\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une chaîne de caractère est en fait une liste spécifique dans laquelle chaque élément est un caractère"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n",
      "data scientist\n",
      "data \n"
     ]
    }
   ],
   "source": [
    "print(chaine1[:6])\n",
    "print(chaine1[-14:])\n",
    "print(chaine1[15:20])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut facilement passer d'une chaîne de caractères à une liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Python', 'pour', 'le', 'data', 'scientist']\n"
     ]
    }
   ],
   "source": [
    "# on sépare les éléments en utilisant l’espace\n",
    "liste1=chaine1.split()\n",
    "print(liste1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python pour le data scientist\n"
     ]
    }
   ],
   "source": [
    "# on joint les éléments avec l’espace\n",
    "chaine1bis=\" \".join(liste1)\n",
    "print(chaine1bis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4.4 Les dictionnaires\n",
    "\n",
    "Les dictionnaires permettent de stocker des éléments en utilisant un système de clés."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1={\"cle1\":\"valeur1\", \"cle2\":\"valeur2\", \"cle3\":\"valeur3\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'valeur2'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# on accède à un élément par sa clé\n",
    "dict1[\"cle2\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['cle1', 'cle2', 'cle3'])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# on peut afficher la liste des clés\n",
    "dict1.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('cle1', 'valeur1'), ('cle2', 'valeur2'), ('cle3', 'valeur3')])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# on peut aussi afficher les pairs clé : valeur\n",
    "dict1.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# on crée une clé et a valeur associée :\n",
    "dict1[\"cle4\"]=\"valeur4\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# on peut supprimer cette clé\n",
    "del dict1[\"cle4\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# on peut aussi utiliser la fonction dict :\n",
    "dict2=dict(cle1=\"valeur1\",cle2=\"valeur2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'valeur1'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict2[\"cle1\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 Conditions / Boucles avec Python\n",
    "\n",
    "### 2.5.1 Conditions\n",
    "Les conditions sont simples à mettre en place en Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# on définit a\n",
    "a=True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c'est vrai\n"
     ]
    }
   ],
   "source": [
    "# première condition\n",
    "if a is True :\n",
    "    print(\"c'est vrai\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c'est vrai\n"
     ]
    }
   ],
   "source": [
    "# on ajoute une alternative\n",
    "if a is True :\n",
    "    print(\"c'est vrai\")\n",
    "else :\n",
    "    print(\"ce n'est pas vrai\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c'est vrai\n"
     ]
    }
   ],
   "source": [
    "# on ajoute un elif\n",
    "if a is True :\n",
    "    print(\"c'est vrai\")\n",
    "elif a is False :\n",
    "    print(\"c'est faux\")\n",
    "else :\n",
    "    print(\"ce n'est pas un booléen\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Opérateurs de comparaison\n",
    "On peut utiliser en Python == ou is et leur utilisation sera différente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# True est égal à 1\n",
    "True == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# False est égal à 0\n",
    "False == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mais True n'est pas 1 (objet différent)\n",
    "True is 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# en comparaisons True est plus grand que False (1>0)\n",
    "True > False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# pour des chaînes de caractères, l’ordre alphabétique prime\n",
    "\"Python\" > \"Java\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Java\"< \"C\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.2 Les boucles\n",
    "#### La boucle for\n",
    "La boucle *for* itère sur les éléments d'un objet. \n",
    "\n",
    "Avec une liste on a :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for elem in [1, 2]:\n",
    "    print(elem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction range() permet de générer une suite d'entiers :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n",
      "[2, 3, 4]\n",
      "[2, 4, 6, 8, 10, 12, 14]\n"
     ]
    }
   ],
   "source": [
    "print(list(range(5)))\n",
    "print(list(range(2,5)))\n",
    "print(list(range(2,15,2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour générer une boucle sur des entiers de 0 à 10, on utilise :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0--1--2--3--4--5--6--7--8--9--10--"
     ]
    }
   ],
   "source": [
    "for i in range(11) :\n",
    "    print(i,end=\"--\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attention, la dernière valeur est toujours exclue !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction *enumerate()* permet de générer un indice en plus de la valeur de l'élement :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Suisse\n",
      "1 Espagne\n",
      "2 France\n",
      "3 Etats-Unis\n",
      "4 Inde\n",
      "5 Chine\n"
     ]
    }
   ],
   "source": [
    "for i, a in enumerate(liste_pays) :\n",
    "    print(i, a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction *zip* permet de joindre deux listes et de les parcourir \"en parallèle\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Lundi, il fera beau\n",
      " Mardi, il fera mauvais\n"
     ]
    }
   ],
   "source": [
    "for jour, meteo in zip([\"lundi\",\"mardi\"],[\"beau\",\"mauvais\"]) :\n",
    "    print(\" % s, il fera % s\" %(jour.capitalize(), meteo))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut combiner *enumerate* et *zip* :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0 : Lundi, il fera beau\n",
      "  1 : Mardi, il fera mauvais\n"
     ]
    }
   ],
   "source": [
    "for i, (jour, meteo) in enumerate(zip([\"lundi\",\"mardi\"],[\"beau\",\"mauvais\"])) :\n",
    "    print(\" % i : % s, il fera % s\" %(i, jour.capitalize(), meteo))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### La boucle While\n",
    "Cette boucle a un fonctionnement classique en Python :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "51\n"
     ]
    }
   ],
   "source": [
    "i=1\n",
    "val_stop=50\n",
    "while i<100 :\n",
    "    i+=1\n",
    "    if i>val_stop :\n",
    "        break\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.6 Les fonctions\n",
    "Il est très simple de définir des fonctions en Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ma_fonc(a,b) :\n",
    "    print(a+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# on a différentes approches pour appeler une fonction\n",
    "ma_fonc(a=4, b=6)\n",
    "ma_fonc(4,6)\n",
    "ma_fonc(b=6, a=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les valeurs par défaut des paramètres\n",
    "On peut définir des valeurs par défaut, ici on fixe b=6. Si b est renseigné dans l'appel, il prend la valeur renseignée, sinon il prend la valeur par défaut."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ma_fonc_b(a, b=6) :\n",
    "    print(a+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "ma_fonc_b(2,5)\n",
    "ma_fonc_b(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ma_fonc2(a, b=6, c=5, d=10) :\n",
    "    print(a+b+c+d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "ma_fonc2(2, c=3)\n",
    "ma_fonc2(2, d=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lorsqu'on a plusieurs paramètres dans un appel de fonction, plutôt que d'appeler séparément les éléments, on peut fournir une liste à la fonction. \n",
    "\n",
    "Dans ce cas on utilisera *list :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\n"
     ]
    }
   ],
   "source": [
    "list_fonc=[3,5,6,8]\n",
    "ma_fonc2(*list_fonc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi utiliser un dictionnaire et on utilise **dico :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n"
     ]
    }
   ],
   "source": [
    "dico_fonc={\"a\":5,\"b\":6,\"c\":7,\"d\":5}\n",
    "ma_fonc2(**dico_fonc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### L'utlisation de \\*args et \\*\\*kwargs dans un appel de fonctions\n",
    "Ceci va permettre d'avoir un nombre indéfini de paramètres dans l'appel de la fonctions.\n",
    "\n",
    "\\*args est associé à une liste et \\*\\*kwargs à un dictionnaire (c'est les \\* qui comptent et non les noms des arguents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ma_fonc3(param_obligatoire,*args,**kwargs) :\n",
    "    print(\"Argument obligatoire :\", param_obligatoire)\n",
    "    # si on a des arguments positionnés après les arguments obligatoires\n",
    "    # on les affiche\n",
    "    if args :\n",
    "        for val in args :\n",
    "            print(\"Argument dans args : \", val)\n",
    "    # si on a des arguments du type arg1 =… situé après les arguments\n",
    "    # obligatoires, on les affiche\n",
    "    if kwargs :\n",
    "        for key, val in kwargs.items() :\n",
    "             print(\"Nom de l’argument et valeur dans kwargs\", key, val,sep=\": \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Argument obligatoire : DATA\n",
      "Argument dans args :  Science\n",
      "Argument dans args :  Python\n",
      "Nom de l’argument et valeur dans kwargs: option: mon_option\n"
     ]
    }
   ],
   "source": [
    "ma_fonc3(\"DATA\",\"Science\",\"Python\", option=\"mon_option\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Argument obligatoire : DATA\n",
      "Nom de l’argument et valeur dans kwargs: autre_option: mon_option\n"
     ]
    }
   ],
   "source": [
    "ma_fonc3(\"DATA\", autre_option=\"mon_option\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans ce code, on a combiné les différentes options. On utilise souvent ce type\n",
    "d’arguments lorsqu’on appelle des fonctions de manière imbriquée de manière à\n",
    "éviter d’avoir à nommer tous les paramètres de toutes les fonctions appelées. Bien\n",
    "entendu, c’est à l’utilisateur de bien nommer les paramètres dans la partie kwargs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6.3 Les docstrings\n",
    "Les docstrings consistent en des descriptions des fonctions, des classes ou des modules que l'on définit en utilisant \"\"\" \"\"\" dans la ligne suivant la définition de la fonction / classe / module :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ma_fonction(*args):\n",
    "    \"\"\"Cette fonction calcule la somme des paramètres\"\"\"\n",
    "    if args:\n",
    "        return sum(args)\n",
    "    else:\n",
    "        return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function ma_fonction in module __main__:\n",
      "\n",
      "ma_fonction(*args)\n",
      "    Cette fonction calcule la somme des paramètres\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(ma_fonction)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour une description des bonnes pratiques en terme d'utilisation des docstrings, je vous conseile la lecture de PEP 257 :\n",
    "\n",
    "\n",
    "https://www.python.org/dev/peps/pep-0257/\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6.4 Les retours multiples\n",
    "Il est possible d'avoir plusieurs objets dans un return de fonctions. Dans ce cas ces différents éléments sont soit stockés dans un tuple, soit associé à différents objets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ma_fonc(a, b) :\n",
    "    return a+b, a-b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(7, -3)\n",
      "7 -3\n"
     ]
    }
   ],
   "source": [
    "tu1=ma_fonc(2,5)\n",
    "print(tu1)\n",
    "val1, val2=ma_fonc(2,5)\n",
    "print(val1, val2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6.5 Les fonctions lambdas\n",
    "Il s'agit de fonctions anonymes qui s'écrivent en une seule ligne.\n",
    "\n",
    "En voici deux exemples :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['PYTHON', 'POUR', 'LE', 'DATA', 'SCIENTIST']"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ma_chaine=\"Python pour le data scientist\"\n",
    "(lambda chaine : chaine.upper().split())(ma_chaine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 8, 12]\n"
     ]
    }
   ],
   "source": [
    "ma_liste = [1, 6, 8, 3, 12]\n",
    "nouvelle_liste = list(filter(lambda x: (x >= 6), ma_liste))\n",
    "print(nouvelle_liste)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.7 Les classes\n",
    "### 2.7.1 Comment reconnaître une classe\n",
    "\n",
    "On reconnaît une classe car, en principe, elle s'écrit avec des majuscule et sans séparateurs.\n",
    "\n",
    "On aura : KMeans() est une classe\n",
    "\n",
    "### 2.7.2 Définir une classe\n",
    "On définit simplement des classes en Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MonImage:\n",
    "    def __init__(self, resolution = 300, source = \"./\", taille= 500) :\n",
    "        self.resolution = resolution\n",
    "        self.source = source\n",
    "        self.taille = taille"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# on crée un objet de la classe qu'on a créé plus haut\n",
    "image_1 = MonImage(source=\"../other/python-pour-le-data-scientist-dunod.jpeg\",\n",
    "                  taille=500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En plus du constructeur \\__init\\__(), on va ajouter des méthodes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MonImage:\n",
    "    def __init__(self, resolution = 300, source = \"./\", taille= 500) :\n",
    "        self.resolution=resolution\n",
    "        self.source=source\n",
    "        self.taille=taille\n",
    "\n",
    "    def affiche_caract(self):\n",
    "        print(\"Résolution:\", self.resolution)\n",
    "        print(\"Taille:\", self.taille)\n",
    "        print(\"Source:\", self.source)\n",
    "\n",
    "    def agrandir_image(self, facteur) :\n",
    "        self.taille*= facteur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n"
     ]
    }
   ],
   "source": [
    "# on applique une méthode sur notre objet\n",
    "image_1 = MonImage(source=\"../other/python-pour-le-data-scientist-dunod.jpeg\",\n",
    "                  taille=500)\n",
    "image_1.agrandir_image(2)\n",
    "print(image_1.taille)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Je vous conseille fortement d'approfondir la notion de classe, centrale dans la programmation orientée objet de Python. \n",
    "\n",
    "La notion d'héritage est extrêmement importante et vous servira dès que vous serez un développeur plus aguérri.\n",
    "\n",
    "De nombreuses références sont disponibles sur le web et à la fin de l'ouvrage."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.8 Les modules et les packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut importer simplement des packages dans un notebook ou dans un script"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2018-10-23\n"
     ]
    }
   ],
   "source": [
    "print(datetime.date.today())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On donne souvent des noms courts aux packages :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.19138325]\n"
     ]
    }
   ],
   "source": [
    "print(np.random.random(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi importer une classe ou une fonction spécifiquement :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pandas import DataFrame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La création de package et de module est simple en Python, référez-vous à la partie à ce sujet dans l'ouvrage ou à la documentation de Python ici :\n",
    "\n",
    "https://docs.python.org/3/tutorial/modules.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.9 Aller plus loin\n",
    "\n",
    "### 2.9.1 La gestion d'exceptions\n",
    "Il est souvent nécessaire de gérer les erreurs qui peuvent être présentes dans un programme."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rapport(x, y) :\n",
    "    try:\n",
    "        return x/y\n",
    "    except ZeroDivisionError :\n",
    "        print(\"Division par zéro\")\n",
    "        return None\n",
    "    except TypeError :\n",
    "        print(\"Le type entré ne correspond pas\")\n",
    "        return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rapport2(x, y) :\n",
    "    try:\n",
    "        resultat = x/y\n",
    "    except ZeroDivisionError:\n",
    "        print(\"Division par zéro\")\n",
    "    else:\n",
    "        print(\"Le résultat est %.2f\" %(resultat))\n",
    "    finally:\n",
    "        print(\"Le calcul est terminé\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le résultat est 0.50\n",
      "Le calcul est terminé\n"
     ]
    }
   ],
   "source": [
    "rapport2(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Division par zéro\n",
      "Le calcul est terminé\n"
     ]
    }
   ],
   "source": [
    "rapport2(1,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans ce cas, l'erreur est affiché mais le programme execute quand même ce qui se trouve après finally"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le calcul est terminé\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-81-f1f1fcb3db51>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mrapport2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"&\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-78-74446a11f354>\u001b[0m in \u001b[0;36mrapport2\u001b[1;34m(x, y)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mrapport2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m         \u001b[0mresultat\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m/\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mZeroDivisionError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m         \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Division par zéro\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "rapport2(\"&\", 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.9.2 Les expressions régulières\n",
    "Python possède un module re qui permet de travailler sur des chaînes de caractères en utilisant des expressions réguières.\n",
    "\n",
    "Ce code illustre un cas où l'on chercherait à tester la présence d'une adresse email :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vrai\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "chaine = \"info@stat4decision.com\"\n",
    "# on vérifie qu'il y a bien le signe @ et on vérifie que l'adresse se termine\n",
    "# oar .fr ou .com\n",
    "regexp = \"(^[a-z0-9._-]+@[a-z0-9._-]+\\.[(com|fr)]+)\"\n",
    "if re.match(regexp, chaine) is not None :\n",
    "    print(\"Vrai\")\n",
    "else:\n",
    "    print(\"Faux\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.9.3 Les décorateurs\n",
    "Il s'agit d'utiliser des fonctions de fonctions. Vous pouvez consulter l'ouvrage pour plus de détails."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bonjour !\n",
      "Au revoir !\n"
     ]
    }
   ],
   "source": [
    "def bonjour() :\n",
    "    return \"Bonjour !\"\n",
    "\n",
    "def bonjour_aurevoir(fonction) :\n",
    "    print(fonction(), \"Au revoir !\", sep=\"\\n\")\n",
    "\n",
    "bonjour_aurevoir(bonjour)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "# on définit le décorateur - vérification du nom d’utilisateur\n",
    "def test_utilisateur(fonction) :\n",
    "    def verif_utilisateur(*args) :\n",
    "        if args[0]==\"Emmanuel\" :\n",
    "            fonction(*args)\n",
    "        else :\n",
    "            print(\"Mauvais utilisateur\")\n",
    "    return verif_utilisateur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "# on définit un mauvais utilisateur avec le bon password\n",
    "utilisateur=\"Paul\"\n",
    "password_emmanuel=\"Python\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "# on définit la fonction affiche_mot_de_passe qui affiche le mot de\n",
    "# passe que si l’utilisateur est Emmanuel en utilisant le décorateur\n",
    "@test_utilisateur\n",
    "def afficher_mot_de_passe(utilisateur) :\n",
    "    print(\"Mon mot de passe est % s\" %(password_emmanuel))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mauvais utilisateur\n"
     ]
    }
   ],
   "source": [
    "# on appelle la fonction décorée\n",
    "afficher_mot_de_passe(utilisateur)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mon mot de passe est Python\n"
     ]
    }
   ],
   "source": [
    "# on change d’utilisateur\n",
    "utilisateur=\"Emmanuel\"\n",
    "afficher_mot_de_passe(utilisateur)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ce chapitre ainsi que ce notebook ne constitue qu'un avant-goût de toutes les possibilités de Python.\n",
    "\n",
    "Dans la suite, nous allons nous intéresser plus précisément au outil pour le traitement de données de Python.\n",
    "\n",
    "Si vous désirez approfondir votre pratique du langage avec notamment les héritages pour la programmation orientée objet, je vous invite à consulter le wiki de la Python Software Foundation :\n",
    "https://wiki.python.org/moin/\n",
    "\n",
    "Et les nombreuses ressources web (notamment https://stackoverflow.com/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De nombreuses autres ressources vous permettrons de compléter vos compétences en Python"
   ]
  }
 ],
 "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
}