{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1> Indexation de tables </h1>\n",
    "\n",
    "<p> Nous allons d'abord voir comment Python ouvre un fichier, l'édite ou le modifie.</p>\n",
    "\n",
    "<p> Plusieurs méthodes permettent de lire de tels fichiers en utilisant ou non des bibliothèques adaptées.</p>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> Fonctions élémentaires de lecture/écriture de fichiers </h3>\n",
    "\n",
    "<p> Les fonctions élémentaires de lecture écriture des fichiers textes sont adaptées à la lecture ligne à ligne : </p>\n",
    "\n",
    "* Ouverture en lecture : `f = open('nom.txt','r')`\n",
    "* Ouverture en écriture : `g = open('nom.txt','w')`\n",
    "* Fermeture : `f.close()`\n",
    "* Ouverture et fermeture avec une structure de bloc : `with open('nom.txt','r') as f :`\n",
    "* Lire la ligne suivante : `ligne = f.readline()`\n",
    "* lires toutes leslignes : `leslignes = f.readlines()`\n",
    "* Parcourir toutes les lignes : `for ligne in f:`\n",
    "* Écrire dans le fichier : `g.write('message')`\n",
    "* Écrire dans le fichier avec passage à la ligne : `g.write('message\\n')`\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> Exercice 1 :</h4> a)  Créer un fichier texte avec un éditeur de texte ( le boc notes de Windows)  <br> Ecrire 5 lignes dans ce fichier <br>\n",
    "Le sauvegarder sous le nom monfichier.txt dans le même répertoire que ce notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> b) Voici 3 codes possibles pour ouvrir et afficher les lignes du fichier : </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f=open('monfichier.txt','r',encoding=\"UTF-8\")\n",
    "ligne=f.readline()\n",
    "print(ligne)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f=open('monfichier.txt','r',encoding=\"UTF-8\")\n",
    "leslignes=f.readlines()\n",
    "print(leslignes)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('monfichier.txt','r',encoding=\"UTF-8\") as f:\n",
    "    for ligne in f:\n",
    "        print(ligne)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> c) on va maintenant voir comment créer un fichier et écrire dans un fichier </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('nouveaufichier.txt','w',encoding=\"UTF-8\") as g:\n",
    "    g.write('voici la 1ere ligne\\n')\n",
    "    g.write('la deuxième\\n')\n",
    "    g.write('fin')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> d) Aller vérifier dans votre dossier la création d'un fichier nouveaufichier.txt, l'ouvrir et vérifier son contenu.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> Exercice 2 :</h4> A partir de votre fichier monfichier.txt, écrire un code qui génére un autre fichier qui sera composé des lignes 1, 3 et 5 de monfichier.txt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h5> utilisation de  split et strip </h5>\n",
    "<p>Dans le cas d'un fichier tabulé ou avec séparateur, le décodage d'une ligne nécessite de séparer les différentes valeurs des champs en précisant le séparateur utilisé. La méthode `split` permet de faire ce traitement sur une chaîne de caractères.<br>\n",
    "\n",
    "Il suffit de lui préciser le séparateur à utiliser : `'\\t'` pour tab, `';'`, `':'` ou `','` par exemple.<br>\n",
    "\n",
    "La méthode strip permet de supprimer les blancs en debut et fin de ligne.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ligne = '     truc,12.5,2018,Nantes,253000,bonjour         '\n",
    "ligne.split(',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ligne.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ligne.strip().split(',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> Importation d'un fichier CSV </h2>\n",
    "<h3> On va voir plusieurs méthodes pour n'en retenir qu'une seule </h3>\n",
    "\n",
    "<p> On pourrait utiliser les méthodes précédentes pour importer les lignes d'un fichier CSV dans un tableau puis il faudrait ensuite traiter chaque ligne chaque ligne et séparer les champs dans des listes.<br>\n",
    "On obtient un tableau de listes ( = tableau de tableau).<br>\n",
    "Voici un code possible avec le fichier countries.csv <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table1 = []\n",
    "with open('countries.csv') as f:\n",
    "        f.readline() # on lit la 1ère ligne mais celle-ci ne sera pas traitée dans le tableau\n",
    "        for ligne in f:# on parcourt chaque ligne\n",
    "            ligne=ligne.strip()# on traite la ligne en enlevant les fins de ligne si besoin\n",
    "            table1.append (ligne.split(';'))# on ajoute la ligne au tableau"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(table1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Remarque1**: toutes les informations manipulées par les fonctions standard de lecture, ainsi que la fonction `split` manipulent uniquement des chaînes de caractères. Si certains champs contiennent des nombres, il faut les convertir explicitement avec les fonctions `int` ou `float`.\n",
    "* **Remarque2** : Cette structure n’est pas la plus satisfaisante car le lien entre les valeurs du tableau et le nom des descripteurs n’est pas direct."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les données peuvent etre enregistrés dans un tableau de dictionnaires"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table2 = []\n",
    "with open('countries.csv') as f:\n",
    "        c=f.readline() # les clés des enregistrements sont obtenus à partir de la 1ere ligne du fichier\n",
    "        c=c.strip() # on enlève les espaces de début et fin de ligne\n",
    "        c=c.split(';') # on convertit c en une liste de toutes les clés\n",
    "        for ligne in f: # on parcourt les lignes du fichier\n",
    "            ligne=ligne.strip()\n",
    "            ligne=ligne.split(';')\n",
    "            D={}\n",
    "            for i in range(len(c)):\n",
    "                D[c[i]]=ligne[i] # on affecte à chaque clé sa valeur\n",
    "            table2.append(D) # on ajoute chaque dictionnaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(table2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> Lecture d'une table avec la bibliothèque CSV </h2> \n",
    "\n",
    "<p> La bibliothèque `csv` fournit des fonctions permettant de lire l'ensemble des lignes d'un fichier `CSV` en séparant les champs selon le séparateur indiqué.<br>\n",
    "\n",
    "La méthode `reader` permet de lire la table ligne à ligne et renvoit successivement pour chaque ligne un tableau des champs de chaque ligne. La première ligne contient les noms des champs.<br>\n",
    "\n",
    "Voici une portion de code permettant de charger le fichier countries.csv , avec des points-virgules comme délimitations.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv  # importation de la bibliothèque csv\n",
    "with open(\"countries.csv\", \"r\",encoding=\"UTF-8\") as csvfile: # ouverture du fichier\n",
    "    c = csv.reader(csvfile, delimiter=';') # création d'un objet \"c\" à itérer\n",
    "    pays = []\n",
    "    for ligne in c:# on parcourt c ligne par ligne\n",
    "        pays.append(ligne) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(pays)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Dans ce cas, les résultats sont stockés sous forme d’un tableau de tableaux (ou liste de listes au sens de Python).<br>\n",
    "\n",
    "On peut ainsi obtenir la liste des noms des champs (ligne d’en-tête) : </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pays[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "puis le premier enregistrement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pays[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> C'est quoi ce 468 ? <br> Cette structure n’est pas la plus satisfaisante car le lien entre les valeurs du tableau pays[1]  et le nom des enregistrements, contenus dans pays[0] , n’est pas direct. </p> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> Dictionnaires Ordonnés </h2>\n",
    "<p> La méthode <strong>DictReader </strong> permet de lire la table ligne à ligne et renvoit successivement pour chaque ligne un dictionnaire des champs de cette ligne. La première ligne du fichier a servi à obtenir les clés utilisés pour chaque enregistrement.\n",
    "\n",
    "On obtient une liste de dictionnaires ordonnés. Les dictionnaires ordonnés sont des dictionnaires qui stockent un ordre particulier pour les clés. Nous utiliserons ces objets comme de simples dictionnaires."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "with open(\"countries.csv\", \"r\",encoding=\"UTF-8\") as csvfile:\n",
    "    d = csv.DictReader(csvfile, delimiter=';')\n",
    "    pays = []\n",
    "    for ligne in d:\n",
    "        pays.append(dict(ligne)) # Conversion du type OrderedDict en dictionnaire\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(pays)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> La conversion du dictionnaire ordonné en dictionnaire (dict(row)) permet uniquement d’avoir un affichage plus plaisant.<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Cette fois, on obtient un tableau de p-uplets représentés sous forme de dictionnaire :</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pays[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> Ecriture d'un fichier CSV à partir d'une table</h2>\n",
    "\n",
    "<p> Le module csv de Python propose aussi des fonctions utilitaires pour écrire le contenu d'un tableau de dictionnaires dans un fichier csv </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "notretable=[{'nom':'Turing','prénom':'Alan','Année de Naissance':1912},{'nom':'Hooper','prénom':'Grace','Année de Naissance':1906},{'nom':'Torvald','prénom':'Linus','Année de Naissance':1969}]\n",
    "nomcolonnes=[\"nom\",\"prénom\",\"Année de Naissance\"]\n",
    "with open(\"informaticien.csv\",\"w\",encoding=\"UTF-8\") as sortie:\n",
    "    new=csv.DictWriter(sortie,fieldnames=nomcolonnes)\n",
    "    new.writeheader()\n",
    "    new.writerows(notretable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Aller vérifier avec un éditeur de texte le contenu du fichier informaticien.csv qui a été créé dans le repertoire </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4>  Dans la suite, nous allons voir comment exploiter une table pour y faire des recherches ou des tris </h4>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}