Chapitre 04.1 - CSV.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapitre 4.1 - Les fichiers CSV, JSON et les requêtes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Le format CSV\n",
    "\n",
    "Un fichier CSV est un fichier de tableau simplifié au maximum :\n",
    "- le fichier est encodé en plein texte, il peut être lu par un éditeur de texte lambda\n",
    "- le fichier utilise un séparateur de colonnes (usuellement une virgule, un point-virgule ou une tabulation)\n",
    "- le fichier utilise une ligne par ligne de tableur\n",
    "\n",
    "Exemple : [Les 1000 premiers numéros du Gaulois en statistiques](./data/csv/gaulois.csv) (grâce à la [BNF](http://api.bnf.fr/m%C3%A9tadonn%C3%A9es-quantitatives-de-la-presse-ancienne-xixe-xxe-si%C3%A8cles#chapitre3) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les Packages\n",
    "\n",
    "Python est fait de nombreuses fonctions de bases. Nous avons vu par exemple qu'il était possible d'utiliser facilement les fonctions `len()` ou encore `print()`. Mais Python possède aussi des `packages` (le nom des librairies et bibliothèques en Python) par défaut.\n",
    "\n",
    "Un package est un ensemble de modules comportant des outils tels que des fonctions et qui peut être assez simplement importé. Par exemple, si je voulais travailler avec le package standard pour utiliser des fichiers CSV, je ferais :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette ligne va me permettre d'importer le module csv. Regardons ce qu'il a dans le ventre :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Dialect',\n",
       " 'DictReader',\n",
       " 'DictWriter',\n",
       " 'Error',\n",
       " 'QUOTE_ALL',\n",
       " 'QUOTE_MINIMAL',\n",
       " 'QUOTE_NONE',\n",
       " 'QUOTE_NONNUMERIC',\n",
       " 'Sniffer',\n",
       " 'StringIO',\n",
       " '_Dialect',\n",
       " '__all__',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " '__version__',\n",
       " 'excel',\n",
       " 'excel_tab',\n",
       " 'field_size_limit',\n",
       " 'get_dialect',\n",
       " 'list_dialects',\n",
       " 're',\n",
       " 'reader',\n",
       " 'register_dialect',\n",
       " 'unix_dialect',\n",
       " 'unregister_dialect',\n",
       " 'writer']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(csv)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C'est bien, mais ça ne vous dit pas grand-chose non ? On voit à la limite quelque chose pour lire (`reader`) et quelque chose pour écrire (`writer`) avec *a priori* deux variations : `DictReader` et `DictWriter`. Mais cela reste vague. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Le package CSV\n",
    "\n",
    "Heureusement, python propose pour ses librairies standards une très bonne documentation : https://docs.python.org/3.5/library/csv.html\n",
    "\n",
    "Je reprends ci-dessous deux morceaux de la documentation, qui sont ceux qui vont d'abord nous intéresser.\n",
    "\n",
    "### 1. Lire\n",
    "\n",
    "Commençons par ce qui est la documentation de `reader()`\n",
    " \n",
    "#### csv.reader(csvfile, dialect=’excel’, **fmtparams)\n",
    "\n",
    "> Return a reader object which will iterate over lines in the given `csvfile`. `csvfile` can be any object which supports the iterator protocol and returns a string each time its `__next__()` method is called — file objects and list objects are both suitable. If csvfile is a file object, it should be opened with newline=''. [1] An optional `dialect` parameter can be given which is used to define a set of parameters specific to a particular CSV dialect. It may be an instance of a subclass of the Dialect class or one of the strings returned by the list_dialects() function. The other optional `fmtparams` keyword arguments can be given to override individual formatting parameters in the current dialect. For full details about the dialect and formatting parameters, see section [Dialects and Formatting Parameters](https://docs.python.org/3.5/library/csv.html#dialects-and-formatting-parameters).\n",
    "\n",
    "> Each row read from the csv file is returned as a list of strings. No automatic data type conversion is performed unless the QUOTE_NONNUMERIC format option is specified (in which case unquoted fields are transformed into floats).\n",
    "\n",
    "> A short usage example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Baked Beans']\n",
      "Spam, Spam, Spam, Spam, Spam, Baked Beans\n",
      "['Spam', 'Lovely Spam', 'Wonderful Spam']\n",
      "Spam, Lovely Spam, Wonderful Spam\n"
     ]
    }
   ],
   "source": [
    "import csv\n",
    "with open('data/csv/eggs.csv', newline='') as csvfile:\n",
    "    spamreader = csv.reader(csvfile, delimiter=' ', quotechar='|')\n",
    "    for row in spamreader:\n",
    "        print(row)\n",
    "        print(', '.join(row))\n",
    "# Spam, Spam, Spam, Spam, Spam, Baked Beans\n",
    "# Spam, Lovely Spam, Wonderful Spamss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**À partir de cette documentation et de cet exemple**, on peut tirer plusieurs conclusions :\n",
    "\n",
    "- `csv.reader()` prend comme premier argument un fichier ouvert\n",
    "- il peut prendre un `dialect` ou des paramètres qui ne sont pas développés par la documentation de la fonction elle-même : dans `**fmtparams`, `**` signifie qu'il existe d'autres paramètres optionnels nominatifs.\n",
    "- il arrive que, sans aller dans *Dialects and Formatting Parameters*, nous avons deux exemples de ces paramètres dans l'exemple :\n",
    "    - `delimiter` qui semble être un délimiteur de colonne.\n",
    "    - `quotechar` qui semble être un \"encapsulateur\" permettant d'échapper les délimiteurs\n",
    "    \n",
    "Regardons le fichier [data/csv/eggs.csv](data/csv/eggs.csv)\n",
    "\n",
    "En lançant l'exemple, on s'aperçoit que le `reader` va renvoyer une liste quand on va itérer dessus: ces listes correspondent aux lignes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Une fonction utile : la fonction enumerate\n",
    "\n",
    "Dans le cadre d'une boucle, enumerate permet de renvoyer un tuple sur une valeur simple afin de de compter l'index de l'objet parcouru :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 = vert\n",
      "1 = rouge\n",
      "2 = bleu\n"
     ]
    }
   ],
   "source": [
    "couleurs = [\"vert\", \"rouge\", \"bleu\"]\n",
    "\n",
    "for index, couleur in enumerate(couleurs):\n",
    "    print(str(index)+ \" = \" + couleur)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercice \n",
    "\n",
    "À partir du fichier `data/csv/gaulois.csv`, compter le nombre de publicités en page 1 sur l'ensemble des numéros. \n",
    "\n",
    "*Attention ! La première ligne est une ligne d'en-tête*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2260\n"
     ]
    }
   ],
   "source": [
    "pubs = 0\n",
    "with open (\"data/csv/gaulois.csv\", newline='') as csvfile:\n",
    "    tableau = csv.reader(csvfile)\n",
    "    for index, colonne in enumerate(tableau):\n",
    "        if index >= 1:\n",
    "            pubs += int(colonne[9])\n",
    "print(pubs)\n",
    "    \n",
    "\n",
    "\n",
    "\"\"\"\n",
    "#correction (j'ai corrigé mon propre code avec la correction)\n",
    "import csv\n",
    "with open('data/csv/gaulois.csv', newline='') as f:\n",
    "    reader = csv.reader(f)\n",
    "    for row_no, row in enumerate(reader):\n",
    "        if row_no >= 1:\n",
    "            pubs += int(row[9])\n",
    "                     \n",
    "#exemple avec une liste de listes pour confirmer que les tableaux sont des listes de listes :\n",
    "\n",
    "elements = [[\"1\", \"2\", \"3\"],[\"vert\", \"2\", \"bleu\"],[\"autre\", \"2\", \"non\"],[\"boubou\", \"2\", \"tiwi\"]]\n",
    "pubs = 0\n",
    "for index, element in enumerate(elements):\n",
    "    if index >= 1:\n",
    "        pubs += int(element[1])\n",
    "print(pubs)\n",
    "\"\"\"\n",
    "\n",
    "# Tests pour vérifier : \n",
    "#le résultat doit être enregistré dans une variable pubs\n",
    "assert pubs == 2260, \"Il y a eu 2260 publicité sur les premiers numéros du Gaulois\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Écrire\n",
    "\n",
    "Si lire est utile, écrire l'est tout autant, surtout lorsque l'on récupère des informations d'ici et là et que l'on veut les remettre en formes\n",
    "\n",
    "Voyons la documentation de csv.writer et son exemple :\n",
    "\n",
    "#### csv.writer(csvfile, dialect=’excel’, **fmtparams)\n",
    "\n",
    ">    Return a writer object responsible for converting the user’s data into delimited strings on the given file-like object. csvfile can be any object with a write() method. If csvfile is a file object, it should be opened with newline='' [1]. An optional dialect parameter can be given which is used to define a set of parameters specific to a particular CSV dialect. It may be an instance of a subclass of the Dialect class or one of the strings returned by the list_dialects() function. The other optional fmtparams keyword arguments can be given to override individual formatting parameters in the current dialect. For full details about the dialect and formatting parameters, see section Dialects and Formatting Parameters. To make it as easy as possible to interface with modules which implement the DB API, the value None is written as the empty string. While this isn’t a reversible transformation, it makes it easier to dump SQL NULL data values to CSV files without preprocessing the data returned from a cursor.fetch* call. All other non-string data are stringified with str() before being written.\n",
    "\n",
    "> A short usage example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "with open('data/csv/eggs.csv', 'w') as csvfile:\n",
    "    spamwriter = csv.writer(csvfile, delimiter=' ', quotechar='|', quoting=csv.QUOTE_MINIMAL)\n",
    "    spamwriter.writerow(['Spam'] * 5 + ['Baked Beans'])\n",
    "    spamwriter.writerow(['Spam', 'Lovely Spam', 'Wonderful Spam'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**À partir de cette documentation et de cet exemple**, on peut tirer plusieurs conclusions :\n",
    "\n",
    "- `csv.writer()` prend comme premier argument un fichier ouvert en mode écriture\n",
    "- il peut prendre un `dialect` ou des paramètres qui ne sont pas développés par la documentation de la fonction elle-même : dans `**fmtparams`, `**` signifie qu'il existe d'autres paramètres optionnels nominatifs.\n",
    "- il arrive que, sans aller dans *Dialects and Formatting Parameters*, nous ayons deux exemples de ces paramètres dans l'exemple :\n",
    "    - `delimiter` qui semble être un délimiteur de colonne.\n",
    "    - `quotechar` qui semble être un \"encapsulateur\" permettant d'échapper les délimiteurs\n",
    "    - `quoting` qui d'après la documentation correspond à un mode de citation minimal (Utilisation des `quotechar` que lorsque cela est nécessaire. C'est par ailleurs la valeur par défaut : https://docs.python.org/3.5/library/csv.html#csv.Dialect.quoting )\n",
    "- on écrit une ligne en utilisant la méthode `.writerow()` qui prend comme argument une liste\n",
    "- on utilise `.writerow()` autant de fois que nécessaire\n",
    "    \n",
    "Regardons le fichier [data/csv/eggs.csv](data/csv/eggs.csv)\n",
    "\n",
    "En lançant l'exemple, on s'aperçoit que le `writer()` va rédiger deux lignes. Ce sont les deux que nous avons lues plus haut."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercice\n",
    "\n",
    "`modules_cours.chapitre4` est un module écrit spécifiquement pour ce cours (si vous êtes [curieux-ses](modules_cours/chapitre4.py)) Dans ce module, il y a la fonction `read_rss()` qui renvoie un générateur contenant des tuples Titre - Résumé - Lien - Date de publication. Par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#le module read_rss ne semble fonctionner que sur linux avec env/bin/activate, pas conda \n",
    "\n",
    "import csv\n",
    "from modules_cours.chapitre4 import read_rss\n",
    "\n",
    "# Il s'agit ici de l'adresse RSS d'un flux de la BNF\n",
    "for entree in read_rss(\"http://www.bnf.fr/Satellite?c=Page&cid=1237374444944&locale=1194947514616&p=1237374444944&pagename=bnf_dev%2FRss&typeRss=Biblio\"):\n",
    "    print(entree)       \n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "À partir de cette fonction, réaliser un CSV (en utilisant le délimiteur `\\t`) pour le flux RSS de Bibliopat : `http://www.bibliopat.fr/rss-actualites`. Le CSV sera stocké à `bibliopat.csv`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['titre', 'date', 'lien']\n",
      "['Assemblée générale 2021', 'Tue, 14 Sep 2021 10:12:40 +0000', 'http://www.bibliopat.fr/actualite-BiblioPat/assemblee-generale-2021']\n",
      "['Journées BiblioPat 2021', 'Sun, 05 Sep 2021 16:40:18 +0000', 'http://www.bibliopat.fr/actualite-BiblioPat/journees-bibliopat-2021']\n",
      "['Vœux 2021 de BiblioPat', 'Fri, 08 Jan 2021 14:57:06 +0000', 'http://www.bibliopat.fr/actualite-BiblioPat/voeux-2021-de-bibliopat']\n",
      "['Assemblée générale 2020 et table-ronde', 'Mon, 16 Nov 2020 17:02:23 +0000', 'http://www.bibliopat.fr/actualite-BiblioPat/assemblee-generale-2020-et-table-ronde']\n",
      "['BiblioPat reconfiné et mobilisé', 'Sun, 01 Nov 2020 16:23:25 +0000', 'http://www.bibliopat.fr/actualite-BiblioPat/bibliopat-reconfine-et-mobilise']\n",
      "['Publication de recommandations pour les services patrimoniaux en temps de pandémie', 'Thu, 30 Apr 2020 16:37:44 +0000', 'http://www.bibliopat.fr/actualite-BiblioPat/publication-de-recommandations-pour-les-services-patrimoniaux-en-temps-de']\n",
      "['Communiqué interassociatif : Recommandations pour un déconfinement progressif des bibliothèques', 'Wed, 29 Apr 2020 17:01:53 +0000', 'http://www.bibliopat.fr/actualite-BiblioPat/communique-interassociatif-recommandations-pour-un-deconfinement-progressif-des']\n",
      "['Communiqué interassociatif portant sur la réouverture des bibliothèques suite au discours du Premier Ministre le 28 avril 2020', 'Tue, 28 Apr 2020 17:45:44 +0000', 'http://www.bibliopat.fr/actualite-BiblioPat/communique-interassociatif-portant-sur-la-reouverture-des-bibliotheques-suite-au']\n",
      "['Vœux 2020', 'Sat, 18 Jan 2020 09:35:28 +0000', 'http://www.bibliopat.fr/actualite-BiblioPat/voeux-2020']\n",
      "['Journées BiblioPat 2019 - Le patrimoine MOUVEMENTé', 'Fri, 08 Nov 2019 13:38:24 +0000', 'http://www.bibliopat.fr/actualite-BiblioPat/journees-bibliopat-2019-le-patrimoine-mouvemente']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\n#correction\\n#ouvrir un fichier dans lequel on va écrire\\n#on va devoir définir une surcouche pour écrire dans ce fichier en CSV\\n#Attention, paramètre pas par défaut délimiteur = TAB\\n#pour chacune des entréees du flux RSS\\n\\n#Ecrire une ligne qui contient titre, lien, date\\n\\nwith open(\"bibliopat.tsv\", mode=\"w\") as f:\\n    #il s\\'agit ici de l\\'adresse RSS d\\'un fluix de la BNF\\n    ecriveur = csv.writer(f, delimiter=\"\\t\")\\n    for titre, resume, lien, date in read_rss(\"http://www.bibliopat.fr/rss-actualites\"):\\n        ecriveur.writerow([titre, lien, date]\\n'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from modules_cours.chapitre4 import read_rss\n",
    "import csv\n",
    "\n",
    "# Votre code ici\n",
    "\n",
    "#mon code pour choisir l'entree que l'on veux dans le flux (10 entŕees différentes)\n",
    "for index, entree in enumerate(read_rss(\"http://www.bibliopat.fr/rss-actualites\")):\n",
    "    if index == 10:\n",
    "        print(entree)\n",
    "        print(type(entree))\n",
    "\n",
    "    \n",
    "#fichier csv en mode écriture\n",
    "with open('bibliopat.csv', mode='w') as f:\n",
    "    tableau = csv.writer(f, delimiter=\"\\t\")\n",
    "    tableau.writerow([\"titre\", \"date\", \"lien\"])\n",
    "    for titre, resume, lien, date in read_rss(\"http://www.bibliopat.fr/rss-actualites\"):\n",
    "        tableau.writerow([titre, date, lien])\n",
    "#j'avais juste mis la valeur entree pour tout le tuple, au lieux de \"titre, resumé, lien, date\", et cela ne marche pas\n",
    "#on dirait qu'il faut forcément assigner un nom de variable à chaque élément du tuple pour après les écrire sur le csv\n",
    "        \n",
    "    \n",
    "#verifier fichier csv\n",
    "with open('bibliopat.csv') as f:\n",
    "    tableau = csv.reader(f, delimiter=\"\\t\")  \n",
    "    for ligne in tableau:\n",
    "        print(ligne)\n",
    "    \n",
    "\"\"\"\n",
    "#correction\n",
    "#ouvrir un fichier dans lequel on va écrire\n",
    "#on va devoir définir une surcouche pour écrire dans ce fichier en CSV\n",
    "#Attention, paramètre pas par défaut délimiteur = TAB\n",
    "#pour chacune des entréees du flux RSS\n",
    "\n",
    "#Ecrire une ligne qui contient titre, lien, date\n",
    "\n",
    "with open(\"bibliopat.tsv\", mode=\"w\") as f:\n",
    "    #il s'agit ici de l'adresse RSS d'un fluix de la BNF\n",
    "    ecriveur = csv.writer(f, delimiter=\"\\t\")\n",
    "    for titre, resume, lien, date in read_rss(\"http://www.bibliopat.fr/rss-actualites\"):\n",
    "        ecriveur.writerow([titre, lien, date]\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "#### Ce que l'on a appris\n",
    "\n",
    "Pour finir cette section, voici un récapitulatif des concepts appris. Lisez la liste et posez des questions si certaines choses ne sont pas claires.\n",
    "\n",
    "- `import`\n",
    "- `from ___ import ___`\n",
    "- la notion de librairie/module/package\n",
    "- `csv.reader()`\n",
    "- `csv.writer()`\n",
    "- `enumerate()`\n",
    "- Lire une documentation et ses exemples\n",
    "\n",
    "#### Ce que l'on recommande d'approfondir\n",
    "\n",
    "Si les fonctions `csv.reader()` et `csv.writer()` sont sympathiques, les fonctions `DictReader` et `DictWriter` le sont beaucoup plus : elles stockent les noms de colonnes ! *cf.* [la documentation](https://docs.python.org/3.5/library/csv.html#csv.DictReader)"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}