1nsi_4_donnees_en_tables_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Traitement de données en table\n",
    "\n",
    "# 2- Cas d'un fichier CSV\n",
    "\n",
    "CSV : abréviation de ‘Comma Separated Values’ ( = valeurs séparées par des virgules). C’est un format de fichier utilisé dans l'importation et l'exportation de feuilles de calculs et de bases de données (légères)\n",
    "\n",
    "\n",
    "Dans cette partie du cours on va utiliser un module de fonctions conçu pour ouvrir et traiter les données contenues dans un fichier csv. Ce module du nom de csv.py devra être importé pour pouvoir être utilisé.\n",
    "Après avoir ouvert le fichier en mode lecture, on peut utiliser l’une des méthodes suivantes :\n",
    "\n",
    "    • csv.reader(nom_objet_fichier, delimiter = ’,’ ) qui renvoie un objet lecteur, qui itérera sur les lignes de l'objet \n",
    "    nom_objet_fichier donné en paramètre. Chaque ligne lue depuis le fichier CSV est renvoyée comme une liste de chaînes de caractères.\n",
    "    \n",
    "    • csv.DictReader(nom_objet_fichier, delimiter = ’,’ ) renvoie un objet qui opère comme un lecteur ordinaire mais assemble\n",
    "     les informations de chaque ligne dans un dictionnaire dont les clés sont données par les valeurs de la première ligne du\n",
    "     fichier. (Rque : on donne ici une version simplifiée de cette méthode, ce qui signifie que l’on devra utiliser des fichiers\n",
    "     csv dont la première ligne est constituée des en-têtes de colonnes. Si cette première ligne n’existe pas on sera amener à la\n",
    "     créer, par exemple avec un tableur)\n",
    "    \n",
    "Dans l'exemple ci-dessous, le fichier des départements a été converti en csv mais en gardant le délimiteur tabulation ('\\t'). Lors de la création de l'objet lecteur, on devra donc spécifier ce délimiteur :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# utilisation de csv.reader() :\n",
    "\n",
    "import csv\n",
    "\n",
    "fichier = open('data/departements_reduit.csv', 'r') # ouverture du fichier en lecture\n",
    "\n",
    "lecteur = list(csv.reader(fichier, delimiter='\\t'))\n",
    "fichier.close()\n",
    "\n",
    "print(type(lecteur),'\\n')    # pour voir le type de l'objet lecteur que l'on a créé\n",
    "print(lecteur,'\\n')          # pour voir le contenu brut de cet objet\n",
    "\n",
    "for ligne in lecteur:   # ici on en fait une présentation plus agréable\n",
    "    print(ligne)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le résultat de l'exécution de ce code montre que l'objet lecteur est une liste de liste. On retrouve la situation vue dans le notebook précédent, ce qui fait que nous n'irons pas plus loin avec cette méthode csv.reader()\n",
    "\n",
    "On va refaire le même programme en utilisant cette fois la méthode csv.DictReader() :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# utilisation de csv.DictReader() :\n",
    "\n",
    "import csv\n",
    "\n",
    "fichier = open('data/departements_reduit.csv', 'r') # ouverture du fichier en lecture\n",
    "\n",
    "lecteur = list(csv.DictReader(fichier, delimiter='\\t'))\n",
    "fichier.close()\n",
    "\n",
    "print(type(lecteur),'\\n')    # pour voir le type de l'objet lecteur que l'on a créé\n",
    "print(lecteur,'\\n')          # pour voir le contenu brut de cet objet\n",
    "\n",
    "for ligne in lecteur:   # ici on en fait une présentation plus agréable\n",
    "    print(dict(ligne))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En situation réelle, on aura intérêt à stocker notre structure de données (ci-dessus on n'a fait que l'afficher) : on va créer une liste vide que l'on remplit avec les dictionnaires :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# utilisation de csv.DictReader() :\n",
    "\n",
    "import csv\n",
    "\n",
    "fichier = open('data/departements_reduit.csv', 'r') # ouverture du fichier en lecture\n",
    "\n",
    "lecteur = list(csv.DictReader(fichier, delimiter='\\t'))\n",
    "fichier.close()\n",
    "\n",
    "france = []                  # création d'une liste vide\n",
    "for ligne in lecteur:          \n",
    "    france.append(dict(ligne))    # ajout \" à la volée\" des dictionnaires représentant les enregistrements de la table\n",
    "\n",
    "    # ... et si on a besoin plus tard de l'afficher :  \n",
    "for elt in france:\n",
    "    print(elt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3- Exploitation et traitement des données\n",
    "\n",
    "## 3.1 Recherche dans une table\n",
    "\n",
    "Sur le site de l’Observatoire National de la Biodiversité, on a récupéré un fichier présentant le résultat du suivi temporel des oiseaux communs de 2001 à 2018. Ce fichier a été porté au format csv : tendance_STOC.csv \n",
    "\n",
    "![title](images/tableur_stoc.png)\n",
    "\n",
    "Remarque : pour des petites variations mesurées (de -5% à +5%), on estime qu'elles sont alors trop faibles pour être significatives. Ceci est reporté dans la colonne 'significatif' pour laquelle la valeur de l'attribut peut être :\n",
    " - False si la variation est comprise entre (-5% et +5%)\n",
    " - True au delà\n",
    " \n",
    " **Questions :**\n",
    "\n",
    " - Q1- Déterminer le séparateur utilisé dans ce fichier csv. Est-ce un fichier csv pur ?\n",
    "\n",
    " - Q2- Réaliser un programme Python qui charge ces données dans une structure de type liste de dictionnaires, structure que l’on appellera **stoc**. Vérifier par affichage que cette structure stoc est bien représentative du fichier :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Programme question 2 :\n",
    "???\n",
    "...\n",
    "???\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Q3- Afficher le nom ainsi que le pourcentage de variation des **espèces pour lesquelles la population a doublé (ou plus) entre 2001 et 2018**. Les enregistrements de ces espèces seront mis dans une liste appelée **extraction** , créée en **compréhension**, avant d’en afficher les attributs demandés. On affichera également le nombre d’espèces concernées"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Programme question 3 :\n",
    "???\n",
    "...\n",
    "???\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Q4- Extraire dans la liste **extraction** les enregistrements des espèces dont la population a **diminué de façon significative** au cours de la période d’étude. Afficher le nombre d’espèces concernées, leur nom ainsi que le pourcentage de variation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Programme question 4\n",
    "???\n",
    "...\n",
    "???\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Q5- Ecrire le programme qui permet d’afficher une phrase comparative du genre:\n",
    "\n",
    "*'xx espèces d’oiseaux ont vu leur population augmenter de façon significative alors que yy  espèces d’oiseaux ont vu leur population diminuer de façon significative'*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Programme question 5 :\n",
    "???\n",
    "...\n",
    "???\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2- Supprimer les doublons\n",
    "\n",
    "Il peut arriver dans une table d’avoir des **doublons c’est à dire deux enregistrements identiques**. Ceci peut arriver pour différentes raisons : par exemple deux personnes différentes travaillant sur la même table de données et qui entrent le même enregistrement.\n",
    "\n",
    "Il est préférable d’éliminer ces doublons. \n",
    "\n",
    "*On a introduit volontairement* trois doublons dans le fichier tendance_STOC.csv et il a été renommé **tendance_STOC_dbl.csv**. \n",
    "\n",
    "(pour aider à une vérification visuelle rapide, un de ces trois doublons est la cigogne que l’on a placé après l’outarde...)\n",
    "\n",
    "On demande **d’éliminer les doublons de ce fichier** (et d’indiquer combien il y en avait).\n",
    "\n",
    "On propose la technique suivante :\n",
    "\n",
    "    • on crée et on charge la liste ‘stoc’ avec tous les enregistrements de la table (il y aura donc dedans les doublons)\n",
    "\n",
    "    • on vient créer une liste vide que l’on appellera ‘stoc_zd’ (pour stoc zéro doublons).\n",
    "\n",
    "    • on balaye toute la liste stoc élément par élément et on ajoute un élément à la liste stoc_zd s’il n’existe pas déjà dedans\n",
    "\n",
    "    • on pourra vérifier que l’on a bien éliminé 3 doublons et que la liste ‘stoc_zd’ ne les contient plus (par exemple, vérifier la cigogne qui était en trop)\n",
    "\n",
    "    • on propose ensuite de recopier cette liste bonne dans stoc : pour cela on propose d’utiliser la méthode copy du module copy (rechercher les informations nécessaires sur cette méthode)\n",
    "    \n",
    "    • vérifier que la liste stoc ainsi recréée comporte bien les 153 espèces de la bonne liste (celles que l’on avait dans le fichier ‘tendance_STOC.csv’)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "import copy\n",
    "\n",
    "fichier = open('data/tendance_STOC_dbl.csv', 'r') # ouverture du fichier en lecture\n",
    "\n",
    "lecteur = list(csv.DictReader(fichier, delimiter=';'))\n",
    "fichier.close()\n",
    "\n",
    "stoc = []                  # création d'une liste vide\n",
    "for ligne in lecteur:          \n",
    "    stoc.append(dict(ligne))    # ajout \" à la volée\" des dictionnaires représentant les enregistrements de la table\n",
    "# programme à compléter ...\n",
    "???\n",
    "...\n",
    "???"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3  Test de cohérence d’une table\n",
    "\n",
    "Un autre problème qui peut se poser, et qu’il est préférable là aussi d’éliminer avant de commencer du travail sur l’extraction de données, c’est de vérifier la cohérnece d'une table. \n",
    "\n",
    "On a modifié la table tendance_STOC.csv en supprimant 3 valeurs d'attributs ; le fichier a été renommé 'tendance_STOC_incoherente.csv'.\n",
    "\n",
    "Travail à faire : \n",
    " - rechercher et afficher les enregistrements en erreur\n",
    " - afficher le nombre d'erreurs rencontrées dans la table\n",
    " - faire subir ce test de cohérence au fichier initial 'tendance_STOC.csv' et vérifier qu'en sortie aucune erreur n'a été trouvée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "???\n",
    "...\n",
    "???"
   ]
  }
 ],
 "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-final"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}