Cal4-PythonProg.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<a href=\"http://www.insa-toulouse.fr/\" ><img src=\"http://www.math.univ-toulouse.fr/~besse/Wikistat/Images/logo-insa.jpg\" style=\"float:left; max-width: 120px; display: inline\" alt=\"INSA\"/></a> \n",
    "\n",
    "<a href=\"http://wikistat.fr/\" ><img src=\"http://www.math.univ-toulouse.fr/~besse/Wikistat/Images/wikistat.jpg\" style=\"max-width: 250px; display: inline\"  alt=\"Wikistat\"/></a>\n",
    "\n",
    "<a href=\"http://www.math.univ-toulouse.fr/\" ><img src=\"http://www.math.univ-toulouse.fr/~besse/Wikistat/Images/logo_imt.jpg\" style=\"float:right; max-width: 250px; display: inline\" alt=\"IMT\"/> </a>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a href=\"https://www.python.org/\"><img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/f/f8/Python_logo_and_wordmark.svg/390px-Python_logo_and_wordmark.svg.png\" style=\"max-width: 200px; display: inline\" alt=\"Python\"/></a> [pour Statistique et Science des Données](https://github.com/wikistat/Intro-Python)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Eléments de programmation en  <a href=\"https://www.python.org/\"><img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/f/f8/Python_logo_and_wordmark.svg/390px-Python_logo_and_wordmark.svg.png\" style=\"max-width: 150px; display: inline\" alt=\"Python\"/></a> pour Calcul Scientifique - Statistique"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Résumé**: Compléments de programmation en python: structures de contrôle, programmation fonctionnelle (map, reduce, lambda), introduction aux classes et objets. \n",
    "\n",
    "##  Introduction\n",
    "\n",
    "L'objectif de ce tutoriel est d'introduire quelques outils et concepts plus avancés de la programmation en Python pour dans le but d'améliorer la performance et la lisibilité des codes. Les notions de classe, de programmation objet et celle de *programmation fonctionnelle* qui en découle sont fondamentales. Elles sont fondamentales pour le bon usage de certaines librairie dont *Scikit-learn* (section 3.3). C'est aussi une introduction à l'utilisation des fonctionnalités *MapReduce* parallélisables et donc à la base de l'algorithmique pour données distribuées (*Hadoop*) avec [*PySpark*](https://github.com/wikistat/Ateliers-Big-Data/tree/master/1-Intro-PySpark)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 Structures de contrôle\n",
    "\n",
    "### 1.1 Structure itérative `for`\n",
    "\n",
    "Une boucle `for` permet, comme dans la pluspart des langages de programmation, de parcourir les éléments d'un objet *itérable*. En python cela peut-être une liste, un tuple, une chaîne de caractères (*string*), mais également des objets spécialement conçus pour cela, appelés *iterator*.\n",
    "\n",
    "Syntaxe de la structure `for`:\n",
    "\n",
    "`for` *variable* `in range` *iterator*: \n",
    "<br/> &nbsp;&nbsp;&nbsp;&nbsp;    instruction\n",
    "\n",
    "La ligne `for` se termine par deux points ':'. Le bloc de codes à l'intérieur de la boucle est *indenté*. \n",
    "\n",
    "Voici comment parcourir différentes structures itératives en se souvenant que: **de façon générale, il faut éviter les boucles `for` dans un langage interprété** en utilisant les autres fonctionnalités (section 2) prévues dans les librairies pour parcourir des tableaux ou matrices.\n",
    "\n",
    "\n",
    "\n",
    "##### `range`\n",
    "La fonction `range` produit une liste d'entiers mais aussi un objet itérable d'entiers utilisés au fur et à mesure des itérations de la boucle.\n",
    "\n",
    "**Attention** `xrange` de python2 est remplacé par `range` en python3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print (i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'appel à la fonction range(n) permet d'itérer sur les entiers de 0 à n-1 mais il est possible de spécifier des intervalles des valeurs de chaque pas d'itération: `range(2,11,2) range(10,0,-1)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Strings\n",
    "Les chaînes de caractères sont également des objets parcourables avec la boucle `for`: caractère après caractère."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for character in \"Hi There!\":\n",
    "    print (character)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Dictionnaires\n",
    "Un dictionnaire peut être parcouru terme à terme, cependant, comme la pluspart des objets python, les dictionnaires possèdent des fonctions permettant de les transformer en une liste:\n",
    "\n",
    "    .items()\n",
    "    .keys()\n",
    "    .values()\n",
    "\n",
    "ou un *iterator*\n",
    "\n",
    "    .iteritems()\n",
    "    .iterkeys()\n",
    "    .itervalues()\n",
    "\n",
    "\n",
    "Les dictionnaires n'ont pas de structure ordonnée, les valeurs ne s'affichent pas forcément dans l'ordre dans lequel on les a entrées."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dico={\"a\":1,\"b\":2,\"c\":3}\n",
    "for k in dico.keys():\n",
    "    print (k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les fonctions `.items()` et `.iteritems()` permettent de parcourir les couples (clés, objets) des dictionnaires."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Si une seule variable itérative est spécifiée, celle-ci est un-tuple.\n",
    "for kv in dico.items():\n",
    "    print (kv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Si deux variables itératives sont spécifiées, la première est la clé, la seconde la valeur correspondante\n",
    "for k,v in dico.items():\n",
    "    print (k)\n",
    "    print (v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Si la clé ou la valeur du dictionnaire n'est pas nécessaire, elle n'est pas stockée dans une variable en utilisant \"_\"\n",
    "for k,_ in dico.items():\n",
    "    print (k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Numpy Array\n",
    "La fonction `nditer` permet de parcourir tous les éléments d'un tableau (*array*) *Numpy*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "a = np.arange(6).reshape(2,3)\n",
    "for x in np.nditer(a):\n",
    "    print (x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Appliquer directement la boucle `for` sur le tableau *Numpy* permet de parcourir les différentes lignes de ce tableau."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in a:\n",
    "    print (x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour parcourir les colonnes, la métode la plus simple consiste à parcourir les lignes de la matrice transposée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in a.T:\n",
    "    print (x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est cependant très important de comprendre que les *arrays numpy* ont été conçus pour appliquer des fonctions directement sur l'ensemble du tableau en évitant des boucles. Ainsi nombre de fonctions natives permettent de résoudre de nombreux problèmes sans avoir à parcourir l'ensemble de la matrice: `sum`, `max`, etc... permettent d'obtenir les résultats escomptés de manière bien plus rapide qu'en utilisant les boucles `for`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mina = a.max()              # Retourne la valeur maximum de l'array a\n",
    "minxa = a.max(axis=1)       # Retourne la valeur maximum de chaque ligne de l'array a\n",
    "minya = a.max(axis=0)       # Retourne la valeur maximum de chaque colonne de l'array a\n",
    "print(mina, minxa, minya)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour appliquer des fonctions plus complexes sur chaque ligne et/ou colonne de l'array, il existe également des fonctions natives de la librairie *numpy* permettant d'appliquer ces fonctions efficacement comme par exemple `apply_along_axis`, similaire à `apply` de R. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scale(x):\n",
    "    xcr = (x-np.mean(x))/np.std(x)\n",
    "    return xcr\n",
    "X = np.random.randint(5, size=(3, 3))\n",
    "Xcr = np.apply_along_axis(scale,1,X)\n",
    "print(X, Xcr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Pandas DataFrame\n",
    "De la même manière que pour les arrays *numpy*, les DataFrame *Pandas* ne sont pas conçus pour être parcourus facilement. Il est, là encore, préférable d'utiliser au maximum les méthodes natives de pandas ou de numpy, ou de convertir au préalable les colonnes souhaitées en listes ou encore même de convertir un *DataFrame* en *array* avant un traitemnte itératif.\n",
    "\n",
    "Il éxiste deux fonctions permettant de parcourir les différentes colonnes d'une DataFrame *Pandas*:\n",
    "\n",
    "* `iterrows()`: retourne le couple (index, ligne). Chaque ligne est parcourue sous la forme d'un objet *Series* de *Pandas*. Se construction est très coûteuse et rend la méthode très lente .\n",
    "* `itertuples()`: retoure un object specifique Pandas, où l'index, et les valeurs des colonnes de chaque ligne est accesible via des méthodes spécifiques. Plus rapide que `iterrows`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.DataFrame([[\"A\",4],[\"B\",5],[\"C\",6]],index=[1,2,3],columns=[\"Letter\",\"Number\"])\n",
    "\n",
    "for i,r in df.iterrows():\n",
    "    print(i,r)\n",
    "\n",
    "for ir in df.itertuples():\n",
    "    print(ir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Librarie *Itertools* \n",
    "La librairie native de python *itertools* possède de nombreuses fonctions générant des *iterators*. \n",
    "Plus d'exemples dans la [documentation](https://docs.python.org/3/library/itertools.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "#zip : Concatenne les éléments de plusieurs objets itérables\n",
    "zip_list = []\n",
    "for k in zip('ABCD',[1,2,3,4],\"wxyz\"):\n",
    "    zip_list.append(k)\n",
    "print(\"zip\")\n",
    "print(zip_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#permutation : retourne tous les arrangements possibles de liste de longueur n.\n",
    "permutation_list = []\n",
    "for k in itertools.permutations(\"ABCD\",2):\n",
    "    permutation_list.append(k)\n",
    "print(\"permutations\")\n",
    "print(permutation_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### One-Line Statement\n",
    "Après avoir parouru différents éléments d'un objet itérable et pour enregistrer un résultat pour chaque étape dans une liste, il est possible d'écrire la boucle `for` sur une seule ligne de la manière suivante:\n",
    "\n",
    "[result *for* variable in *iterator*]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Version1\n",
    "A1=[]\n",
    "for k in range(10):\n",
    "    A1.append(k*k)\n",
    "    \n",
    "# Version 2\n",
    "A2 = [k*k for k in range(10)]\n",
    "print(A1,A2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Affectation des indices\n",
    "Des expressions telles que x = x + 1 ou x = x - 2 apparaissent très souvent dans le corps des boucles. Le language Python permet de simplifier ces notations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 17\n",
    "s = \"hi\"\n",
    "a += 3           # Equivalent to a = a + 3\n",
    "a -= 3           # Equivalent to a = a - 3\n",
    "a *= 3           # Equivalent to a = a * 3\n",
    "a /= 3           # Equivalent to a = a / 3\n",
    "a %= 3           # Equivalent to a = a % 3\n",
    "s += \" there\"    # Equivalent to s = s + “ there\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Structure itérative `while`\n",
    "La boucle *for* permet de parcourir l'ensemble des éléments d'un objet itérable, ou un nombre déterminé d'éléments de ce dernier. Cependant, ce nombre n'est pas toujours prévisible et il est possible de parcourir ces éléments et arrêter le parcours lorsqu'une condition est respéctée ou non. C'est l'objet de l'instruction `while` avec la syntaxe:\n",
    "\n",
    "`while` *condition*:\n",
    "<br/> &nbsp;&nbsp;&nbsp;&nbsp;    instructions\n",
    "\n",
    "Cette instruction permet de répéter en boucle les instructions jusqu'à ce que la *condition* soit vérifiée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Incrémentation de `count` jusqu'à ce qu'elle dépasse la valeur 100.000\n",
    "count = 1 \n",
    "while count <= 100000: \n",
    "    count += 1 \n",
    "print (count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'instruction `break` permet de sortir de la boucle `while` même si sa condition est respectée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True: \n",
    "    number = int(input(\"Enter the numeric grade: \")) \n",
    "    if number >= 0 and number <= 100:\n",
    "        break\n",
    "    else:\n",
    "        print (\"Error: grade must be between 100 and 0\" )\n",
    "    print (number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 Structures conditionnelles  `if - else`\n",
    "L'instruction conditionelle `if-else` est une des plus communes en programmation informatique. En python, elle se présente sous la forme suivante:\n",
    "\n",
    "`if` *condition*:\n",
    "<br/> &nbsp;&nbsp;&nbsp;&nbsp;   instructions 1\n",
    "<br/> `else`:\n",
    "<br/> &nbsp;&nbsp;&nbsp;&nbsp;   Instructions 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number=1\n",
    "if number==1:\n",
    "    print (True)\n",
    "else:\n",
    "    print (False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lorsque plus de deux alternative sont possibles, utiliser l'instruction `elif` pour énumérer les différentes possibilités."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number=13\n",
    "if number<5:\n",
    "    print(\"A\")\n",
    "elif number <10:\n",
    "    print(\"B\")\n",
    "elif number <20:\n",
    "    print(\"C\")\n",
    "else:\n",
    "    print(\"D\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### One-Line Statement\n",
    "Comme pour la boucle for, il est possible d'écrire l'instruction `if_else` en une seule ligne lorsque le code est simple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number=10\n",
    "\"A\" if number >10 else \"B\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### One line with for Loop\n",
    "Différentes combinaisons sont possibles pour associer à la fois l'instruction `if_else` avec une boucle `for` en une ligne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Sélectionne uniquement les valeur paire\n",
    "l1 = [k for k in range(10) if k%2==0]\n",
    "l1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Retourne \"even\" si l'élement k est pair, \"odd\" sinon.\n",
    "l2 = [\"even\" if k%2==0 else \"odd\" for k in range(10)]\n",
    "l2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Programmation fonctionnelle \n",
    "L'utilisation de *higher-order functions* permet d'éxecuter rapidement des schémas classiques:\n",
    "\n",
    "* appliquer la même fonction aux éléments d'une liste,\n",
    "* séléctionner, ou non, les différents éléments d'une liste selon une certaine condition,\n",
    "* ...\n",
    "\n",
    "**Important**: il s'agit ici d'introduitre les éléments de *programmation fonctionnelle*, présents dans Python, et utilisés systématiquement, car *parallélisable*, dans des architectures distribuées (*e. g. Hadoop, Spark*).\n",
    "\n",
    "### 2.1 `map`\n",
    "\n",
    "La première de cette fonction est la fonction `map`. Elle permet d'appliquer une fonction sur toutes les valeurs d'une liste et retourne une nouvelle liste avec les résultats correspondants.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "numbers = [random.randrange(-10,10) for k in range(10)]\n",
    "abs_numbers = map(abs,numbers) # Applique la fonction \"valeur absolue\" à tout les élements de la liste\n",
    "print(numbers,list(abs_numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def first_capital_letters(txt):\n",
    "    if txt[0].islower():\n",
    "        txt = txt[0].upper()+txt[1:]\n",
    "    return txt\n",
    "\n",
    "name=[\"Jason\",\"bryan\",\"hercule\",\"Karim\"]\n",
    "list(map(first_capital_letters,name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 `filter`\n",
    "\n",
    "La fonction `filter` permet d'appliquer une fonction test à chaque valeur d'une liste. Si la fonction test est vérifiée, la valeur est ajoutée dans une nouvelle liste. Sinon, la valeur n'est pas prise en compte. La nouvelle liste, constitué de toutes les valeures \"positive\" selon la fonction test, est retournée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_odd(n):\n",
    "    return n % 2 == 1\n",
    "list(filter(is_odd,range(20)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 `reduce` \n",
    "\n",
    "La dernière fonction est la fonction `reduce`. Cette approche est loin d'être intuitive. Le meilleur moyen de comprendre le mode d'emploi de cette fonction est d'utiliser un exemple.\n",
    "\n",
    "L'objectif est de calculer la somme de tous les entier de 0 à 9.\n",
    "\n",
    "- Générer dans un premier temps la liste contenant tout ces éléments `r10 = [0,1,2,3,4,5,6,7,8,9]`\n",
    "- La fonction `reduce`, applique une première fois la fonction `sum_and_print` sur les deux premiers éléments de la liste. \n",
    "- Exécution récursive: la fonction `sum_and_print` est appliquée sur le résultat de la première opération et sur le 3ème éléments de la liste\n",
    "- Itération récursive jusqu'à ce que tous les éléments de la liste soient parcourus\n",
    "\n",
    "La fonction `reduce` a donc deux arguments: une fonction et une liste.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import functools\n",
    "def sum_and_print(x,y):\n",
    "    print(\"Input: \", x,y)\n",
    "    print(\"Output: \", y)\n",
    "    return x+y\n",
    "\n",
    "r10 = range(10)\n",
    "res =functools.reduce(sum_and_print, r10)\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Par défaut, la fonction passée en paramètre de la fonction `reduce` effectue sa première opérations sur les deux premiers éléments de la listes passés en paramètre. Mais il est possible de spécifier une valeur initiale en troisième paramètre. La première opération sera alors effectuée sur cette valeur initiale et le premier élément de la liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def somme(x,y):\n",
    "    return x+y\n",
    "\n",
    "r10 = range(10)\n",
    "res =functools.reduce(somme, r10,1000)\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 `lambda`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'utilisation de fonctions génériques permet de simplifier le code mais il est coûteux de définir une nouvelle fonction qui peut ne pas être réutilisée, comme par exemple celle de l'exemple précédent.\n",
    "L'appel `lambda` permet de créer une fonction de façon temporaire. La définition de ces fonctions est assez restrictive, puisqu'elle implique une définition sur *une seule ligne*, et ne permet pas d'assignation. \n",
    "\n",
    "Autre point important, l'exécution de cette fonction sur des données distribuées est implicitement parallélisée.\n",
    "\n",
    "Ainsi les précédents exemples peuvent-être ré-écrits de la manière suivante:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name=[\"Jason\",\"bryan\",\"hercule\",\"Karim\"]\n",
    "list(map(lambda x : x[0].upper()+x[1:] if x[0].islower() else x,name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(filter(lambda x : x % 2 == 1 ,range(10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r10 = range(10)\n",
    "res =functools.reduce(lambda x,y:x+y, r10,1000)\n",
    "res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Classes et objets\n",
    "### 3.1 Définitions et exemples\n",
    "Les classes sont des objets communs à tous les langages orientés objets. Ce sont des objets constitués de\n",
    "\n",
    "- *attributs*: des paramètres fixes, de différentes natures, attribués à l'objet, \n",
    "- *méthodes*: des fonctions qui permettent d'appliquer des transformations sur ces attributs. \n",
    "\n",
    "Ci dessous on définit une classe \"Elève\" dans laquelle un élève est décrit par son nom, son prénom et ses notes. On notera la *convention de nommage* des méthodes qui commence par une minuscule, mais qui possède une majuscule à chaque début de nouveau mot. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Eleve:\n",
    "    \"\"\"Classe définissant un élève caractérisé par:\n",
    "        - son nom\n",
    "        - son prénom\n",
    "        - ses notes\n",
    "     \"\"\"  \n",
    "    \n",
    "    def __init__(self, nom, prenom): #constructeur de la classe\n",
    "        \"\"\" Construit un élève avec les nom et prenom passé en paramètre et une liste de notes vide.\"\"\"\n",
    "        self._nom = nom\n",
    "        self._prenom=prenom\n",
    "        self._notes = []\n",
    "        \n",
    "    def getNom(self):\n",
    "        \"\"\" retourne le nom de l'élève \"\"\"\n",
    "        return self._nom\n",
    "    \n",
    "    def getNotes(self):\n",
    "        \"\"\" retourne les notes de l'élève\"\"\"\n",
    "        return self._notes\n",
    "    \n",
    "    def getNoteMax(self):\n",
    "        \"\"\" retourne la note max de l'élève\"\"\"\n",
    "        return max(self._notes)\n",
    "    \n",
    "    def getMean(self):\n",
    "        \"\"\" retourne la moyenne de l'élève\"\"\"\n",
    "        return np.mean(self._notes)\n",
    "    \n",
    "    def getNbNote(self):\n",
    "        \"\"\" retourne le nombre de note de l'élève\"\"\"\n",
    "        return len(self._notes)\n",
    "    \n",
    "    def addNote(self, note):\n",
    "        \"\"\" ajoute la note 'note' à la liste de note de l'élève\"\"\"\n",
    "        self._notes.append(note)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Toutes les classes sont composées d'un *constructeur* qui a pour nom \\_\\_init\\_\\_. Il s'agit d'une méthode spéciale d'instance que Python reconnaît et sait utiliser dans certains contextes. La fonction \\_\\_init\\_\\_ est automatiquement appelée à la création d'une nouvelle classe et prend en paramètre `self`, qui représente l'objet instantié, et les différents attributs nécessaires à sa création."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eleve1 = Eleve(\"Jean\",\"Bon\")\n",
    "eleve1._nom"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les attributs de la classe sont directement accessibles de la manière suivante:\n",
    "\n",
    "`objet.nomDeLAtribbut`\n",
    "\n",
    "Cependant, par convention, il est conseillé de définir une méthode pour avoir accès à cet objet.\n",
    "Les méthodes qui permettent d'accéder à des attributs de l'objets sont appelés des *accessors*. Dans la classe élève, les méthodes commençant par `get` sont des *accessors*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eleve1.getNom()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les méthodes permettant de modifier les attributs d'un objet sont appelées des *mutators*. La fonction `addNote`, qui permet d'ajouter une note à la liste de notes de l'élève est un *mutator*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(eleve1.getNotes())\n",
    "eleve1.addNote(15)\n",
    "print(eleve1.getNotes())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in range(10):\n",
    "    eleve1.addNote(np.random.randint(20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (eleve1.getNbNote())\n",
    "print (eleve1.getNoteMax())\n",
    "print (eleve1.getMean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Héritage\n",
    "\n",
    "L'*héritage* est une fonctionnalité qui permet de définir une classe \"fille\" à  partir d'une autre classe \"mère\". La classe fille hérite alors  automatiquement de tous les attributs et de toutes les méthodes de la classe mère.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EleveSpecial(Eleve):\n",
    "    \n",
    "    def __init__(self, nom, prenom, optionName):\n",
    "        Eleve.__init__(self, nom, prenom)\n",
    "        self._optionName = optionName\n",
    "        self._optionNotes = []\n",
    "\n",
    "    def getNotesOption(self):\n",
    "        \"\"\" retourne les notes de l'élève\"\"\"\n",
    "        return self._optionNotes\n",
    "    \n",
    "    def addNoteOption(self, note):\n",
    "        \"\"\" ajoute la note 'note' à la liste de note de l'élève\"\"\"\n",
    "        self._optionNotes.append(note)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eleve2 = EleveSpecial(\"Sam\",\"Stress\",\"latin\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eleve2.addNote(14)\n",
    "print (eleve2.getNotes())\n",
    "eleve2.addNoteOption(12)\n",
    "print (eleve2.getNotesOption())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Classes de  *Scikit-learn*\n",
    "\n",
    "Les méthodes d'apprentissage statistique de la librairie *Scikit-learn* sont un parfait exemple d'utilisation de classes. Sans entrer en détail dans l'implémentation de cette méthode, voici l'exemple de la Régression linéaire par moindres carrés. \n",
    "\n",
    "**Toutes** les fonctions de *Scikit-learn* sont définies sur de modèle. Voir dans le [tutoriel d'apprentissage statistique](https://github.com/wikistat/Intro-Python) avec *Scikit-learn* comment ces propriétés sont utilisées pour enchaîner (*pipeline*) des exécutions.\n",
    "\n",
    "L'objet [`LinearRegression`](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) est une classe qui est initée avec des attributs suivants:\n",
    "\n",
    "- `fit_intercept` : si le terme constant doit être estimé ou considéré à 0\n",
    "- `normalize` : si le jeux d'apprentissage doit être normalisé avant la regression\n",
    "- `copy_X` : si le jeux d'apprentissage doit être copié pour éviter les effets de bords\n",
    "- `n_jobs` : le nombre de processeur à utiliser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "lr = LinearRegression(fit_intercept=True, normalize=False, copy_X=True, n_jobs=1)\n",
    "print (lr.fit_intercept, lr.normalize, lr.copy_X, lr.n_jobs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La classe `LinearRegression` possède également des attributs qui sont mis à jour à l'aide des *méthodes*:\n",
    "\n",
    "- `coef_` : coefficients estimés \n",
    "- `residues_` : somme des résidus\n",
    "- `intercept_` : terme constant\n",
    "\n",
    "La méthode `fit` de cette classe est un *mutator*. Elle prend en paramètre le jeux d'apprentissage, `X_train` et la variable réponse correspondante `Y_train` pour estimer les paramètres de la regression linéaire et ainsi mettre à jour les attributs correspondants."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train=[[0, 0], [1, 1], [2, 2]]\n",
    "Y_train =  [0, 1, 2]\n",
    "lr.fit (X_train, Y_train)\n",
    "lr.coef_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La classe `LinearRegression` possède aussi d'autres *méthodes* qui utilisent les attributs de la classe. Par exemple:\n",
    "\n",
    "- `predict`: estime la prévision de  la variable réponse d'un jeu test `X_test`\n",
    "- `score`: retourne le coefficient *R2* de qualité de la prévision.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test = [[1.5,1.5],[2,4],[7.3,7.1]]\n",
    "Y_test = [1.5,2.4,7]\n",
    "pred = lr.predict(X_test)\n",
    "s = lr.score(X_test,Y_test)\n",
    "print(pred,s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 4 *Packing* et *Unpacking*\n",
    "Section plus technique qui peut être sautée en première lecture.\n",
    "\n",
    "L'opérateur `*` permet, selon la situation, de \"paquéter\" ou \"dépaquéter\" les éléments d'une liste.\n",
    "\n",
    "L'opérateur `**` permet, selon la situation, de \"paquéter\" ou \"dépaquéter\" les éléments d'un dictionnaire."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 *Unpacking*\n",
    "\n",
    "Dans l'exemple ci-dessous. Les opérateurs \\* et \\*\\*  dépaquettent les listes et dictionnaires pour les passer en arguments de fonctions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unpacking_list_and_print(a, b):\n",
    "    print (a)\n",
    "    print (b)\n",
    "listarg = [3,4]\n",
    "unpacking_list_and_print(*listarg)\n",
    "    \n",
    "def unpacking_dict_and_print(k1=0, k2=0):\n",
    "    print (k1)\n",
    "    print (k2)\n",
    "dictarg = {'k1':4, 'k2':8}\n",
    "unpacking_dict_and_print(**dictarg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 *Packing*\n",
    "Ces opérateurs sont surtout utiles dans le sens du \"packing\". Les fonctions sont alors définies de sorte à recevoir un nombre inconnu d'argument qui seront ensuite \"paquétés\" et traités dans la fonction.\n",
    "\n",
    "L'argument `*args` permet à la fonction de recevoir un nombre supplémentaire inconnu d'arguments sans mot-clef associé."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def packing_and_print_args(required_arg, *args):\n",
    "    print (\"arg Nécessaire:\", required_arg)\n",
    "    for i, arg in enumerate(args):\n",
    "        print (\"args %d:\" %i, arg)\n",
    "\n",
    "packing_and_print_args(1, \"two\", 3)\n",
    "packing_and_print_args(1, \"two\", [1,2,3],{\"a\":1,\"b\":2,\"c\":3})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'argument `**kwargs` permet à la fonction de recevoir un nombre supplémentaire inconnu d'arguments avec mot-clef."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def packing_and_print_kwargs(def_kwarg=2, **kwargs):\n",
    "    print (\"kwarg défini:\", def_kwarg)\n",
    "    for i,(k,v) in enumerate(kwargs.items()):\n",
    "        print (\"kwarg %d:\" %i ,k , v) \n",
    "\n",
    "packing_and_print_kwargs(def_kwarg=1, sup_arg1=\"two\", sup_arg2=3)\n",
    "packing_and_print_kwargs(sup_arg1=\"two\", sup_arg2=3, sup_arg3=[1,2,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les arguments `*args` et `**kwargs` peuvent être combinés dans une autre fonctions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def packing_and_print_args_and_kwargs(required_arg ,def_kwarg=2, *args, **kwargs):\n",
    "    print (\"arg Nécessaire:\", required_arg)\n",
    "    for i, arg in enumerate(args):\n",
    "        print (\"args %d:\" %i, arg)\n",
    "    print (\"kwarg défini:\", def_kwarg)\n",
    "    for i,(k,v) in enumerate(kwargs.items()):\n",
    "        print (\"kwarg %d:\" %i ,k , v )\n",
    "\n",
    "packing_and_print_args_and_kwargs(1, \"two\", [1,2,3] ,sup_arg1=\"two\", sup_arg2=3 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ces deux opérateurs sont très utiles pour gérer des classes liées par des héritages. Les arguments `*args **kwargs` permettent alors de gérer la tranmission de cet héritage sans avoir à redéfinir les arguments à chaque étape."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Objet(object):\n",
    "    def __init__(self, attribut=None, *args, **kwargs):\n",
    "        print (attribut)\n",
    "\n",
    "class Objet2Point0(Objet):\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        super(Objet, self).__init__(*args, **kwargs)\n",
    "\n",
    "class Objet3Point0(Objet2Point0):\n",
    "    def __init__(self,attribut2=None, *args, **kwargs):\n",
    "        super(Objet2Point0, self).__init__(*args, **kwargs)\n",
    "        print (attribut2)\n",
    "\n",
    "my_data = {'attribut': 'Argument1', 'attribut2': 'Argument2'}\n",
    "Objet3Point0(**my_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Référence\n",
    "\n",
    "**Lambert K. et Osborne M.** (2010). *Fundamentals of Python: From First Programs Through Data Structures*, Course Technology."
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.4"
  },
  "toc": {
   "nav_menu": {
    "height": "330px",
    "width": "252px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}