03_sas_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# De SAS à python, quelle approche ?\n",
    "\n",
    "Le passage de SAS à Python mérite une reflexion importante.\n",
    "\n",
    "En effet, chaque outil a ses propres forces et faiblesses.\n",
    "\n",
    "### Quand passe-t-on de SAS à Python ?\n",
    "\n",
    "\n",
    "1. Lorsque les achats décident de ne plus payer de licence SAS !!!\n",
    "2. Lorsqu'on veut traiter des données non structurées\n",
    "3. Lorsqu'on désire automatiser des traitements complexes\n",
    "4. Lorsqu'on veut utiliser des méthodes de data science avancées"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Est-ce que c'est économique de passer de SAS à python ?\n",
    "\n",
    "**A long terme OUI**\n",
    "\n",
    "Mais cela a des impacts importants sur l'organisation d'une structure :\n",
    "\n",
    "- Montée en compétence des équipes data\n",
    "- Prise en charge de la maintenance par les équipes SI\n",
    "- Tout n'est pas implémenté en python, il va falloir repenser certains codes\n",
    "- Python n'est qu'un langage de programmation et non un logiciel intégrant plusieurs niveaux\n",
    "\n",
    "Cela a aussi de forts avantages :\n",
    "\n",
    "- Attractivité de l'organisation pour de nouveaux profils data\n",
    "- Ecosystème open source et extrêmement bien documenté\n",
    "- Outils modernes et intégrés\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Si vous êtes habitué à SAS, qu'est-ce qui va changer ?\n",
    "\n",
    "- L'interface de développement\n",
    "  - Elles sont multiples en python\n",
    "\n",
    "\n",
    "- La gestion des tables\n",
    "  - En python, pas de tables stockées \"en dur\", tout est chargé en mémoire --> besoin de plus de mémoire RAM sur les machines ou serveurs\n",
    "  - C'est au développeur de gérer la mémoire utilisée\n",
    "\n",
    "\n",
    "- La gestion des environnements\n",
    "  - Python et ses packages évoluent vite, les versions changent\n",
    "  - Il faut être vigilant sur les outils utilisés\n",
    "  \n",
    "\n",
    "- Il faut penser très vite en mode \"macro\"\n",
    "  - Le passage d'un script à une fonction (macro) est extrêmement simple\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comme évoqué plus tôt, l'objectif n'est en général pas de traduire mot à mot un projet SAS en python mais refléchir à son évolution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les principes\n",
    "\n",
    "En python, tout passe par des fonctions et des classes. Plus d'étapes Data ou de procédure proc, votre code ressemblera à ça :\n",
    "\n",
    "`x = ma_fonction(arg1, arg2...)` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attention `x` n'est pas équivalent à `X`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le signe `=` permet d'instancier (ou de créer) des objets, ainsi on aura :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "chaine1 = \"Python\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ceci permet de créer un objet qui stocke une chaîne de caractère et qu'on pourra réutiliser dans notre code.\n",
    "\n",
    "Pour connaître son type, on utilise :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(chaine1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour afficher l'objet, on utilise la fonction `print()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n"
     ]
    }
   ],
   "source": [
    "print(chaine1)"
   ]
  },
  {
   "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": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "nom_de_variable = \"python\"\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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python Python Python\n"
     ]
    }
   ],
   "source": [
    "print(\"Python\",'Python',\"\"\"Python\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "De nombreuses opérations sur les chaînes : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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": "markdown",
   "metadata": {},
   "source": [
    "Que fait chacune de ces commandes ? (essayez d'expliquer en quelques mots)"
   ]
  },
  {
   "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": 5,
   "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": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "chaine_python2 = ___"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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 booléens\n",
    "\n",
    "- `not`, `and` et `or`\n",
    "- Ordres de priorité\n",
    "    - `not`\n",
    "    - `and`\n",
    "    - `or`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(not True)\n",
    "print(True or False)\n",
    "print(True and False)\n",
    "print(not True and False)\n",
    "print(not True or False)"
   ]
  },
  {
   "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": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bool1 n'est pas un booléen\n"
     ]
    }
   ],
   "source": [
    "bool1=1\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": "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": 12,
   "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": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "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": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_jours = [\"lundi\", \"mardi\", \"mercredi\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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 ___ in ____:\n",
    "    print(_____)"
   ]
  },
  {
   "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": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_temperatures = [15,20,10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": 30,
   "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": "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": "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": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste1 = ____"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "listinit = [2,5,7,12]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "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": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_celsius = [0, 10, 20, 35]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_fahr = ____"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "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": 55,
   "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": 56,
   "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": 6,
   "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": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "dico = {'data_eleves':[5,10,15], 'data_etabl':[2,3,6,9], 'data_acad':[4,7,8]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['data_eleves', 'data_etabl', 'data_acad'])\n",
      "dict_values([[5, 10, 15], [2, 3, 6, 9], [4, 7, 8]])\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": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 10, 15]\n"
     ]
    }
   ],
   "source": [
    "# On accède aux valeurs par clé\n",
    "print(dico[\"data_eleves\"])"
   ]
  },
  {
   "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": 69,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def affichage_produit(val1,val2):\n",
    "    \"\"\"Cette fonction affiche le produit de 2 valeurs\"\"\"\n",
    "    return val1*val2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    }
   ],
   "source": [
    "produit = affichage_produit(4,6)\n",
    "print(produit)"
   ]
  },
  {
   "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": 71,
   "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": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo !\n"
     ]
    }
   ],
   "source": [
    "assert test(2,3) == ___\n",
    "print(\"Bravo !\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo !\n"
     ]
    }
   ],
   "source": [
    "assert test(2,3,4) == ___\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": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def test2(a, b, *args):\n",
    "    val=0\n",
    "    for i in args:\n",
    "        val+=i\n",
    "    return a+b+val"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** Remplacez `___` par la valeur attendue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo !\n"
     ]
    }
   ],
   "source": [
    "assert test2(2,4,6,8) == ___\n",
    "print(\"Bravo !\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo !\n"
     ]
    }
   ],
   "source": [
    "assert test2(2,4) == ____\n",
    "print(\"Bravo !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "On peut aussi stocker les options d'une fonction dans un dictionnaire avec `**kwargs`"
   ]
  },
  {
   "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",
    "renvoie la chaîne \"bravo !\"<br>\n",
    "Sinon, renvoyez la chaîne \"autre\"\n",
    "    \n",
    "*Indice :* on va utiliser la commande `in`, on utilise `\"mot\" in chaine`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "def python_in_str(_____):\n",
    "    ____\n",
    "    return ____"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo\n"
     ]
    }
   ],
   "source": [
    "assert python_in_str(\"la data avec python\") == \"bravo !\"\n",
    "print(\"Bravo !\")"
   ]
  },
  {
   "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": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ma_moyenne(liste1, liste2):\n",
    "    \"\"\" Cette fonction renvoie la moyenne de tous les éléments de deux listes\"\"\"\n",
    "    _____\n",
    "    return ______"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": 92,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['nba_2013.csv', 'winequality-white.csv', 'titanic_train.csv', 'titanic_test.csv', 'US_Unemployment_Oct2012.csv', 'all_instructors_by_airport.geojson', 'excel-data.xlsx', 'us-states.json', 'Use_Case_Covid', 'sfpd_districts.json', 'housing.csv', 'ville.xls', 'winequality-red.csv', 'credit2.xlsx', 'airbnb.csv', 'california.png', 'base-dpt.csv', 'base-dpt.xlsx', 'credit1.txt', 'sfpd_incidents.csv', 'iris.xlsx', 'SMSSpamCollection', 'bce_uai.sas7bdat', 'wind-global.nc', 'titanic', 'mnist', 'vlib.csv', 'salaries.sqlite', 'tour-eiffel.png', 'telecom.csv', 'output', 'Advertising.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": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recup_fichiers(_____):\n",
    "    # 1. on récupère la liste des fichiers\n",
    "    ______\n",
    "    # 2. on sélectionne uniquement les fichiers avec l'extension (on peut faire une boucle et une condition)\n",
    "    ______\n",
    "    return ______"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "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 \"Advertising.csv\" in recup_fichiers(\"./data\", \".csv\")\n",
    "print(\"Bravo !\")"
   ]
  },
  {
   "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": "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": 133,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def ma_fonction(val):\n",
    "    try:\n",
    "        print(val**2)\n",
    "    except TypeError:\n",
    "        print(\"Erreur mauvais type de données\")"
   ]
  },
  {
   "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",
    "\n",
    "https://docs.python.org/3/library/exceptions.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}