Cal2-PythonPandas.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",
    "</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": [
    "# Trafic de données avec  <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> & <a href=\"http://pandas.pydata.org/\"><img src=\"http://pandas.pydata.org/_static/pandas_logo.png\" style=\"max-width: 250px; display: inline\" alt=\"Pandas\"/></a> \n",
    "\n",
    "**Résumé**:  Utilisation de Python pour la préparation (*data munging* ou *wrangling* ou trafic) de données pas trop massives: qui tiennent en mémoire une fois réorganisées. Cette étape est abordée par l'initiation aux fonctionnalités de la librairie `pandas` et à la classe `DataFrame`; lire et écrire des fichiers, gérer une table de données et les types des variables, échantillonner, discrétiser, regrouper des modalités, description élémentaires uni et bi-variées; concaténation et jointure de tables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 Introduction\n",
    "### 1.1 Objectifs\n",
    "Le *data munging* ou *wrangling* (traduit ici par *trafic*) de données est l'ensemble des opérations permettant de passer de données brutes à une table (*data frame*) correcte et adaptée aux objectifs à atteindre par des  méthodes statistiques d'analyse, exploration, modélisation ou apprentissage. \n",
    "\n",
    "En présence de données complexes, peu ou mal organisées, présentant des trous, trop massives pour tenir en mémoire...  la qualité de cette étape est fondamentale (*garbage in garbage out*) pour la bonne réalisation d'une étude. Compte tenu de la diversité des situations envisageables, il serait vain de vouloir exposer tous les outils et techniques qui peuvent s'avérer nécessaires. Tâchons  néanmoins de résumer les problèmes qui peuvent être rencontrés.\n",
    "### 1.2 Croissance du volume\n",
    "Le volume des données et sa croissance occasionnent schématiquement trois situations.\n",
    "1. Le fichier initial des données brutes peut être chargé  intégralement en mémoire moyennant éventuellement de sauter quelques colonnes ou lignes du fichier (cf. section  3.1). C'est la situation courante, tout logiciel statistique comme R peut réaliser les traitements. *C'est l'objet des sections 2 à 6*.\n",
    "2. Le fichier initial est très volumineux mais la table (*DataFrame*), qui résulte de quelques  trafics (*munging*) appropriés, tient en mémoire. Cette situations nécessite: lecture, analyse, transformation, ré-écriture, séquentielles du fichier ligne à ligne ou par bloc. Il existe des astuces avec R mais il est préférable d'utiliser des outils plus adaptés. Tout langage de programmation (java, c, perl, ruby...) peut être utilisé pour écrire le ou les programmes réalisant ce travail. Néanmoins Python, et plus précisément la librairie [`pandas`](http://pandas.pydata.org/), offrent un ensemble d'outils efficaces pour accomplir ces tâches sans avoir à ré-inventer la roue et ré-écrire tout un ensemble de fonctionnalités relativement basiques. Remarque : les procédures `univariate` et `freq` et l'étape `data` de SAS sont adaptées car elles ne chargent pas les données en mémoire pour réaliser des traitements rudimentaires. Néanmoins pour tout un tas de raisons trop longues à exposer, notamment de coût annuel de location, SAS perd régulièrement des parts de marché sur ce créneau. *Cette approche est introduite ci-dessous en section 7 et consiste à enchâsser dans une même structure itérative et séquentielle les étapes précédentes des sections 2 à 6*.\n",
    "3. Lorsque les données, très massives, sont archivées sur un système de données distribuées (*Hadoop Distributed File System* ou HDFS), trafic et prétraitement des données doivent tenir compte de cet environnement. L'environnement *Spark* et l'API `PySpark` permettant de gérer en python des données distribuées est à favoriser. *Cf. le [calepin](http://wikistat.fr/Notebooks/Cal6-PythonSpark.html)* concerné. \n",
    "\n",
    "### 1.3 Quelques problèmes\n",
    "Liste non exhaustive des problèmes pouvant être rencontrés et dont la résolution nécessite simultanément des compétences en Informatique, Statistique, Mathématiques et aussi \"métier\" du domaine de l'étude. \n",
    "-  Identifier les \"individus\" $\\times$ \"variables\" (*instances*$\\times$*features* en langue informatique) de la table à mettre en forme à partir de bases de données variées; *i.e.* logs d'un site web, listes d'incidents, localisations...\n",
    "- Donnés atypiques (*outliers*): correction, suppression, transformation des variables ou méthode statistique robuste?\n",
    "- Variable qualitative avec beaucoup de modalités dont certaines très peu fréquentes: suppression, modalité `autres`, recodage aléatoire, regroupement \"métier\" ou méthode tolérante?\n",
    "- Distributions a-normales (log-normale, Poisson, multimodales...) et problèmes d'hétéroscédasticité: transformation, discrétisation ou méthodes tolérantes?\n",
    "- Données manquantes: suppressions (ligne ou colonne), imputation ou méthodes tolérantes ?\n",
    "- Représentations (splines, Fourier, ondelettes) et recalage (*time warping*) de données fonctionnelles.\n",
    "- Représentation de trajectoires, de chemins sur un graphe ? \n",
    "- Choix d'une distance (quadratique, absolue, géodésique...) entre les objets étudiés.\n",
    "- ...\n",
    "Bien entendu les \"bons\" choix dépendent directement de l'objectif poursuivi et des méthodes mises en oeuvre par la suite. D'où l'importance d'intégrer de façon précoce, dès la planification du recueil des données, les compétences statistiques nécessaires au sein d'une équipe. \n",
    "### 1.4 Fonctionnalités de `pandas`\n",
    "La richesse des fonctionnalités de la librairie `pandas` est une des raisons, si ce n'est la principale,  d'utiliser Python pour extraire, préparer, éventuellement analyser, des données. En voici un bref aperçu. \n",
    "- *Objets*: les classes `Series` et `DataFrame` ou *table de données*.\n",
    "- *Lire, écrire* création et exportation de tables de données à partir de fichiers textes (séparateurs, `.csv`, format fixe, compressés), binaires (HDF5 avec `Pytable`), HTML, XML, JSON, MongoDB, SQL... \n",
    "- *Gestion*  d'une table: sélection des lignes, colonnes, transformations, réorganisation par niveau d'un facteur, discrétisation de variables quantitatives, exclusion ou imputation élémentaire de données manquantes, permutation et échantillonnage aléatoire, variables indicatrices, chaînes de caractères...\n",
    "- *Statistiques* élémentaires  uni et bivariées, tri à plat (nombre de modalités, de valeurs nulles, de valeurs manquantes...), graphiques associés, statistiques par groupe, détection élémentaire de valeurs atypiques...\n",
    "- *Manipulation* de tables: concaténations, fusions, jointures, tri, gestion des types et formats...\n",
    "### 1.5 Références\n",
    "Ce tutoriel élémentaire s'inspire largement du livre de référence (Mc Kinney, 2013) et de la [documentation en ligne](http://pandas.pydata.org/pandas-docs/stable/) à consulter sans modération. Cette documentation inclut également des [tutoriels](http://pandas.pydata.org/pandas-docs/stable/tutorials.html) à exécuter pour compléter et approfondir la première ébauche d'un sujet relativement technique et qui peut prendre des tournures très diverses en fonction de la qualité et des types de données traitées.\n",
    "### 1.6 Exemple\n",
    "Les données choisies pour illustrer ce tutoriel sont issues d'une compétition du site [Kaggle](https://www.kaggle.com/): [Titanic: Machine learnic from Disaster](https://www.kaggle.com/c/titanic-gettingStarted). Le concours est terminé mais les [données](https://www.kaggle.com/c/titanic-gettingStarted/data) sont toujours disponibles sur le site avec des tutoriels utilisant Excel, Python ou R. \n",
    "\n",
    "Une des raisons du drame, qui provoqua la mort de 1502 personnes sur les 2224 passagers et membres d'équipage, fut le manque de canots de sauvetage. Il apparaît que les chances de survie dépendaient de différents facteurs (sexe, âge, classe...). Le but du concours est de construire un modèle de prévision (classification supervisée) de survie en fonction de ces facteurs. Les données sont composées d'un échantillon d'apprentissage (891) et d'un échantillon test (418) chacun décrit par 11 variables dont la première indiquant la survie ou non lors du naufrage. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Liste des variables\n",
    "\n",
    "Label  | Intitulé\n",
    "----------|-------------\n",
    "survival   |     Survival (0 = No; 1 = Yes)\n",
    "pclass   |       Passenger Class (1 = 1st; 2 = 2nd; 3 = 3rd)\n",
    "name    |       Name\n",
    "sex     |        Sex\n",
    "age     |        Age\n",
    "sibsp   |        Number of Siblings/Spouses Aboard\n",
    "parch    |       Number of Parents/Children Aboard\n",
    "ticket   |       Ticket Number\n",
    "fare    |        Passenger Fare\n",
    "cabin   |        Cabin\n",
    "embarked |       Port of Embarkation (C = Cherbourg; Q = Queenstown; S = Southampton)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Les classes `Series` et `DataFrame`\n",
    "De même que la librairie `Numpy` introduit le type `array` indispensable à la manipulation de matrices en calcul scientifique, celle `pandas` introduit les classes `Series` (séries chronologiques) et  `DataFrame` ou table de données indispensables en statistique. \n",
    "\n",
    "### 2.1 *Series*\n",
    "La classe `Series` est l'association de deux `arrays` unidimensionnels. Le premier est un ensemble de valeurs indexées par le 2ème qui est souvent une série temporelle.  Ce type est introduit principalement pour des applications en Econométrie et Finance où Python est largement utilisé."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 *DataFrame*\n",
    "Cette classe est proche de celle du même nom dans le langage R, il s'agit d'associer avec le même index de lignes des colonnes ou variables de types différents (entier, réel, booléen, caractère). C'est un tableau bi-dimensionnel avec des index de lignes et de colonnes mais il peut également être vu comme une liste de `Series` partageant le même index. L'index de colonne (noms des variables) est un objet de type `dict` (dictionnaire). C'est la classe qui sera principalement utilisée dans ce tutoriel. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exemple de data frame\n",
    "import pandas as pd\n",
    "data = {\"state\": [\"Ohio\", \"Ohio\", \"Ohio\", \n",
    "       \"Nevada\", \"Nevada\"],\n",
    "     \"year\": [2000, 2001, 2002, 2001, 2002],\n",
    "     \"pop\": [1.5, 1.7, 3.6, 2.4, 2.9]}\n",
    "frame = pd.DataFrame(data)\n",
    "# ordre des colonnes\n",
    "pd.DataFrame(data, columns=[\"year\", \"state\", \"pop\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# index des lignes et valeurs manquantes (NaN)\n",
    "frame2=pd.DataFrame(data, columns=[\"year\", \"state\", \"pop\", \"debt\"],\n",
    "     index=[\"one\", \"two\", \"three\", \"four\", \"five\"])\n",
    "# liste des colonnes\n",
    "frame.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# valeurs d'une colonnes\n",
    "frame[\"state\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frame.year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"imputation\"\n",
    "frame2[\"debt\"] = 16.5\n",
    "frame2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# créer une  variable\n",
    "frame2[\"eastern\"] = frame2.state == \"Ohio\"\n",
    "frame2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frame2.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# supprimer une  variable\n",
    "del frame2[u\"eastern\"]\n",
    "frame2.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Index\n",
    "Les index peuvent être définis par emboîtement et beaucoup d'autres fonctionnalités sur la gestion des index sont décrites par Mac Kinney (2013) (chapitre 5): \n",
    "- `append` nouvel index par concaténation,\n",
    "- `diff` différence ensembliste,\n",
    "- `intersection` intersection ensembliste,\n",
    "- `union` union ensembliste\n",
    "- `isin` vrai si la valeur est dans la liste,\n",
    "- `delete` suppression de l'index $i$,\n",
    "- `drop` suppression d'une valeur d'index, \n",
    "- `is_monotonic` vrai si les valeurs sont croissantes, \n",
    "- `is_unique` vrai si toutes les valeurs sont différentes, \n",
    "- `nique` tableau des valeurs uniques de l'index."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Lire écrire des tables de données\n",
    "`Pandas` offre des outils efficaces pour lire écrire des fichiers selon différents formats (csv, texte, fixe, compressé, xml, html, hdf5) ou interagir avec des bases de données SQL, MongoDB, des APIs web. Ce document se contente de décrire les fonctions les plus utiles `read_csv` et `read_table` pour lire des fichiers textes et générer un objet de classe ` DataFrame`. \n",
    "\n",
    "En principe ces fonctions font appel à un code écrit en C dont très rapide à l'exécution sauf pour l'emploi de certaines options (`skip\\_footer, sep`} autre qu'un seul caractère), à éviter, qui provoquent une exécution en Python (`engine=Python`). \n",
    "\n",
    "La réciproque pour l'écriture est obtenue par les commandes `data.to_csv` ou `_table` avec des options similaires. \n",
    "\n",
    "### 3.1 Syntaxe\n",
    "L'exemple de base est donné pour lire un fichier au format `.csv` dont les valeurs sont séparées par des \",\" et dont la première ligne contient le nom des variables.\n",
    "``\n",
    "import pandas as pd\n",
    "data=pd.read_csv(\"fichier.csv\")\n",
    "data=pd.read_table(\"fichier.csv\", sep=\",\")\n",
    "``\n",
    "\n",
    "Il est important de connaître la liste des possibilités et options offertes par cette simple commande. Voici les principales ci-dessous et un lien à la [liste complète](http://pandas.pydata.org/pandas-docs/stable/io.html#io-read-csv-table).\n",
    "- `path` chemin ou non du fichier ou URL.\n",
    "- `sep` délimiteur comme \\verb+ , ; | \\t + ou \\verb# \\s+ #  pour un nombre variable d'espaces. \n",
    "- `header` défaut 0, la première ligne contient le nom des variables; si `None` les noms sont générés ou définis par ailleurs.\n",
    "- `index_col` noms ou numéros de colonnes définissant les index de lignes, index pouvant être hiérarchisés comme les facteurs d'un plan d'expérience.\n",
    "- `names` si {\\tt header=None}, liste des noms des variables. \n",
    "- `nrows` utile pour tester et limiter le nombre de ligne à lire.\n",
    "- `skiprow` liste de lignes à sauter en lecture.\n",
    "- `skip_footer` nombre de lignes à sauter en fin de fichier.\n",
    "- `na_values` définition du ou des codes signalant des valeurs manquantes. Ils peuvent être définis dans un dictionnaire pour associer variables et codes de valeurs manquantes spécifiques.\n",
    "- `usecols` sélectionne une liste des variable à lire pour éviter de lire des champs ou variables volumineuses et inutiles.\n",
    "- `skip_blan_lines` à `True` pour sauter les lignes blanches.\n",
    "- `converters` appliquer une fonction à une colonne ou variable.\n",
    "- `day_first` par défaut `False`, pour des dates françaises au format `7/06/2013`.\n",
    "- `chunksize` taille des morceaux à lire itérativement.\n",
    "- `verbose` imprime des informations comme le nombre de valeurs manquantes des variables non numériques.\n",
    "- `encoding` type d'encodage comme \"utf-8\" ou \"latin-1\"\n",
    "- `thousand` séparateur des miliers: \".\" ou \",\".\n",
    "\n",
    "Remarques:\n",
    "- De nombreuses options de gestion des dates et séries ne sont pas citées.\n",
    "- `chunksize` provoque la lecture d'un gros fichiers par morceaux de même taille (nombre de lignes). Des fonctions (comptage, dénombrement...) peuvent ensuite s'appliquer itérativement sur les morceaux.\n",
    "\\end{itemize}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Exemple\n",
    "Les données du naufrage du Titanic  illustrent l'utilisation de `pandas`. Elles sont lues directement à partir de leur URL ou sinon les charger [ici](http://www.math.univ-toulouse.fr/~besse/Wikistat/data) vers le répertoire de travail de Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importations\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "# tester la lecture\n",
    "# path=\"\"\n",
    "path='./'\n",
    "df = pd.read_csv(path+'titanic-train.csv',nrows=5)\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tout lire\n",
    "df = pd.read_csv(path+\"titanic-train.csv\")\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Des variables sont inexploitables\n",
    "# Choisir les colonnes utiles\n",
    "df=pd.read_csv(path+\"titanic-train.csv\",\n",
    "    usecols=[1,2,4,5,6,7,9,11],nrows=5)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "À partir de la version 0.15, `pandas`, inclut un type `category` assez proche de celui ` factor` de R. Il devrait normalement être déclaré dans un dictionnaire au moment par exemple de la lecture (`dtype={\"Surv\":pd.Categorical...}`) mais ce n'est pas le cas, c'est donc le type objet qui est déclaré puis modifié. Il est vivement recommandé de bien affecter les bons types à chaque variable ne serait-ce que pour éviter de faire des opérations douteuses, par exemple arithmétiques sur des codes de modalités."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df=pd.read_csv(path+\"titanic-train.csv\",skiprows=1,header=None,usecols=[1,2,4,5,9,11],\n",
    "  names=[\"Surv\",\"Classe\",\"Genre\",\"Age\",\"Prix\",\"Port\"],dtype={\"Surv\":object,\n",
    "    \"Classe\":object,\"Genre\":object,\"Port\":object})\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Redéfinition des bons types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"Surv\"]=pd.Categorical(df[\"Surv\"],ordered=False)\n",
    "df[\"Classe\"]=pd.Categorical(df[\"Classe\"],ordered=False)\n",
    "df[\"Genre\"]=pd.Categorical(df[\"Genre\"],ordered=False)\n",
    "df[\"Port\"]=pd.Categorical(df[\"Port\"],ordered=False)\n",
    "df.dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarque: il est également possible de tout lire avant de laisser \"tomber\" les variable inexploitables. C'est le rôle de la commande: \n",
    "\n",
    "`df = df.drop([\"Name\", \"Ticket\", \"Cabin\"], axis=1)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Echantillonnage simple\n",
    "Comme dans R, le type `DataFrame` de Python est chargé en mémoire. Si, malgré les options précédentes permettant de sélectionner, les colonnes, les types des variables... le fichier est encore trop gros, il reste possible, avant de chercher une configuration matérielle lourde et en première approximation, de tirer un échantillon aléatoire simple selon une distribution uniforme. Un tirage stratifié demanderait plus de travail. Cela suppose de connaître le nombre de ligne du fichier ou une valeur inférieure proche."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pour les données titanic:\n",
    "N=891  # taille du fichier\n",
    "n=200  # taille de l'échantillon\n",
    "lin2skipe=[0] # ne pas lire la première ligne\n",
    "# ne pas lire N-n lignes tirées aléatoirement\n",
    "lin2skipe.extend(np.random.choice(np.arange(1,N+1),\n",
    "    (N-n),replace=False))\n",
    "df_small=pd.read_csv(path+\"titanic-train.csv\",\n",
    "    skiprows=lin2skipe,header=None, \n",
    "    usecols=[1,2,4,5,9,11],\n",
    "    names=[\"Surv\",\"Classe\",\"Genre\",\"Age\",\n",
    "         \"Prix\",\"Port\"])\n",
    "df_small"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Gérer une table de données\n",
    "### 3.1 Discrétisation d'une variable quantitative\n",
    "Pour la discrétisation d'une variable quantitative. Il est d'un bon usage de définir les bornes des classes à des quantiles, plutôt qu'également espacées, afin de construire des classes d'effectifs sensiblement égaux.  Ceci est obtenu par la fonction `qcut`. La fonction `cut` propose par défaut des bornes équi-réparties à moins de fournir une liste de ces bornes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"AgeQ\"]=pd.qcut(df.Age,3,labels=[\"Ag1\",\"Ag2\",\n",
    "   \"Ag3\"])\n",
    "df[\"PrixQ\"]=pd.qcut(df.Prix,3,labels=[\"Pr1\",\"Pr2\",\n",
    "   \"Pr3\"])\n",
    "df[\"PrixQ\"].describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Modifier / regrouper des modalités\n",
    "Le recodage des variables qualitatives ou renommage en clair des modalités est obtenu simplement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"Surv\"]=df[\"Surv\"].cat.rename_categories(\n",
    "    [\"Vnon\",\"Voui\"])\n",
    "df[\"Classe\"]=df[\"Classe\"].cat.rename_categories(\n",
    "    [\"Cl1\",\"Cl2\",\"Cl3\"])\n",
    "df[\"Genre\"]=df[\"Genre\"].cat.rename_categories(\n",
    "    [\"Gfem\",\"Gmas\"])\n",
    "df[\"Port\"]=df[\"Port\"].cat.rename_categories(\n",
    "    [\"Pc\",\"Pq\",\"Ps\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est possible d'associer recodage et regroupement des modalités en définissant un dictionnaire de transformation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.DataFrame({\"food\":[\"bacon\",\"pulled pork\", \n",
    "   \"bacon\", \"Pastrami\",\n",
    "   \"corned beef\", \"Bacon\", \"pastrami\", \"honey ham\",\n",
    "   \"nova lox\"],\n",
    "   \"ounces\": [4, 3, 12, 6, 7.5, 8, 3, 5, 6]})\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "meat_to_animal = {\n",
    "    \"bacon\": \"pig\",\n",
    "    \"pulled pork\": \"pig\",\n",
    "    \"pastrami\": \"cow\",\n",
    "    \"corned beef\": \"cow\",\n",
    "    \"honey ham\": \"pig\",\n",
    "    \"nova lox\": \"salmon\"\n",
    "}\n",
    "# Eviter les mélanges de majuscules minuscules \n",
    "# en mettant tout en minuscule\n",
    "data[\"animal\"] = data[\"food\"].map(\n",
    "    str.lower).map(meat_to_animal)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data[\"food\"].map(lambda x: meat_to_animal[x.lower()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfs = pd.DataFrame({\"key\": [\"b\", \"b\", \"a\", \"c\",\n",
    "    \"a\", \"b\"],\"data1\": range(6)})\n",
    "pd.get_dummies(dfs[\"key\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Variables indicatrices\n",
    "Générer des indicatrices des modalités ou *dummy variables*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dummies = pd.get_dummies(dfs['key'], prefix='key')\n",
    "df_with_dummy = dfs[['data1']].join(dummies)\n",
    "df_with_dummy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4 Permutation et tirage aléatoires\n",
    "Permutation aléatoire:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfs = pd.DataFrame(np.arange(5 * 4).reshape(5, 4))\n",
    "sampler = np.random.permutation(5)\n",
    "sampler\n",
    "dfs\n",
    "dfs.take(sampler)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tirage aléatoire avec remplacement ou *bootstrap* ; celui sans remplacement est traité section 3.3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bag = np.array([5, 7, -1, 6, 4])\n",
    "sampler = np.random.randint(0, len(bag), size=10)\n",
    "draws = bag.take(sampler)\n",
    "draws"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5 Transformations, opérations\n",
    "Les opérations arithmétiques entre `Series` et `DataFrame` sont possibles au même titre qu'entre `array`. Si les index ne correspondent pas, des valeurs manquantes (NAN) sont créées à moins d'utiliser des méthodes d'arithmétique `flexible` (`add, sub, div, mul`) autorisant la complétion par une valeur par défaut, généralement 0.\n",
    "\n",
    "Une fonction quelconque (`lambda`) peut être appliquée avec une même commande qu'`apply` de R. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# la table de données\n",
    "frame = pd.DataFrame(np.random.randn(4,3), \n",
    "    columns=list(\"bde\"),\n",
    "    index=[\"Utah\", \"Ohio\", \"Texas\", \"Oregon\"])\n",
    "# une fonction\n",
    "f = lambda x: x.max() - x.min()\n",
    "frame.apply(f, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.6 Tri et rangs\n",
    "Trier une table selon les valeurs d'une variable ou d'un index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frame = pd.DataFrame(np.arange(8).reshape((2,4)), \n",
    "        index=[\"three\", \"one\"],\n",
    "        columns=[\"d\", \"a\", \"b\", \"c\"])\n",
    "frame.sort_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frame.sort_index(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frame.sort_index(axis=1, ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frame.sort_values(by=\"b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La commande `rank` remplace les valeurs par leur rang dans l'ordre des lignes ou des colonnes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frame = pd.DataFrame({\"b\": [4.3, 7, -3, 2], \n",
    "    \"a\": [0, 1, 0, 1],\"c\": [-2, 5, 8, -2.5]})\n",
    "frame.rank(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frame.rank(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Statistiques descriptives élémentaires\n",
    "Continuer l'étude des données sur le naufrage du Titanic. Les commandes ci-dessous permettent des premiers diagnostics sur la qualité des données.\n",
    "### 4.1 Description univariée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"Age\"].hist()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"Age\"].plot(kind=\"box\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"Prix\"].plot(kind=\"hist\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# qualitatif\n",
    "df[\"Surv\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"Classe\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"Genre\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"Port\"].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 Description bivariée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.plot(kind=\"scatter\",x=\"Age\",y=\"Prix\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# afficher une sélection\n",
    "df[df[\"Age\"]>60][[\"Genre\",\"Classe\",\"Age\",\"Surv\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.boxplot(column=\"Age\",by=\"Classe\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.boxplot(column=\"Prix\",by=\"Surv\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# table de contingence\n",
    "table=pd.crosstab(df[\"Surv\"],df[\"Classe\"])\n",
    "print(table)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mosaic plot\n",
    "from statsmodels.graphics.mosaicplot import mosaic\n",
    "mosaic(df,[\"Classe\",\"Genre\"])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mosaic(df,[\"Surv\",\"Classe\"])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 Imputation de données manquantes\n",
    "La gestion des données manquantes est souvent un point délicat. De nombreuses stratégies ont été élaborées, les principales sont décrites dans une [vignette](http://wikistat.fr/pdf/st-m-app-idm.pdf). Nous ne décrivons ici que les plus élémentaires à [mettre en oeuvre](http://pandas.pydata.org/pandas-docs/version/0.15.2/missing_data.html) avec `pandas`.\n",
    "\n",
    "Il est ainsi facile de supprimer toutes les observations présentant des données manquantes lorsque celles-ci sont peu nombreuses et majoritairement regroupées sur certaines lignes ou colonnes.\n",
    "\n",
    "``\n",
    "df = df.dropna(axis=0)\n",
    "df = df.dropna(axis=1)\n",
    "``\n",
    "\n",
    "`Pandas` permet également de faire le choix pour une variable qualitative de considérer ` `np.nan` comme une modalité spécifique ou d'ignorer l'observation correspondante.\n",
    "\n",
    "Autres stratégies:\n",
    "* Cas quantitatif: une valeur manquante est imputée par la moyenne ou la médiane.\n",
    "*  Cas d'une série chronologique: imputation par la valeur précédente ou suivante ou par interpolation linéaire, polynomiale ou encore lissage spline.\n",
    "* Cas qualitatif: modalité la plus fréquente ou répartition aléatoire selon les fréquences observées des modalités.\n",
    "\n",
    "La variable âge contient de nombreuses données manquantes. La fonction `fillna` présente plusieurs options d'imputation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remplacement par la médiane d'une variable quantitative\n",
    "df=df.fillna(df.median())\n",
    "df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# par la modalité \"médiane\" de AgeQ\n",
    "df.info()\n",
    "df.AgeQ=df[\"AgeQ\"].fillna(\"Ag2\")\n",
    "# par le port le plus fréquent\n",
    "df[\"Port\"].value_counts()\n",
    "df.Port=df[\"Port\"].fillna(\"Ps\")\n",
    "df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ces imputations sont pour le moins très rudimentaires et d'autres sont à privilégier pour des modélisations  plus soignées mais ces méthodes font généralement appel à R.\n",
    "\n",
    "D'autres fonctions (Mac Kinney, 2013) sont proposées pour supprimer les duplicatas (` drop\\_duplicates`), modifier les dimensions, traquer des atypiques unidimensionnels selon un modèle gaussien ou par rapport à des quantiles."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 Manipuler des tables de données\n",
    "### 5.1 Jointure\n",
    "Il s'agit de \"jointer\" deux tables partageant la même clef ou encore de concaténer horizontalement les lignes  en faisant correspondre les valeurs d'une variable clef qui peuvent ne pas être uniques."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tables\n",
    "df1 = pd.DataFrame({\"key\": [\"b\", \"b\", \"a\", \"c\", \n",
    "     \"a\",\"a\", \"b\"],\"data1\": range(7)})\n",
    "df2 = pd.DataFrame({\"key\": [\"a\", \"b\", \"d\"],\n",
    "    \"data2\": range(3)})\n",
    "pd.merge(df1,df2,on=\"key\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La gestion des clefs manquantes est en option: entre autres, ne pas introduire de ligne (ci-dessus), insérer des valeurs manquantes ci-dessous. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# valeurs manquantes\n",
    "pd.merge(df1,df2,on=\"key\", how=\"outer\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2 Concaténation selon un axe\n",
    "Concaténation verticale (axis=0) ou horizontales (axis=1) de tables. La concaténation horizontale est similaire à la jointure (option `outer`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tables\n",
    "df1 = pd.DataFrame({\"key\": [\"b\", \"b\", \"a\", \"c\", \n",
    "    \"a\", \"a\", \"b\"],\"var\": range(7)})\n",
    "df2 = pd.DataFrame({\"key\": [\"a\", \"b\", \"d\"],\n",
    "    \"var\": range(3)})\n",
    "# concaténation verticales\n",
    "pd.concat([df1,df2],axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# concaténation horizontale\n",
    "pd.concat([df1,df2],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 Trafic séquentiel de gros fichiers\n",
    "Étape suivante associée de la croissance du volume: les fichiers des données brutes ne tiennent pas en mémoire.  Il \"suffit\" d'intégrer ou enchâsser les étapes des sections précédentes dans la lecture séquentielle d'un gros fichier. En apparence, simple d'un point de vue méthodologique, cette étape peut consommer beaucoup de temps par tests et remises en cause incessantes des choix de sélection, transformation, recodage... des variables. Il est crucial de se doter d'outils efficaces. \n",
    "\n",
    "Il s'agit donc de lire les données par morceau (nombre fixé de lignes) ou ligne à ligne, traiter chaque morceau, le ré-écrire dans un fichier de format binaire plutôt que texte; le choix du format HDF5 semble le plus efficace du point de vue technique et pour servir d'interface à d'autres environnements: C, java, Matlab... et R car une librairie ({\\tt rhdf5} de Bioconductor) gère ce format.\n",
    "\n",
    "La procédure est comparable à une étape `Data` de SAS, qui lit/écrit les tables ligne à ligne.\n",
    "\n",
    "Deux librairies: `h5py` et `PyTables` gèrent le format HDF5 en Python. Pour simplifier la tâche, `pandas` intègre une classe `HDFStore` utilisant `PyTables` qui doit donc être installée. \n",
    "\n",
    "**Attention**: ce format n'est pas adapté à une gestion *parallélisée*, notamment en écriture. \n",
    "\n",
    "\n",
    "### 6.1 Lecture séquentielle\n",
    "L'exemple est ici donné pour lire un fichier texte mais beaucoup d'autres formats (excel, hdf, sql, json, msgpack, html, gbq, stata, clipboard, pickle) sont connus de `pandas`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importations\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "# lire tout le fichier par morceaux\n",
    "# avec l'option chunksize\n",
    "Partition=pd.read_csv(path+\"titanic-train.csv\",skiprows=1,\n",
    "  header=None,usecols=[1,2,4,5,9,11],\n",
    "  names=[\"Surv\",\"Classe\",\"Genre\",\"Age\",\n",
    "    \"Prix\",\"Port\"],dtype={\"Surv\":object,\n",
    "    \"Classe\":object,\"Genre\":object,\"Port\":object},\n",
    "    chunksize=100)\n",
    "# ouverture du fichier HDF5\n",
    "stock=pd.HDFStore(\"titan.h5\")\n",
    "# boucle de lecture\n",
    "for Part in Partition:\n",
    "    # \"nettoyage\" préliminaire des données\n",
    "    #Part=Part.drop([\"Name\",\"Ticket\",\"Cabin\"],axis=1)\n",
    "    # ... autres opérations\n",
    "    # création de la table \"df\" dans \"stock\" puis\n",
    "    # extension de celle-ci par chaque \"Part\"\n",
    "    stock.append(\"df\",Part)\n",
    "# dernier morceau lu et ajouté\n",
    "Part.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Il est généralement utile de fermer le fichier\n",
    "stock.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Attention** aux types implicites des variables. Si, par exemple, une donnée manquante n'apparaît pas dans une colonne du 1er morceau mais dans le 2ème, cela peut engendrer un conflit de type. Expliciter systématiquement les types et noms des variables dans un dictionnaire en paramètre.\n",
    "\n",
    "### 6.2 Utilisation d'une table HDF5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ouverture du fichier\n",
    "Archiv=pd.HDFStore(\"titan.h5\")\n",
    "# sélection de la table et affichage de l'entête\n",
    "Archiv.select(\"df\").head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette partie est à développer pour illustrer les fonctionnalités de `pandas` permettant d'interroger / requêter (*querying* notamment SQL) une table archivée dans un fichier HDF5. Consulter la [documentation en ligne](http://pandas.pydata.org/pandas-docs/dev/io.html#hdf5-pytables) à ce sujet. \n",
    "\n",
    "### 6.3 Echantillon aléatoire simple\n",
    "Le fichier créé au format HDF5 peut être encore très volumineux. Par souci d'efficacité, son raffinement, son exploitation, voire même son analyse pour modélisation, peuvent ou même doivent être opérés sur un  simple échantillon aléatoire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# extraction du nombre de lignes  / individus\n",
    "nrows = Archiv.get_storer(\"df\").nrows\n",
    "# génération des index aléatoires\n",
    "r = np.random.randint(0,nrows,size=10)\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# extraction des lignes d'index fixés\n",
    "df_ech=Archiv.select(\"df\",where=pd.Index(r))\n",
    "df_ech"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il \"suffit\" alors d'appliquer les outils des sections 4 à 6 précédentes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.4 Echanges entre R et Pyhton\n",
    "Les données ayant été préparées, nettoyées, le transfert de la table dans R permet de déployer toute la richesse des librairies développées dans cet environnement plus familier au statisticien. Il est possible d'appeler des commandes R à partir de Python avec la librairie  `rpy2` et  réciproquement d'appeler des commandes Python de R avec la librairie `rpython`. \n",
    "\n",
    "La librairie `rpy2` définit la commande `load_data` qui charge un `data.frame` de R dans un `DataFrame` tandis que celle `convert_to_r_dataframe` génère un objet R.\n",
    "\n",
    "Le plus efficace mais sans doute pas le plus simple, consisterait à lire directement, à partir de R, le fichier intermédiaire précédent au format binaire HDF5 en utilisant la librairie ` rhdf5` de Bioconductor. Cette démarche pose des problèmes pour la gestions des variables qualitatives et plus généralement celle de la classe `DataFrame`. Une alternative simple consiste à construire un fichier intermédiaire au format classique `.csv`. \n",
    "\n",
    "\n",
    "## À suivre...\n",
    "Ces traitements font appel à de très nombreuses opérations de lectures / écritures sur un seul ordinateur, un seul disque au regard du volume des calculs; ils ne sont pas adaptés à une parallélisation sur un ordinateur multiprocesseur. La gestion et l'analyse de plus gros volumes de données nécessite une distribution de celles-ci sur plusieurs serveurs / disques. D'autres technologies doivent être utilisées; c'est actuellement le couple *Spark/Hadoop* le plus en vogue.\n",
    "\n",
    "**Intérêt**: *Spark* est utilisable avec java, Scala et aussi Python. L'investissement dans ce langage est donc rentable. "
   ]
  },
  {
   "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)"
   ]
  }
 ],
 "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
}