complements_matplotlib_barh.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matplotlib :\n",
    "\n",
    "## tracer un diagramme en barres horizontales ( = Horizontal bar chart)\n",
    "\n",
    "Présenter des données de façon graphique peut permettre d'en faire une meilleure analyse visuelle.\n",
    "\n",
    "Le package matplotlib permet une multitude de représentations graphiques. \n",
    "\n",
    "C'est un package que nous avons déja rencontré lors de l'étude d'un programme Python en relation avec le cours de Sciences Physiques. \n",
    "\n",
    "Plus précisemment, nous avons eu affaire à l'un des modules de ce package, **pyplot** que nous allons retrouver ici. \n",
    "\n",
    "L'aide concernant ce module peut-être obtenue avec l'aide intégrée de Python, mais on pourra préférer voir l'aide en ligne : \n",
    "\n",
    " https://matplotlib.org/3.2.1/api/_as_gen/matplotlib.pyplot.html#module-matplotlib.pyplot \n",
    " \n",
    " On pourra y trouver un exemple de diagramme en barres horizontales :\n",
    " \n",
    " https://matplotlib.org/3.2.1/gallery/lines_bars_and_markers/barh.html#sphx-glr-gallery-lines-bars-and-markers-barh-py \n",
    " \n",
    " mais pour démarrer, on pourra préférer le code ci-dessous, qui va à l'essentiel (bien que présentant des petits défauts). Il a été trouvé sur le site https://pythonspot.com/matplotlib-bar-chart/.\n",
    " \n",
    " Exécuter le code et aller voir les commentaires donnés en dessous. **Expérimenter** sur ce code en faisant des (tentatives de) modifications. Accompagner ces modifications d'une **lecture de la documentattion correspondante** (Cf le premier lien donné ci-dessus) :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " # Cette première ligne de 'code' est nécessaire pour le notebook jupyter.\n",
    "# Ne pas la copier si on souhaite utiliser le reste du code dans Thonny :\n",
    "%matplotlib inline \n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "objects = ('Python', 'C++', 'Java', 'Perl', 'Scala', 'Lisp')\n",
    "y_pos = np.arange(len(objects))\n",
    "performance = [10,8,6,4,2,1]\n",
    "\n",
    "plt.barh(y_pos, performance, align='center', alpha=0.5)\n",
    "plt.yticks(y_pos, objects)\n",
    "plt.xlabel('Usage')\n",
    "plt.title('Programming language usage')\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Commentaires :\n",
    "\n",
    "#### 1- pyplot :\n",
    "\n",
    "Pyplot étant un module de Matplotlib, l'utilisation d'une méthode de pyplot devrait se faire par :\n",
    "\n",
    " **matplotlib.pyplot.nom_de_la_methode()**\n",
    " \n",
    " ce qui serait assez fastidieux... Pour cette raison un alias est réalisé dans la ligne d'importation :\n",
    " \n",
    " **import matplotlib.pyplot as plt**\n",
    " \n",
    " Cet alias est celui proposé par la documentation de pyplot : on évitera d'en utiliser un autre. Cela permet une homogénéité d'écriture avec les autres développeurs.\n",
    " \n",
    " Dans le code on trouvera donc :\n",
    " \n",
    " **plt.nom_de_la_methode()** au lieu de **matplotlib.pyplot.nom_de_la_methode()**\n",
    "\n",
    "#### 2- numpy :\n",
    "\n",
    "Numpy est un module python que l'on retrouve souvent associé à Matplotlib... de ce fait certains utilisent systématiquement numpy et matplotlib ensemble bien que ce ne soit pas toujours justifié. \n",
    "\n",
    "Numpy permet de réaliser du calcul scientifique, en particulier sur des tableaux / matrices. Au bout des calculs scientifiques on a souvent une représentation graphique, et c'est là qu'entre en jeu Matplotlib avec son module Pyplot.\n",
    "\n",
    "Mais on peut fort bien avoir fait du travail sur Python et vouloir faire une représentation grahique. Pyplot est alors utilisé, sans que l'on ait eu besoin de faire intervenir Numpy.\n",
    "\n",
    "Dans le code d'exemple ci-dessus, numpy est utilisé dans une seule ligne d'instruction :\n",
    "\n",
    "y_pos = np.arange(len(objects))\n",
    "\n",
    "Voici ce que donne la documentation de numpy.arange (https://docs.scipy.org/doc/numpy/reference/generated/numpy.arange.html) :\n",
    "\n",
    "\n",
    "**numpy.arange([start, ]stop, [step, ]dtype=None)**\n",
    "\n",
    "    Return evenly spaced values within a given interval.\n",
    "\n",
    "    Values are generated within the half-open interval [start, stop) (in other words, the interval including start but excluding stop). For integer arguments the function is equivalent to the Python built-in range function, but returns an ndarray rather than a list.\n",
    "\n",
    "    When using a non-integer step, such as 0.1, the results will often not be consistent. It is better to use numpy.linspace for these cases.\n",
    "    \n",
    "On y apprend que cette méthode est équivalente à la fonction native range() de Python si on travaille avec des entiers. ( numpy.arange peut travailler avec des valeurs non entières contrairement à range()...mais on nous dit que les résultats pourraient ne pas être cohérents...). \n",
    "\n",
    "Une petite imprécision dans cette documentation : la fonction native range() ne renvoie plus une liste (c'était vrai avec Python 2), mais un itérateur sur une série de nombres. Si on veut une liste il faut la créer (avec la fonction native list).\n",
    "\n",
    "Tester les codes ci-dessous pour voir la différence entre range(), list(range()) et np.arange() utilisées avec des entiers. On constate que le format de l'objet renvoyé par np.arange est différent, spécifique de la bibliothèque numpy (un objet de type 'array', type qui n'existe pas dans python)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range(2,10,2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(2,10,2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.arange(2,10,2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Essai avec des nombres non entiers :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range(2,10,0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.arange(2,6,0.5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# un exemple de problème : avec ce code on devrait obtenir : array([2. , 2.2, 2.4]) car la valeur de stop 2.6 devrait\n",
    "# être exclue... mais :\n",
    "import numpy as np\n",
    "np.arange(2.0, 2.6, 0.2)\n",
    "# ce problème est du à la précision non infinie sur les flottants ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On doit être capable de dire ce que fait cette ligne d'instruction :\n",
    "\n",
    "**y_pos = np.arange(len(objects))**\n",
    "\n",
    "et se demander si :\n",
    "**y_pos = range(len(objects))** pourrait suffire **ici** (auquel cas l'importation du module numpy ne serait plus nécessaire). Il faut donc regarder à quoi sert par la suite y_pos ; doit-il avoir le type fourni par numpy ou être d'un autre type. On va donc explorer la documentation des méthodes dans lesquelles y_pos est utilisé.\n",
    "\n",
    "Par exemple, aller voir l'aide sur barh() pour répondre aux questions suivantes :\n",
    "\n",
    " - Dans ce code les structures de données qui servent à alimenter le graphique ('objects' et 'performance') sont de deux types différents... Cela semble curieux... N'est-il pas possible d'utiliser le même type pour les deux (par exemple le type list) ?\n",
    "  - Le paramètre align peut prendre deux valeurs. Lesquelles ? A-t-il une valeur par défaut ? Ici le développeur lui a donné la valeur 'center' : était-ce utile ? Tester avec la valeur 'edge' pour voir le résultat sur le graphique.\n",
    "  - lorsque l'on va voir l'aide pour barh, on obtient :\n",
    "  \n",
    "  **matplotlib.pyplot.barh(y, width, height=0.8, left=None, \\*, align='center', \\*\\*kwargs)**\n",
    "  \n",
    "  dans le code en exemple, on a :\n",
    "  \n",
    "  **plt.barh(y_pos, performance, align='center', alpha=0.5)**\n",
    "   - y_pos = paramètre effectif du paramètre formel y\n",
    "   - performance = paramètre effectif du paramètre formel width\n",
    "   - pas de valeur donnée à height ; elle aura donc la valeur par défaut 0,8\n",
    "   - pas de valeur donnée à left ; elle aura donc la valeur par défaut None\n",
    "   - align avait été redéfini avec sa valeur par défaut ... ???\n",
    "   - mais alpha n'apparaît pas dans la liste des paramètres ...\n",
    "  \n",
    "  En fait il y a un dernier paramètre formel appelé **kwargs** qui signifie **keyword arguments** et qui permet d'ajouter un nombre quelconque de paramètres supplémentaires, parfois nombreux et peu souvent utilisés, raison pour\n",
    "laquelle ils ne sont pas détaillés. Ces paramètres sont bien sûr connus de la fonction et il faudra aller voir l'aide détaillée pour les trouver.\n",
    "Pour la méthode barh ( https://matplotlib.org/3.2.1/api/_as_gen/matplotlib.pyplot.barh.html#matplotlib.pyplot.barh) la page web commence par décrire les 5 paramètres principaux (de y à align), puis donne le type retourné puis seulement après décrit les autres paramètres possibles : de 'color' à 'log' sans que l'on y trouve 'alpha'...et c'est seulement plus bas sur la page que l'on trouve :\n",
    "'Other optional kwargs:' avec 'alpha' dans cette liste...où vous apprendrez que alpha est de type 'float or None'.\n",
    "\n",
    "Essayer de modifier alpha (on verra que les valeurs possibles sont comprises entre 0 et 1. Observer l'effet : alpha premet de gérer la 'transparence'. C'est d'ailleurs un terme utilisé en infographie.\n",
    "\n",
    "\n",
    "Essayer de modifier **étape par étape** le code ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cette première ligne de 'code' est nécessaire pour le notebook jupyter.\n",
    "# Ne pas la copier si on souhaite utiliser le reste du code dans Thonny :\n",
    "%matplotlib inline \n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# numpy n'a pas été conservé dans ce code modifié\n",
    "\n",
    "objects = ['Python', 'C++', 'Java', 'Perl', 'Scala', 'Lisp']\n",
    "y_pos = range(len(objects)) \n",
    "performance = [10,8,6,4,2,1]\n",
    "\n",
    "plt.barh(y_pos, performance,height=0.4, align='edge', alpha=0.2)\n",
    "plt.yticks(y_pos, objects)\n",
    "plt.xlabel('Utilisation')\n",
    "plt.title('Utilisation des langages de programmation')\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Améliorer la présentation avec une palette de couleurs\n",
    "\n",
    "Le sujet est vaste. Pour s'en convaincre, aller sur cette page : https://matplotlib.org/3.1.0/gallery/color/colormap_reference.html\n",
    "\n",
    "On se propose d'utiliser une gamme de couleur nommée 'veridis' dont on extraira les couleurs nécessaires pour fire une palette de couleurs adaptée à notre diagramme en barre (on va avoir une couleur différente par barre).\n",
    "\n",
    "Cela nécessite l'importation d'une librairie supplémentaire\n",
    "\n",
    "On crée la palette de couleurs adaptée aux nombre de barres : \n",
    "\n",
    "**palette = cm.get_cmap('viridis', len(objects) )**\n",
    "\n",
    "On pourra remplacer la gamme chromatique 'veridis' par une autre proposée dans l'aide ('plasma', 'inferno', 'magma', 'cividis') selon l'effet recherché\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cette première ligne de 'code' est nécessaire pour le notebook jupyter.\n",
    "# Ne pas la copier si on souhaite utiliser le reste du code dans Thonny :\n",
    "%matplotlib inline \n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.cm as cm\n",
    "# numpy n'a pas été conservé dans ce code modifié\n",
    "\n",
    "objects = ['Python', 'C++', 'Java', 'Perl', 'Scala', 'Lisp']\n",
    "y_pos = range(len(objects)) \n",
    "performance = [10,8,6,4,2,1]\n",
    "\n",
    "# on crée une palette de couleurs. Elle contient autant de couleurs différentes\n",
    "# qu'il n'y a d'éléments dans la liste 'objects':\n",
    "palette = cm.get_cmap('viridis', len(objects) )\n",
    "\n",
    "# dans la méthode plt.barh on utilisera on donnera au paramètre 'color' la valeur 'palette.colors' \n",
    "# on peut toujours utiliser le paramètre 'alpha' :\n",
    "plt.barh(y_pos, performance,height=0.6, color=palette.colors, alpha=0.6)\n",
    "plt.yticks(y_pos, objects)\n",
    "plt.xlabel('Utilisation')\n",
    "plt.title('Utilisation des langages de programmation')\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}