03_bases_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Les bases du langage Python\n",
    "\n",
    "---\n",
    "- Langage de haut niveau\n",
    "- Langage interprété\n",
    "- Langage orienté objet\n",
    "- Langage le plus proche possible du langage naturel\n",
    "\n",
    "*Attention Python est sensible à la casse*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5\n",
    "mon_entier = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "if a == 6:\n",
    "    print(\"youpi\")\n",
    "    print(\"coucou\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Quelques rappels en Python\n",
    "\n",
    "- Tout est objet même les \"variables\"\n",
    "- Un objet possède toujours des propriétés et des méthodes\n",
    "\n",
    "Avec iPython, on utilise pour connaître les méthodes et les propriétés :\n",
    "```\n",
    "mon_objet.[tabulation]\n",
    "```\n",
    "\n",
    "En python, pour construire un objet (opérateur d'allocation), on utilise toujours `=`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Les types en Python\n",
    "\n",
    "Les types de base :\n",
    "- int\n",
    "- float\n",
    "- boolean\n",
    "- string\n",
    "\n",
    "En Python pas besoin de déclarer le type de données, le langage s’en charge tout seul\n",
    "\n",
    "Python est basé sur un typage fort - une fois un objet d'un type donné, Python ne l'adapte pas\n",
    "\n",
    "Pour connaître le type d’une variable, on utilise : type(nom_de_variable)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "nom_de_variable = 44\n",
    "print(type(nom_de_variable))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exercice**\n",
    "\n",
    "Définir quatre variables distinctes, un entier `entier1`, un float `float1`, un booléen `bool1` et une chaîne de caractère `chaine1` et affichez-les dans la console.\n",
    "\n",
    "*Indice :* Les booléen s'écrivent `True` et `False`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "entier1 = 44\n",
    "float1 = 44.44\n",
    "bool1 = True\n",
    "chaine1 = \"AdWay\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo !\n"
     ]
    }
   ],
   "source": [
    "# pour vérifier que vous avez bien répondu à l'exercice, soumettre cette cellule\n",
    "# on utilise maj + Entrée\n",
    "assert type(entier1)==int, \"entier1 n'est pas un entier\"\n",
    "assert type(float1)==float, \"float1 n'est pas un float\"\n",
    "assert type(bool1)==bool, \"bool1 n'est pas un booléen\"\n",
    "assert type(chaine1)==str, \"chaine1 n'est pas une chaîne de caractère\"\n",
    "print(\"Bravo !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Les opérations arithmétiques\n",
    "\n",
    "- +\n",
    "- -\n",
    "- *\n",
    "- /\n",
    "- ** (puissance)\n",
    "- % (modulo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Les chaînes de caractères\n",
    "\n",
    "### 3 codages équivalents :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python Python Python\n"
     ]
    }
   ],
   "source": [
    "print(\"Python\",'Python',\"\"\"Python\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "requete = \"\"\" select x\n",
    "from data\n",
    "where x=4 \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "requete = \"select c from data where x=4\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "De nombreuses opérations sur les chaînes : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 python PYTHON Python\n"
     ]
    }
   ],
   "source": [
    "chaine1=\"Python\"\n",
    "print(len(chaine1), chaine1.lower(), chaine1.upper(), str(chaine1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "chaine1.lower?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que fait chacune de ces commandes ? (essayez d'expliquer en quelques mots)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remarque :** On a deux différences importantes\n",
    "    \n",
    "- `len(chaine1)` est un appel à la fonction `len()` qui prend comme paramètre un objet\n",
    "- `chaine1.lower()` est un appel à la méthode `lower()` de l'objet `chaine1`\n",
    "\n",
    "La méthode `.lower()` est une fonction qui ne peut s'appliquer que sur un objet chaîne de caractère.\n",
    "\n",
    "*Attention :* ne pas oublier les `()` après `lower` qui indique que c'est une méthode."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exercice**\n",
    "\n",
    "Définir une variable comprenant la chaîne 'Python pour la Science', utilisez des opérations sur les chaînes pour construire la chaine 'PYTHON POUR LA DATA SCIENCE'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "chaine_python = 'Python pour la Science'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Indice :* il faut d'abord ajouter le terme data puis mettre en majuscule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chaine_python[0:6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chaine_python[:6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Science'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chaine_python[-7:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "chaine_python2 = (chaine_python[:15] + \"data\" + chaine_python[14:]).upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "chaine_python2 = chaine_python.replace(\"la\", \"la data\").upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo !\n"
     ]
    }
   ],
   "source": [
    "# pour vérifier que vous avez bien répondu à l'exercice, soumettre cette cellule\n",
    "# on utilise maj + Entrée\n",
    "assert chaine_python2 == 'PYTHON POUR LA DATA SCIENCE', \"la réponse est fausse\"\n",
    "print(\"Bravo !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Les opérateurs pour les conditions\n",
    "\n",
    "Permet de mettre en place des conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C'est vrai\n"
     ]
    }
   ],
   "source": [
    "bool1=True\n",
    "if bool1 is True:\n",
    "    print(\"C'est vrai\")\n",
    "elif bool1 is False:\n",
    "    print(\"C'est faux\")\n",
    "else:\n",
    "    print(\"bool1 n'est pas un booléen\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "if a != 5:\n",
    "    print(\"zz\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Attention dans une condition, si on teste l'égalité des valeurs, il faut utiliser == (les autres opérateurs sont <, <=, >, >=, !=)\n",
    "- Il existe aussi l'opérateur is qui est très important en Python (lisibilité)\n",
    "    - Il permet de tester non pas uniquement les valeurs mais les objets similaires ( True == 1 est vrai mais True is 1 est faux) \n",
    "- Veillez à bien respecter l’indentation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# La boucle for\n",
    "\n",
    "- Les boucles for de Python ont une structure spécifique\n",
    "- L'itérateur prend comme valeur les éléments d'une liste\n",
    "- Structure :\n",
    "```\n",
    "for indice in sequence:\n",
    "    instructions\n",
    "```\n",
    "- On peut utiliser `break` pour casser une boucle \n",
    "\n",
    "- `while` peut aussi être utilisé\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "c'est fait\n"
     ]
    }
   ],
   "source": [
    "for i in [0,1,2,3]:\n",
    "    print(i)\n",
    "print(\"c'est fait\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "data = pd.read_table(\"./Data/credit1.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Months_as_a_Customer 48\n",
      "Number_of_Products 56\n",
      "RFM_Score 36\n",
      "Average_Balance_Feed_Index 1208\n",
      "Number_of_Transactions 29\n",
      "Personal_Debt_to_Equity_Ratio 83\n",
      "Months_Current_Account 41\n",
      "Number_of_Loan_Accounts 7\n",
      "Customer_ID 97651\n",
      "Has_Bad_Payment_Record 1\n",
      "Members_Within_Household 7\n",
      "Number_of_Call_Center_Contacts 11\n",
      "Weeks_Since_Last_Offer 52\n",
      "Accepted_Personal_Loan T\n",
      "Accepted_Retention T\n",
      "Accepted_Home_Equity_Loan T\n",
      "Accepted_Credit_Card T\n",
      "Annual_value 1680\n",
      "Interested_in_Personal_Loan T\n",
      "Interested_in_Retention T\n",
      "Interested_in_Home_Equity_Loan T\n",
      "Interested_in_Credit_Card T\n"
     ]
    }
   ],
   "source": [
    "for nom_col in data.columns:\n",
    "    print(nom_col , data[nom_col].max())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "for col in [\"a\",\"b\",\"c\"]:\n",
    "    print(col)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**La boucle de Python est un outil à manier avec parcimonie (elle est très lente)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "L'utilisation de `range(n)` permet de créer une liste de valeur de 0 à **n-1** :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Exercice :**\n",
    "    \n",
    "    \n",
    "Créer une boucle permettant d’afficher des phrases avec une valeur différente à chaque boucle \"Nous sommes ...\", \"lundi\", \"mardi\"..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_jours = [\"lundi\", \"mardi\", \"mercredi\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nous sommes lundi\n",
      "Nous sommes mardi\n",
      "Nous sommes mercredi\n"
     ]
    }
   ],
   "source": [
    "# remplacez les ___ par du code\n",
    "for jour in liste_jours:\n",
    "    print(\"Nous sommes\", jour)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si c'est trop facile : Essayez d'afficher \"Nous sommes lundi et il fait 15 degrés\" et répétez pour chaque jour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_temperatures = [15,20,10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('lundi', 15), ('mardi', 20), ('mercredi', 10)]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# indice, il y a beaucoup de façon d'y arriver, on peut aussi utiliser la fonction zip()\n",
    "list(zip(liste_jours, liste_temperatures))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nous sommes lundi et il fait 15 degrés\n",
      "Nous sommes mardi et il fait 20 degrés\n",
      "Nous sommes mercredi et il fait 10 degrés\n"
     ]
    }
   ],
   "source": [
    "for jour, temp in zip(liste_jours, liste_temperatures):\n",
    "    print(f\"Nous sommes {jour} et il fait {temp} degrés\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Les collections d’objet sous Python\n",
    "\n",
    "Il existe 3 structures principales de données sous Python :\n",
    "- Les tuples : suite de valeurs immuable définie par `( )`\n",
    "- Les listes : suite de valeurs modulable définie par `[ ]`\n",
    "- Les dictionnaires : valeurs indexées clé – valeur défini par `{ }` \n",
    "\n",
    "**Toutes ces structures permettent de stocker n'importe quel type d'objet.**\n",
    "    \n",
    "En Python, quelle que soit la structure, on utilise `[ ]` pour accéder à un élément d’une structure\n",
    "\n",
    "\n",
    "- Dans un tuple : `tup1[0]` permet d’accéder au premier élément\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Les tuples\n",
    "\n",
    "- On ne peut pas modifier un tuple une fois créé\n",
    "\n",
    "**Attention sous Python, le premier indice est toujours le 0**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "(3, 5)\n"
     ]
    }
   ],
   "source": [
    "#on définit un tuple\n",
    "tu = (1,3,5,7)\n",
    "#on peut rechercher sa taille\n",
    "print(len(tu))\n",
    "#on accès aux indices en utilisant []\n",
    "tu2=tu[1:3]\n",
    "print(tu2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "tu3 = (3,True, \"tt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Les listes\n",
    "\n",
    "Une liste est un tuple de taille dynamique et modifiable\n",
    "\n",
    "Les listes sont définies avec des `[ ]`\n",
    "\n",
    "Les méthodes sur les listes comprennent :\n",
    "- `.append()`\t\t\tajoute une valeur en fin de liste\n",
    "- `.insert(i,val)`\t\tinsert une valeur à l’indice i\n",
    "- `.pop(i)`\t\t\textrait la valeur de l’indice i\n",
    "- `.reverse()`\t\t\tinverse la liste\n",
    "- `.extend()` \t\t\tétend la liste\n",
    "\n",
    "**Attention la plupart des méthodes des listes modifient la liste.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_temperatures.reverse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_temperatures.insert(1,\"python\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 'python', 20, 15]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "liste_temperatures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exercice:**\n",
    "    \n",
    "Créez une liste `liste1` composée de 5 éléments, affichez la longueur de la liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste1 = [\"a\",44,True,44.44,\"Python\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo !\n"
     ]
    }
   ],
   "source": [
    "# pour vérifier que vous avez bien répondu à l'exercice, soumettre cette cellule\n",
    "# on utilise maj + Entrée\n",
    "assert len(liste1) == 5\n",
    "print(\"Bravo !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Les listes (suite)\n",
    "\n",
    "On peut faire des recherché plus avancées dans les listes :\n",
    "- `val in list` renvoie `True` si la valeur `val` est dans la liste `list`\n",
    "- `.index(val)` renvoie l'indice de la valeur `val`\n",
    "- `.count(val)` renvoie le nombre d'occurrence de `val`\n",
    "- `.remove(val)` retire la valeur `val` de la liste (que la 1ère)\n",
    "\n",
    "Pour supprimer une liste ou un élément d’une liste, on utilise la commande `del`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Un générateur de liste : la List Comprehension\n",
    "\n",
    "On peut définir des listes de manière plus complexe :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "listinit = [2,5,7,12]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "res = [x**2 for x in listinit if (x % 2 == 0)] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ce code permet de construire une liste en une seule ligne.\n",
    "\n",
    "La liste construire `res` rassemble les valeurs paires au carré."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exercice :**\n",
    "    \n",
    "A partir d’une liste de valeurs en degrés celsius `[0, 10, 20, 35]`, créez une liste en degrés fahrenheits sachant que la formule de transfert est `(9/5*temp+32)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_celsius = [0, 10, 20, 35]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_fahr = [9/5*temp+32 for temp in liste_celsius]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo !\n"
     ]
    }
   ],
   "source": [
    "# pour vérifier que vous avez bien répondu à l'exercice, soumettre cette cellule\n",
    "# on utilise maj + Entrée\n",
    "assert liste_fahr == [32, 50, 68, 95]\n",
    "print(\"Bravo !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Chaîne de caractères\n",
    "\n",
    "Pour intégrer des valeurs spécifiques dans une phrase, on utilisera :\n",
    "- `%f`, `%s`, `%i` à l’intérieur de la chaîne (`float`, `str` ou `entier`)\n",
    "- `%( , )` après la chaîne de caractères"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aujourd'hui nous sommes mercredi\n"
     ]
    }
   ],
   "source": [
    "print(\"Aujourd'hui nous sommes %s\" %(\"mercredi\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Si on veut intégrer d'autres types, on utilisera la méthode `.format()` et le codage `{}` dans la chaîne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La liste [4.5, 3.6, 6] est utilisée\n"
     ]
    }
   ],
   "source": [
    "print(\"La liste {} est utilisée\".format([4.5,3.6,6]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "A partir de python 3.7, on peut utiliser les f-string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello! My name is emmanuel\n"
     ]
    }
   ],
   "source": [
    "name = \"emmanuel\"\n",
    "hello = f\"Hello! My name is {name}\"\n",
    "print(hello)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Les dictionnaires\n",
    "\n",
    "Il s'agit d’une collection d’objets non ordonnés associant les notions \"clé – valeur\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'mardi'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "liste_jours[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "dico = {'Paris':5, 'Lyon':2, 'Bordeaux':1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dico['Lyon']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "dico_modeles = {\"logit\": LogisticRegression(),\n",
    "               \"rf\":RandomForestClassifier()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dico_modeles[\"logit\"].fit(...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_models = [LogisticRegression(), RandomForestClassifier()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression()"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_models[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['Paris', 'Lyon', 'Bordeaux'])\n",
      "dict_values([5, 2, 1])\n"
     ]
    }
   ],
   "source": [
    "# On utilise pour afficher la liste des clés et des valeurs\n",
    "print(dico.keys())\n",
    "print(dico.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# On accède aux valeurs par clé\n",
    "print(dico[\"Paris\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Les fonctions \n",
    "\n",
    "- Les niveaux d’une fonction dépendent de l’indentation\n",
    "- On définit une fonction avec `def fonction():`\n",
    "- Le contenu de la fonction suit\n",
    "- La valeur que retourne la fonction est définie par `return` \n",
    "- Les commentaires liés à une fonction sont inclus dans un docstring (commentaire utilisant `\"\"\"`) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def affichage_produit(val1,val2):\n",
    "    \"\"\"Cette fonction affiche le produit de 2 valeurs\"\"\"\n",
    "    # code\n",
    "    return val1*val2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    }
   ],
   "source": [
    "print(affichage_produit(4,6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "produit_4_6 = affichage_produit(4,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "produit_4_6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_data(data):\n",
    "    data = data.fillna(0)\n",
    "    # code\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "mes_donnes_ss_na = prep_data(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Une fonction peut avoir de multiples arguments dont des argument facultatifs (avec des valeurs par défaut) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def test(a,b,c=3):\n",
    "    return a+b+c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** Remplacez `___` par la valeur attendue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo !\n"
     ]
    }
   ],
   "source": [
    "assert test(2,3) == 8\n",
    "print(\"Bravo !\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo !\n"
     ]
    }
   ],
   "source": [
    "assert test(a=2, b=3, c=4) == 9\n",
    "print(\"Bravo !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "On peut avoir un nombre indéfini d’arguments en utilisant `*args` (ils sont rassemblés dans un tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4-|-6-|-5-|-7\n"
     ]
    }
   ],
   "source": [
    "print(4,6,5,7, sep=\"-|-\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def test2(a, b, *args):\n",
    "    val=0\n",
    "    for i in args:\n",
    "        # val += i\n",
    "        val = val + i\n",
    "    return a+b+val"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** Remplacez `___` par la valeur attendue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo !\n"
     ]
    }
   ],
   "source": [
    "assert test2(2,4,6,8) == 20\n",
    "print(\"Bravo !\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo !\n"
     ]
    }
   ],
   "source": [
    "assert test2(2,4) == 6\n",
    "print(\"Bravo !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercices récapitulatifs :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** Créez la condition suivante :<br>\n",
    "Si \"python\" est compris dans la chaîne `chaine_python`,<br>\n",
    "affichez la chaîne \"bravo !\"<br>\n",
    "Sinon, affichez la chaîne \"autre\"\n",
    "    \n",
    "*Indice :* on va utiliser la commande `in`, on utilise `\"mot\" in chaine`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "autre\n"
     ]
    }
   ],
   "source": [
    "if \"python\" in chaine_python:\n",
    "    print(\"bravo !\")\n",
    "else:\n",
    "    print(\"autre\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exercice :**\n",
    "\n",
    "Construire une fonction prenant en entrée deux listes et qui retourne la moyenne de tous les éléments des deux listes (une seule valeur)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ma_moyenne(liste1, liste2):\n",
    "    return sum(liste1+liste2)/len(liste1+liste2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo !\n"
     ]
    }
   ],
   "source": [
    "# pour vérifier que vous avez bien répondu à l'exercice, soumettre cette cellule\n",
    "# on utilise maj + Entrée\n",
    "assert ma_moyenne([1,2,3],[4,5,6]) == 3.5\n",
    "print(\"Bravo !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice facultatif :**\n",
    "    \n",
    "Essayez de construire une fonction calculant la moyenne de plus de 2 listes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "def moyenne_listes(*listes):\n",
    "    liste_totale = []\n",
    "    for liste in listes:\n",
    "        liste_totale.extend(liste)\n",
    "    return sum(liste_totale)/len(liste_totale)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7142857142857142"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "moyenne_listes([1,2,3],[1,2],[1,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** Automatisation de récupératoin de fichiers\n",
    "\n",
    "On veut créer une fonction en python pour récupérer la liste de tous les fichiers d'un type spécifique dans un répertoie\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['excel-data.xlsx', 'california.png', 'housing.csv', 'telecom.csv', 'nba_2013.csv', 'credit2.xlsx', 'us-states.json', 'winequality-white.csv', 'wind-global.nc', 'US_Unemployment_Oct2012.csv', 'ville.xls', 'tour-eiffel.png', 'Advertising.csv', 'salaries.sqlite', 'winequality-red.csv', 'SMSSpamCollection', 'base-dpt.csv', 'iris.xlsx', 'credit1.txt', 'titanic.csv']\n"
     ]
    }
   ],
   "source": [
    "# indice, on peut utliser ce code qui renvoie tous les fichier d'un répertoire :\n",
    "import os\n",
    "fichiers = os.listdir(\"./Data\")\n",
    "print(fichiers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recup_fichiers(rep, extension):\n",
    "    # 1. on récupère la liste des fichiers\n",
    "    fichiers_rep = os.listdir(rep)\n",
    "    # 2. on sélectionne uniquement les fichiers avec l'extension (on peut faire une boucle et une condition)\n",
    "    # on crée une liste vide à remplir\n",
    "    liste_fichiers = []\n",
    "    # on fait une boucle sur tous les fihciers et on ajoute à la liste les fichiers avec l'extension voulue\n",
    "    for fichier in fichiers_rep:\n",
    "        if extension == fichier[-len(extension):]:\n",
    "            liste_fichiers.append(fichier)\n",
    "    return liste_fichiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo !\n"
     ]
    }
   ],
   "source": [
    "# pour vérifier que vous avez bien répondu à l'exercice, soumettre cette cellule\n",
    "# on utilise maj + Entrée\n",
    "assert \"telecom.csv\" in recup_fichiers(\"./Data\", \".csv\")\n",
    "print(\"Bravo !\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['housing.csv',\n",
       " 'telecom.csv',\n",
       " 'nba_2013.csv',\n",
       " 'winequality-white.csv',\n",
       " 'US_Unemployment_Oct2012.csv',\n",
       " 'Advertising.csv',\n",
       " 'winequality-red.csv',\n",
       " 'base-dpt.csv',\n",
       " 'titanic.csv']"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recup_fichiers(\"./Data\", \".csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Les packages et les modules en Python\n",
    "\n",
    "- Il s’agit d’un ensemble de fonctions qui pourront être appelées d’un autre programme\n",
    "\n",
    "- On utilise :\n",
    "```\n",
    "import nom_pkg\n",
    "```\n",
    "- Si on utilise `as nm` par exemple, ceci permet de raccourcir l'appel aux fonctions du package\n",
    "- On peut utiliser `from mon_pkg import *`, dans ce cas plus de préfixes mais attention aux conflits\n",
    "- On peut aussi utiliser des fonctions ou des classes spécifiques (plus besoin de préfixe)\n",
    "```\n",
    "from pandas import Series\n",
    "```\n",
    "\n",
    "*Si on cherche des informations sur un module, on peut utiliser `dir()` et `help()`*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0\n",
       "0  3\n",
       "1  5\n",
       "2  7"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandas.DataFrame([3,5,7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0\n",
       "0  3\n",
       "1  5\n",
       "2  7"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame([3,5,7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.io.sas.read_sas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LogisticRegression "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Créer votre module et votre package\n",
    "\n",
    "- Il est très simple de faire appel à des fonctions ou à des classes depuis un autre fichier\n",
    "- Il suffit de stocker vos classes et fonctions dans un fichier `.py`\n",
    "- Celui-ci pourra être stocké dans un répertoire appartenant aux chemins de Python ou dans votre répertoire de travail\n",
    "- Vous avez alors la possibilité de faire :\n",
    "```\n",
    "import mon_fichier\n",
    "```\n",
    "et d’utiliser les fonctions et classes de ce fichiers\n",
    "\n",
    "- Vous venez de créer un module. \n",
    "- **Attention ceci n’est pas un package !**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Créer votre module et votre package (suite)\n",
    "\n",
    "\n",
    "- Un package est constitué de plus d’informations qu’un simple fichier `.py`\n",
    "\n",
    "\n",
    "- Voici les étapes pour créer votre premier package :\n",
    "    - Choisissez un nom simple et traduisant bien ce que va faire votre package (si possible un nom qui n’est pas déjà utilisé)\n",
    "    - Créez un répertoire du nom de votre package\n",
    "    - Créez un fichier `__init__.py` dans ce répertoire, ce fichier peut être vide dans un premier temps\n",
    "    - Dans le même répertoire ajoutez des fichiers avec vos fonctions et vos classes\n",
    "\n",
    "Si votre objectif est de publier le package sur PyPi, il faudra ajouter un fichier setup et les dépendances associées\n",
    "\n",
    "Pour importer votre package dans votre Notebook, il vous suffit de faire:\n",
    "```\n",
    "import nom_dossier.nom_fichier\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Les classes\n",
    "\n",
    "Nous avons manipulé de nombreux objets de classes variées. Si nous voulons aller plus loin, il va falloir manipuler des classes et savoir les créer.\n",
    "\n",
    "Une classe est un type permettant de regrouper dans la même structure :\n",
    "- les informations (champs, propriétés, attributs) relatives à une entité ; \n",
    "- les procédures et fonctions permettant de les manipuler (méthodes)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tous les objets en Python sont obtenus à partir de classes. Ainsi, on voit que lorsqu'on définit un float, le type associé est :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "float_test = 33.33\n",
    "print(type(float_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`float` est donc une classe. Celle-ci possède des propriétés, par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33.33"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# la partie réelle du chiffre\n",
    "float_test.real"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elle possède aussi des méthodes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cette fonction teste si l'objet est un entier\n",
    "float_test.is_integer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Construire une classes\n",
    "\n",
    "- La programmation orientée objet, c’est un style de programmation qui permet de regrouper au même endroit le comportement (les fonctions) et les données (les structures) qui sont faites pour aller ensemble\n",
    "- La notion d’objet en Python concerne toutes les structures Python\n",
    "- L’idée est de créer vos propres objets\n",
    "- La création d’un objet se fait en deux étapes :\n",
    "    - Description de l’objet\n",
    "    - Fabrication de l’objet\n",
    "- La notion de classe en python représente la description de l’objet\n",
    "- La deuxième étape se fait uniquement en allouant des informations à l’objet. L’objet obtenu est une instance de la classe\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Une classe va ressembler à :\n",
    "class MaClasse:\n",
    "    def __init__(self,val1=0,val2=0):\n",
    "        \"\"\" il s'agit ici du constructeur de la classe qui permet \n",
    "        d'initaliser les propriétés de la classe\"\"\"\n",
    "        self.val1 = val1\n",
    "        self.val2 = val2\n",
    "    \n",
    "    def methode1(self,param1):\n",
    "        self.val1 += param1\n",
    "        print(self.val1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette classe permet de créer un objet qui a deux propriétés :\n",
    "    - `val1` initialisée à `0`\n",
    "    - `val2` initialisée à `0`\n",
    "    \n",
    "Elle a en plus une méthode permettant d'ajouter une valeur `param1` à `val1`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# La gestion des exceptions\n",
    "\n",
    "- Python possède un système pour gérer les exceptions\n",
    "- On utilise `try:` et `except:`\n",
    "- On peut intercepter différents types d’erreurs\n",
    "    - `NameError`, `TypeError`, `ZeroDivisionError`\n",
    "- Si on ne veut rien faire dans l’exception on peut utiliser le mot clé `pass`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def ma_fonction(val):\n",
    "    try:\n",
    "        print(val**2)\n",
    "    except:\n",
    "        print(\"Erreur\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Erreur\n"
     ]
    }
   ],
   "source": [
    "ma_fonction(\"r\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exercices :**\n",
    "    \n",
    "Créer une gestion d’exception pour une fonction prenant en entrée deux valeurs puis divisez-les, utiliser les différentes erreurs d’exceptions\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "def division(val1, val2):\n",
    "    try:\n",
    "        return val1 / val2\n",
    "    except ZeroDivisionError:\n",
    "        print(\"Division par 0\")\n",
    "    except TypeError:\n",
    "        print(\"Vous devez entrer des nombres\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vous devez entrer des nombres\n"
     ]
    }
   ],
   "source": [
    "division(\"a\",22)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Division par 0\n"
     ]
    }
   ],
   "source": [
    "division(22,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "division(3,5)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}