Cal1-introPython.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=\"float:right; max-width: 250px; display: inline\"  alt=\"Wikistat\"/></a>\n",
    "\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": [
    "# Introduction à <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é** Présentation de pyhton, exécution de commandes interactives ou de scripts avec un IDE, utilisation d'un calepin; les types et structures élémentaires de données, les structures de contrôle, les fonctions, classes et modules. Introduction à l'utilisation des librairies scientifiques: `Numpy, Matplotlib, Scipy` et au type `array`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Prérequis\n",
    "Ce calepin introduit le langage libre Python et décrit les premières commandes nécessaires au pré-traitement des données avant l'utilisation de méthodes statistiques avec ce langage ou avec R. Les aspects statistiques développés dans les différentes vignettes de [Wikistat](http://wikistat.fr) sont supposés acquis ainsi qu'une connaissance des principes élémentaires de programmation dans un langage matriciel comme R ou Matlab. \n",
    "\n",
    "Pour des approfondissements, il existe de très nombreuses ressources pédagogiques accessibles sur la toile dont le [tutoriel officiel](https://docs.python.org/3/tutorial/index.html) de Python 3.4., les sites [`pythontutor.com`](http://pythontutor.com/), [`courspython.com`](http://www.courspython.com/), le livre de [Sheppard (2014)](http://www.kevinsheppard.com/images/0/09/Python_introduction.pdf) qui présentent une introduction à Python pour l'\\'Econométrie et la Statistique et celui de [Mac Kinney (2013)](http://it-ebooks.info/book/1041/), principal auteur de la bibliothèque `pandas`. \n",
    "\n",
    "### 1.2 Installation\n",
    "Python et ses librairies peuvent être installés dans quasiment tout environnement matériel et système d'exploitation à partir du [site officiel](https://www.python.org/downloads/). Voici les principales librairies scientifiques définissant des structures de données et fonctions de calcul indispensables. \n",
    "- `ipython`: pour une utilisation interactive de Python, \n",
    "- `numpy`: pour utiliser vecteurs et tableaux, \n",
    "- `scipy`: intègre les principaux algorithmes numériques, \n",
    "- `matplotlib`: pour les graphes, \n",
    "- `pandas`: structure de données et feuilles de calcul, \n",
    "- `patsy`: formules statistiques,\n",
    "- `statsmodels`: modélisation statistique,\n",
    "- `seaborn`: visualisation de données,\n",
    "- `scikit-learn`: algorithmes d'apprentissage statistique.\n",
    "\n",
    "Néanmoins, compte tenu de la complexité de l'opération, il est plus simple pour le néophyte, surtout sous Windows, de faire appel à une procédure d'installation intégrant les principales librairies. Ces procédures sont développées par des entreprises commerciales mais libres de droits pour une utilisation académique.\n",
    "- *Continuum Analytics* propose [Anaconda](https://store.continuum.io/cshop/anaconda/) avec au choix la version 3.4 ou celle 2.7. `Conda` est l'utilitaire (commande en ligne) qui permet les mises à jour et installations des librairies complémentaires.\n",
    "- *Enthought* propose [Canopy](https://www.enthought.com/products/canopy/) qui n'installe pour le moment que la version 2.7 et intègre un *package manager* avec interface graphique. Attention, certaines librairies même \"collectives\" ne sont disponibles que dans la version commerciale ou celle \"académique\" de Canopy après inscription. \n",
    "\n",
    "D'un point de vue légal, les propositions sont identiques mais Canopy nécessite la création d'un compte académique. Seul \"souci\", ces versions n'incluent que les versions dites stables des différentes librairies et donc avec un temps de retard vis-à-vis des versions encore développement.\n",
    "\n",
    "C'est [Anaconda](https://store.continuum.io/cshop/anaconda/) qui est utilisée ici, car préférable pour un poste personnel, en version 2.7; C'est aussi la version installée par le CSN de l'INSA dans les salles de TP.\n",
    "\n",
    "## 2 Utilisation de Python\n",
    "Python exécute programmes ou scripts, programmes qui peuvent être pré-compilés pour plus d'efficacité. Ce langage s'exécute également à l'aide d'un interprète de commande (`IDLE`) ou {`IPython`) de manière interactive.  En situation pédagogique, c'est l'utilisation et la réalisation d'un *notebook Ipython* (calepin) ou plutôt maintenant *Jupyter* qui est privilégiée à partir d'un simple navigateur (éviter *internet explorer*).\n",
    "\n",
    "\n",
    "### 2.1 Calepin *Jupyter*\n",
    "\n",
    "Les commandes sont regroupées dans des cellules suivies de leur résultat après exécution. Ces résultats et commentaires sont  stockés dans un fichier spécifique `.ipynb` et sauvegardés. Les commandes LaTeX sont acceptées pour intégrer des formules, la mise en page est assurée par des balises HTML ou [*Markdown*](http://fr.wikipedia.org/wiki/Markdown). \n",
    "\n",
    "La commande de sauvegarde permet également d'extraire les seules commandes Python dans un fichier d'extension `.py`. C'est une façon simple et efficace de conserver tout l'historique d'une analyse pour en faire une présentation ou créer un tutoriel. Le calepin peut être en effet chargé  sous un autre format: page `html`, fichier `.pdf` ou diaporama.\n",
    "\n",
    "Le projet [Jupyter](http://jupyter.org/) propose cet environnement de calepin pour beaucoup de langages (Pyhton, Julia, Scala...) dont R. Il devient un outil indispensable pour assurer simplement la *reproductibilité* des analyses. \n",
    "\n",
    "L'ouverture d'un navigateur sur un calepin (Ipython ou Jupyter) est obtenu, selon l'installation,  à partir des menus ou en exécutant: \n",
    "`jupyter notebook`\n",
    "ou \n",
    "`ipython notebook` \n",
    "dans une fenêtre de commande.\n",
    "Une fois le calepin ouvert, \n",
    "- Entrer des commandes Python dans une cellule,\n",
    "- Cliquer sur le bouton d'exécution de la cellule.\n",
    "- Ajouter une ou des cellules de commentaires et balises HTML ou [Markdown](http://fr.wikipedia.org/wiki/Markdown).\n",
    "Itérer l'ajout de cellules. Une fois l'exécution terminée:\n",
    "- Sauver le calepin `.ipynb` \n",
    "- Charger éventuellement une version `.html` pour une page web.\n",
    "- Charger le fichier `.py` regroupant les commandes python pour une version opérationnelle.\n",
    "\n",
    "**Attention** Un calepin de IPython ou Jupyter est un outil de travail exploratoire efficace et un compte rendu nécessairement *chronologique* d'exécution; ce n'est pas le *rapport* d'une étude statistique dont l'organisation suit des [règles spécifiques](http://wikistat.fr/pdf/st-m-redac-rapport-stat.pdf). \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "### 2.2 IDE  `Spyder`\n",
    "Pour la réalisation d'applications et programmes plus complexes, l'usage d'un IDE (*integrated Development Environment*) libre comme [Spyder](http://code.google.com/p/spyderlib/) est recommandé. Ce dernier est intégré à la distribution `Anaconda` et sa présentation  proche de celles de Matlab ou RStudio. Cet environnement exécutant IPython reconnaît évidemment les commandes précédentes. \n",
    " \n",
    "Comme pour RStudio, `Spider` ouvre plusieurs fenêtres:\n",
    "- un éditeur de commandes dont les boutons du menu exécutent tout le fichier ou interactivement la cellule courante, sauvent le fichier, contrôlent le débogage. Une cellule débute par la balise: `#%%`.\n",
    "- Un explorateur d'objets avec aide en ligne, des variables en cours, du répertoire courant. Les boutons de l'explorateur de variables permettent de supprimer, sauver les objets créés ou encore d'importer des données.\n",
    "- La console IPython avec les résultats et son historique.\n",
    "\n",
    "### 2.3 Exemple\n",
    "En résumé, utiliser un calepin pour des analyses exploratoires élémentaires et un IDE `Spyder` ou `Eclipse` (un peu compliqué!) pour la construction de programmes et modules. \n",
    "\n",
    "Selon l'installation et à partir du répertoire de travail, exécuter la commande:\n",
    "\n",
    "`jupyter notebook` \n",
    " \n",
    "qui ouvre le navigateur par défaut. \n",
    "\n",
    "Sur les postes géré par le CSN de l'INSA, si cela ne marche pas, il peut être nécessaire d'ajouter une variable d'environnement:\n",
    "\n",
    "`export PATH=/usr/local/insa/anaconda/bin:$PATH`\n",
    "\n",
    "Entrer les commandes ci-dessous dans le calepin et les exécuter cellule par cellule en cliquant sur le bouton d'exécution de la cellule courante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Ceci est le début d'une session Python gérée à l'aide d'un calepin.\n",
    "# Le script est divisé en cellules avec généralement l'affichage d'au plus un résultat par cellule.\n",
    "## Importer les librairies nécessaires \n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from pylab import *\n",
    "import os \n",
    "## Définir si nécessaire le répertoire courant spécifique \n",
    "##  à l'utilisateur\n",
    "os.chdir(r'.')\n",
    "## Commande magique pour obtenir les graphiques dans le calepin\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#%% Créer un data frame avec pandas\n",
    "data = pd.DataFrame({\n",
    "    'Gender': ['f', 'f', 'm', 'f', 'm', 'm', 'f', 'm', 'f', 'm'],\n",
    "    'TV': [3.4, 3.5, 2.6, 4.7, 4.1, 4.0, 5.1, 4.0, 3.7, 2.1]})\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Génération de variables aléatoires gaussiennes\n",
    "xx = randn(100,100)\n",
    "y = mean(xx,0)\n",
    "# graphique\n",
    "plot(y)\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Types de données"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Scalaires et chaînes\n",
    "La déclaration des variables est implicite ({integer, float, boolean, string), la syntaxe est très proche de celle de R mais il n'y a pas de type `factor`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=3  # est un entier\n",
    "b=1. # est un flottant\n",
    "# Attention:\n",
    "a/2  # a pour résultat 1.5 en Python 3.4 \n",
    "     # mais 1 en 2.7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Opérateurs de comparaison : `==, >, <, !=` de résultat booléen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Comparaison\n",
    "a==b  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  affichage et type des variables\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Chaîne de caractère\n",
    "a='bonjour '\n",
    "b='le '\n",
    "c='monde'\n",
    "a+b+c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attention à l'encodage des caractères. Ce n'est pas le même en python 2 (ascii) et python 3 (utf-8). Ce n'est pas fait dans ces exemples élémentaires mais il est vivement recommander de gérer systématiquement des textes complexes avec caractères spéciaux (accents, guillements...) en utf-8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=u'bonjour' # encodage utf-8\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a='bonjour'  # encodage ascii\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Structures de base"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Listes\n",
    "Les listes permettent des combinaisons de types. \n",
    "**Attention**, le premier élément d'une liste ou d'un tableau est indicé par **0**, pas par 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# exemples de listes\n",
    "liste_A = [0,3,2,'hi']\n",
    "liste_B = [0,3,2,4,5,6,1]\n",
    "liste_C = [0,3,2,'hi',[1,2,3]]    \n",
    "# Elément d'une liste \n",
    "liste_A[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_C[-1] #  dernier élément"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_C[-1][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_C[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_B[0:2] #  Sous-liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_B[0:5:2]  # début:fin:pas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_B[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonctions de listes\n",
    "List=[3,2,4,1]\n",
    "List.sort() \n",
    "print(List)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "List.append('hi')\n",
    "print(List)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "List.count(3) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "List.extend([7,8,9])\n",
    "print(List)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "List.append([10,11,12])\n",
    "print(List)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### t-uple\n",
    "Un tuple est similaire à une liste mais ne peut être modifié, il est défini par des parenthèses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MyTuple=(0,3,2,'h')\n",
    "MyTuple[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MyTuple[1]=10 # TypeError: \"tuple\" object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionnaire\n",
    "Un dictionnaire est similaire à une liste mais chaque entrée est assignée par une clé / un nom, il est défini avec des accolades. Cet objet est utilisé pour la construction de l'index des colonnes (variables) du type *DataFrame* de la librairie `pandas`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "months = {'Jan':31 , 'Fev': 28, 'Mar':31}\n",
    "months['Jan'] \t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "months.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "months.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "months.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Syntaxe de Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 Structures de contrôle élémentaires\n",
    "Un bloc de commandes ou de codes est défini par *deux points suivis d'une indentation fixe*.  Cela oblige à l'écriture de codes faciles à lire mais à être très attentif sur la gestion des indentations car la fin d'indentation signifie la fin d'un bloc de commandes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Structure conditionnelle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# si alors sinon\n",
    "a=2\n",
    "if a>0:\n",
    "    b=0\n",
    "    print(b)\n",
    "else:\n",
    "    b=-1\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Structure itérative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1,8,2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Définition d'une fonction\n",
    "def pythagorus(x,y):\n",
    "    \"\"\" Calcule l'hypotenuse d'un triangle \"\"\"\n",
    "    r = pow(x**2+y**2,0.5)\n",
    "    return x,y,r\n",
    "pythagorus(3,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 Fonctions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# exemple d'appel\n",
    "pythagorus(x=3,y=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# aide intégrée\n",
    "help(pythagorus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pythagorus.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Valeurs des paramètres par défaut\n",
    "def pythagorus(x=1,y=1):\n",
    "    \"\"\" calcule l'hypoténuse d'un triangle \"\"\"\n",
    "    r = pow(x**2+y**2,0.5)\n",
    "    return x,y,r\n",
    "pythagorus()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.4 Modules et librairies\n",
    "#### Modules \n",
    "Un module contient plusieurs fonctions et commandes qui sont regroupées dans un fichier d'extension `.py`. Insérer un fichier vide de nom `_init_.py` dans chaque dossier et sous-dossier contenant un module à importer.  Un module est appelé par la commande `import`. Un module est considéré comme un script s'il contient des commandes. Lors de l'import d'un script, les commandes sont exécutées tandis que les fonctions sont seulement chargées."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Commencer par définir un module dans un fichier texte contenant les commandes suivantes.\n",
    "\n",
    "``\n",
    "def DitBonjour():\n",
    "    print(\"Bonjour\")\n",
    "def DivBy2(x):\n",
    "    return x/2\n",
    "``\n",
    "\n",
    "Sauver le fichier avec pour nom `testM.py` dans le répertoire courant.\n",
    "\n",
    "Il est possible d'importer toutes les fonctions en une seule commande `import`. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import testM\n",
    "testM.DitBonjour()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(testM.DivBy2(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from testM import *\n",
    "DitBonjour()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(DivBy2(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou seulement celles qui seront utilisées. Préférer cette dernière méthode pour les grosses librairies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import testM as tm\n",
    "tm.DitBonjour()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(tm.DivBy2(10))\n",
    "# délétion des objets\n",
    "%reset "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from testM import DitBonjour\n",
    "DitBonjour()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(DivBy2(10)) # erreur"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lors de son premier appel, un module est pré-compilé dans un fichier `.pyc` qui est utilisé pour les appels suivants. **Attention**, si le fichier a été modifié / corrigé, il a besoin d'être rechargé par la commande `reload(name)`.\n",
    "\n",
    "Une librairie (*package*) regroupe plusieurs modules dans différents sous-répertoires. Le chargement spécifique d'un des modules se fait en précisant le chemin. \n",
    "`import sound.effects.echo`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Calcul scientifique\n",
    "Voici trois des principales librairies indispensables au calcul scientifique. Deux autres librairies: `pandas`, `scikit-learn`, sont exposées en détail dans des calepins spécifiques."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1 Principales librairies ou *packages*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `NumPy`\n",
    "Cette librairie définit le type de données `array` ainsi que les fonctions de calcul qui y sont associées. Il contient aussi quelques fonctions d'algèbre linéaire et statistiques. \n",
    "Il n'est finalement utilisé que pour la définition du type `array` car les fonctions numériques sont beaucoup plus développées dans  `SciPy`. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `Matplotlib`\n",
    "Celle-ci propose des fonctions de visualisation / graphs avec des commandes proches de celles de Matlab. Aussi connue sous le nom de `pylab`. La [gallerie](http://matplotlib.org/1.3.1/gallery.html) de cette librairie propose tout un ensemble d'exemples de graphiques avec le code Python pour les générer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importation\n",
    "import numpy as np\n",
    "from pylab import *\n",
    "gaussian = lambda x: np.exp(-(0.5-x)**2/1.5)\n",
    "x=np.arange(-2,2.5,0.01)\n",
    "y=gaussian(x)\n",
    "plot(x,y)\n",
    "xlabel(\"x values\")\n",
    "ylabel(\"y values\")\n",
    "title(\"Gaussian function\")\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `SciPy`\n",
    "Cette librairie est un ensemble très complet de modules d'algèbre linéaire, statistiques et autres algorithmes numériques. Le site  de la documentation en fournit la [liste](http://docs.scipy.org/doc/scipy/reference). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2 Type Array\n",
    "C'est de loin la structure de données la plus utilisée pour le calcul scientifique sous Python. Elle décrit des tableaux ou *matrices* multi-indices de dimension $ n = 1, 2, 3, \\ldots , 40$. Tous les éléments sont de même type (booléen, entier, réel, complexe). \n",
    "\n",
    "Il est possible de contrôler précisément le type d'un `array`, par exemple pour gagner  de la place en mémoire, en codant les entiers sur 8, 16, 32 ou 64 bits, de même pour les réels (*float*) ou les complexes.\n",
    "\n",
    "Les tableaux ou tables de données (*data frame*), bases d'analyses statistiques et regroupant des objets de types différents  sont décrits avec la librairie `pandas`.\n",
    "#### Définition du type `array`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importation\n",
    "import numpy as np\n",
    "my_1D_array = np.array([4,3,2])\n",
    "print(my_1D_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_2D_array = np.array([[1,0,0],[0,2,0],[0,0,3]])\n",
    "print(my_2D_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myList=[1,2,3]\n",
    "my_array = np.array(myList)\n",
    "print(my_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=np.array([[0,1],[2,3],[4,5]])\n",
    "a[2,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[:,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fonctions de type `array`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.arange(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.ones(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.ones((3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.eye(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.linspace(3, 7, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mgrid[0:3,0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=np.diag([1,2,4,3])\n",
    "print(D)\n",
    "print(np.diag(D))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M=np.array([[10*n+m for n in range(3)] \n",
    "for m in range(2)]) \n",
    "print(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le module `numpy.random` fournit toute une liste de fonctions pour la génération de matrices aléatoires."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import random\n",
    "random.rand(4,2) #tirage uniforme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "random.randn(4,2) #tirage selon la loi N(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v=random.randn(1000)\n",
    "import matplotlib.pyplot as plt\n",
    "h=plt.hist(v,20) # histogramme à 20 pas\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=random.randn(64,64)\n",
    "plt.imshow(A,interpolation=\"nearest\")\n",
    "plt.colorbar\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Sauver, écrire dans un fichier, lire un fichier\n",
    "M=random.randn(10,10)\n",
    "np.savetxt('data.csv',M,fmt='%2.2f',delimiter=',')\n",
    "#au format propre à numpy : npy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('data.npy',M)\n",
    "np.load('data.npy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### *Slicing*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v=np.array([1,2,3,4,5])\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v[1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v[1:4:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v[::]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v[ : :2] # par pas de 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v[ : 3] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v[3 :] # à partir de l'indice 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v[-1] # dernier élément"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v[-2 :] # deux derniers éléments "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M=random.rand(4,3) \n",
    "print(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ind=[1,2]\n",
    "M[ind] # lignes d'indices 1 et 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M[:,ind] # colonnes d'indices 1 et 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M[[0,2],[1,2]] # renvoie M[0,1] et M[2,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M[np.ix_([0,2],[1,2])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(M>0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M[M>0.5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Autres fonctions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=np.array([[0,1],[2,3],[4,5]])\n",
    "np.ndim(a) # Nombre de dimensions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.size(a) # Nombre d’éléments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.shape(a) # Tuple contenant la dimension de a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.transpose(a) # Transposée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.T # autre façon de définir la transposée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.min(), np.min(a)  # Valeur min"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.sum(), np.sum(a)  # Somme des valeurs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.sum(axis=0)  # Somme sur les colonnes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.sum(axis=1)  # sur les lignes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quelques manipulations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.r_[1:4,10,11]  # Concaténation en ligne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.c_[1:4,11:14]  # Concaténation en colonne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.c_[1:4,11:15]  # erreur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.arange(6).reshape(3,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=np.array([[1,2],[3,4]])\n",
    "np.tile(A,(3,2)) # Répétition de la matrice A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=np.array([[1,2],[3,4]])\n",
    "B=np.array([[11,12],[13,14]])\n",
    "#Concaténation en ligne\n",
    "np.concatenate((A,B),axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Equivalent à\n",
    "np.vstack((A,B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Concaténation en colonne\n",
    "np.concatenate((A,B),axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Equivalent à\n",
    "np.hstack((A,B))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Opérations sur les `array`s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# somme\n",
    "a=np.arange(6).reshape(3,2)\n",
    "b=np.arange(3,9).reshape(3,2)\n",
    "c=np.transpose(b)\n",
    "a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a*b # produit terme à terme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.dot(a,c) # produit matriciel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.power(a,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.power(2,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a/3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les fonctions `genfromtxt`, `avetxt` permettent de lire, écrire des fichiers textes par exemple au format `.csv` mais ces fonctionnalités sont plus largement abordées avec la librairie `pandas`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fonctions d'algèbre linéaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importation\n",
    "import numpy as np\n",
    "from scipy import linalg\n",
    "A = np.array([[1,2],[3,4]])\n",
    "linalg.inv(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "linalg.det(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "la,v = linalg.eig(A)\n",
    "l1,l2 = la\n",
    "# valeurs propres\n",
    "print(l1, l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1er vecteur propre\n",
    "print(v[:,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SVD de A\n",
    "U,s,V = linalg.svd(A) \n",
    "print(s**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "linalg.eig(np.dot(np.transpose(A),A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tests élémentaires de Statistique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importation\n",
    "import scipy.stats\n",
    "rvs1 = scipy.stats.norm.rvs(loc=5, scale=10,size=500)\n",
    "rvs2 = scipy.stats.norm.rvs(loc=5, scale=10,size=500)\n",
    "rvs3 = scipy.stats.norm.rvs(loc=8, scale=10,size=500)\n",
    "# t-test returns: t-statistic/two-tailed p-value\n",
    "scipy.stats.ttest_ind(rvs1, rvs2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scipy.stats.ttest_ind(rvs1, rvs3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Kolmogorov-Smirnov test\n",
    "# returns: KS statistic / two-tailed p-value\n",
    "scipy.stats.ks_2samp(rvs1, rvs2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scipy.stats.ks_2samp(rvs1, rvs3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Références\n",
    "\n",
    "**Mac Kinney W.** (2013). *Python for Data Analysis*, O’Reilly. [pdf](http://it-ebooks.info/book/104)\n",
    "\n",
    "**Sheppard K.** (2014). *Introduction to Python for Econometrics, Statistics and Data Analysis*, [pdf](https://www.kevinsheppard.com/images/0/09/Python_introduction.pdf)"
   ]
  }
 ],
 "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.6"
  },
  "toc": {
   "nav_menu": {
    "height": "512px",
    "width": "252px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}