{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Consulter un fichier texte - Analyse de données d'un fichier CSV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"top\">**Définition** : un fichier texte est un fichier dont le contenu représente uniquement une suite de caractères (*lettres, chiffres*).\n",
    "\n",
    "Il possède un nom et a pour extension $\\texttt{'.txt'}$\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarque : Le bloc-note de Windows ou n'importe quel traitement de texte peut enregistrer les données saisies en un fichier texte ou encore appelé \"texte brut\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "1. **<a href=\"#S1\">Comment consulter un fichier texte depuis Python</a>**\n",
    "2. **<a href=\"#S2\">Écrire des données dans un fichier texte</a>**\n",
    "3. **<a href=\"#S3\">Ajouter des données dans un fichier existant déjà</a>**\n",
    "4. **<a href=\"#S4\">Analyse de données d'un fichier CSV</a>**\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/Fklag/SNT/master)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <div id=\"S1\">1. Comment consulter un fichier texte depuis Python</div> \n",
    "\n",
    "<div style=\"text-align : right\"><a href=\"#top\">Retour</a></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lire-Écrire-Ajouter**\n",
    "\n",
    "Lire un fichier $\\texttt{'doc.txt'}$ nous permettra soit d'afficher les données qu'il contient soit de collecter une partie d'entre elles et de las stocker dans une liste ou un dictionnaire ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|                      |             Commande             | Rôle                |\n",
    "|----------------------|:--------------------------------:|:---------------------|\n",
    "| Ouvrir  $\\texttt{f}$ | $\\texttt{f=open('doc.txt','r')}$ |Ouvre $\\texttt{f}$ en mode LECTURE  $\\texttt{r}$ est mis pour $\\texttt{read}$ (*lire en français*) |\n",
    "| Lire $\\texttt{f}$  |   $\\texttt{f.read()}$  |  Affiche le contenu de $\\texttt{'doc.txt'}$ dans la console   |\n",
    "| | $\\texttt{f.readlines()}$ | Récupère la liste des lignes de $\\texttt{'doc.txt'}$ |\n",
    "| | $\\texttt{for a in f :}$ | On parcourt les lignes de $\\texttt{f}$. $\\texttt{f}$ est donc itérable ! |\n",
    "| Fermer $\\texttt{f}$  |       $\\texttt{f.close()}$       | Fermer $\\texttt{f}$ |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On dispose du fichier texte $\\texttt{'fruits.txt'}$ suivant :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "fraise\n",
    "kiwi\n",
    "banane\n",
    "orange\n",
    "abricot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Lire avec $\\texttt{f.read()}$**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fraise\n",
      "kiwi\n",
      "banane\n",
      "orange\n",
      "abricot\n",
      "\n"
     ]
    }
   ],
   "source": [
    "f=open('fruits.txt','r')\n",
    "print(f.read())\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Lire avec $\\texttt{f.readlines()}$**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['fraise\\n', 'kiwi\\n', 'banane\\n', 'orange\\n', 'abricot\\n']\n"
     ]
    }
   ],
   "source": [
    "f=open('fruits.txt','r')\n",
    "L=f.readlines()\n",
    "print(L)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**$\\texttt{\\n}$** est le symbole qui crée un retour à la ligne dans le fichier texte.  *(Il signifie $\\texttt{\"Line feed\"}$, \"saut de ligne\" en français*)\n",
    "\n",
    "**Remarque** : $\\texttt{L = f.readlines()}$ est la liste des lignes de $\\texttt{'fruits.txt'}$ \n",
    "* $\\texttt{L[0]}$ correspond à $\\texttt{'fraise\\n'}$ \n",
    "* $\\texttt{L[1]}$ correspond à $\\texttt{'kiwi\\n'}$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Lire en parcourant $\\texttt{f}$**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fraise\n",
      "\n",
      "kiwi\n",
      "\n",
      "banane\n",
      "\n",
      "orange\n",
      "\n",
      "abricot\n",
      "\n"
     ]
    }
   ],
   "source": [
    "f=open('fruits.txt','r')\n",
    "for a in f :\n",
    "    print(a)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remarque** : l'affichage est le même qu'avec $\\texttt{read}($$\\ )$ sauf qu'en plus les sauts de lignes sont appliqués. Pour éviter les sauts de lignes, on propose :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fraise\n",
      "kiwi\n",
      "banane\n",
      "orange\n",
      "abricot\n"
     ]
    }
   ],
   "source": [
    "f=open('fruits.txt','r')\n",
    "for a in f :\n",
    "    print(a.replace('\\n',''))\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Attention au séparateur décimal**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\texttt{'.'}$ est le séparateur décimal pour $\\texttt{Python}$. Exemple : $\\texttt{3.5}$ désigne le nombre réel $\\texttt{3,5}$\n",
    "\n",
    "On dispose du fichier $\\texttt{'data.txt'}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3\n",
    "1,5\n",
    "4,6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour collecter ces trois nombres dans une liste on peut faire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['3', '1.5', '4.6']\n"
     ]
    }
   ],
   "source": [
    "L=[]\n",
    "f=open('data.txt','r')\n",
    "for a in f :\n",
    "    a=a.replace('\\n','')\n",
    "    L.append(a.replace(',','.'))\n",
    "f.close()\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On obtient une liste de chaines de caractères, pour obtenir la liste de nombre réels, on fera :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.0, 1.5, 4.6]\n"
     ]
    }
   ],
   "source": [
    "G=[float(s) for s in L]\n",
    "print(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <div id=\"S2\">2. Écrire des données dans un fichier texte</div> \n",
    "\n",
    "<div style=\"text-align : right\"><a href=\"#top\">Retour</a></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|                      |             Commande             | Rôle                |\n",
    "|----------------------|:--------------------------------:|:---------------------|\n",
    "| Ouvrir  $\\texttt{f}$ | $\\texttt{f=open('doc.txt','w')}$ |Ouvre $\\texttt{f}$ en mode ÉCRITURE  $\\texttt{w}$ est mis pour $\\texttt{write}$ (*écrire en français*) |\n",
    "| Écrire $\\texttt{f}$  |   $\\texttt{f=write('donnees')}$  |  Écrit sur $\\texttt{f}$ la chaîne de caractères $\\texttt{'donnees'}$   |\n",
    "| | | **Si** $\\texttt{'doc.txt'}$ existe déjà alors son contenu est effacé et $\\texttt{Python}$ écrit les nouvelles données |\n",
    "| | | **Sinon** $\\texttt{'doc.txt'}$ est créé et $\\texttt{Python}$ écrit les nouvelles données |\n",
    "| Fermer $\\texttt{f}$  |       $\\texttt{f.close()}$       | Fermer $\\texttt{f}$ |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Exemple**\n",
    "\n",
    "On souhaite écrire les $10$ premiers multiples de $2$ :\n",
    "\n",
    "$2,4,6,\\ldots,20$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "f=open('multiples2.txt','w')\n",
    "f.write('Liste des multiples de 2:')\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remarques** :\n",
    "* rien n'est affiché en sortie !\n",
    "* puisque $\\texttt{'multiple2.txt'}$ n'existait pas le fichier a été créé dans le même répertoire que le script $\\texttt{Python}$ son contenu est\n",
    "\n",
    "Liste des multiples de 2:\n",
    "\n",
    "**Amélioration du code :**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fini\n"
     ]
    }
   ],
   "source": [
    "f=open('multiples2.txt','w')\n",
    "f.write('Liste des multiples de 2:')\n",
    "for i in range (1,11):\n",
    "    x=2*i\n",
    "    f.write(str(x))\n",
    "f.close()\n",
    "print('fini')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Liste des multiples de 2:2468101214161820\n",
    "\n",
    "*il n'y a pas d'espaces entre les différents multiples de 2 !*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fini\n"
     ]
    }
   ],
   "source": [
    "f=open('multiples2.txt','w')\n",
    "f.write('Liste des multiples de 2:\\n')\n",
    "s=''\n",
    "for i in range (1,11):\n",
    "    x=2*i\n",
    "    s = s + '{0:^4},'.format(x)\n",
    "f.write(s[0:len(s)-1])\n",
    "f.close()\n",
    "print('fini')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Liste des multiples de 2:\n",
    " 2  , 4  , 6  , 8  , 10 , 12 , 14 , 16 , 18 , 20 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color:#f0f0fa;\">\n",
    "<br/>\n",
    "**Exercice** : On considère une année A.\n",
    "<ul>\n",
    "<li>Si A n'est pas divisible par $4$, l'année n'est pas bissextile</li>\n",
    "\n",
    "<li>Si A est divisible par $4$, l'année est bissextile sauf si A est divisible par $100$ et pas par $400$</li>\n",
    "\n",
    "</ul>\n",
    "\n",
    "Écrire un script $\\texttt{Python}$ permettant d'obtenir un fichier texte :\n",
    "</div>\n",
    "\n",
    "| Année           | bissextile    |\n",
    "|: ------------- :|:-------------:|\n",
    "| 2000      | Oui |\n",
    "| 2001      | Non |\n",
    "| 2002      | Non | \n",
    "| ..      | .. | \n",
    "| 2020      | Oui | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fini\n"
     ]
    }
   ],
   "source": [
    "f=open('bissextile.txt','w')\n",
    "f.write('{0:^10} | {1:^20}\\n'.format(\"année\",\"bisssextile\"))\n",
    "f.write('-'*30+'\\n')\n",
    "for A in range (2000,2021):\n",
    "    if A%4==0 and (A%100>0 or A%400==0):\n",
    "        s = '{0:^10} | {1:^20}\\n'.format(A,'Oui')\n",
    "    else :\n",
    "        s = '{0:^10} | {1:^20}\\n'.format(A,'Non')\n",
    "    f.write(s)\n",
    "f.close()\n",
    "print('fini')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <div id=\"S3\">3. Ajouter des données dans un fichier existant déjà</div> \n",
    "\n",
    "<div style=\"text-align : right\"><a href=\"#top\">Retour</a></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|                      |             Commande             | Rôle                |\n",
    "|----------------------|:--------------------------------:|:---------------------|\n",
    "| Ouvrir  $\\texttt{f}$ | $\\texttt{f=open('doc.txt','a')}$ |Ouvre $\\texttt{f}$ en mode AJOUT  $\\texttt{a}$ est mis pour $\\texttt{append}$ (*ajouter en français*) |\n",
    "| Écrire $\\texttt{f}$  |   $\\texttt{f=write('donnees')}$  |  Ajoute sur $\\texttt{f}$ la chaîne de caractères $\\texttt{'donnees'}$   |\n",
    "| | | **Si** $\\texttt{'doc.txt'}$ existe déjà alors son contenu est complété par l'ajout des nouvelles données |\n",
    "| | | **Sinon** $\\texttt{'doc.txt'}$ est créé et $\\texttt{Python}$ écrit les nouvelles données |\n",
    "| Fermer $\\texttt{f}$  |       $\\texttt{f.close()}$       | Fermer $\\texttt{f}$ |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exemple**\n",
    "\n",
    "On veut ajouter à la fin du fichier $\\texttt{'fruits.txt'}$ le message \"c'est excellent !\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "f=open('fruits.txt','a')\n",
    "f.write(\"c'est excellent !\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <div id=\"S4\">4. Analyse de données d'un fichier CSV</div> \n",
    "\n",
    "<div style=\"text-align : right\"><a href=\"#top\">Retour</a></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color:#f0f0fa;\">\n",
    "<b>Définition</b>\n",
    "<br/>\n",
    "\n",
    "Un fichier CSV est un fichier tableur, contenant des données (<i>lettres, chiffres</i>)\n",
    "\n",
    "<br/>\n",
    "\n",
    "Pour chaque ligne, les données sont séparées par un caractère de séparation (généralement une virgule, un point-virgule ou une tabulation).\n",
    "\n",
    "<br/>\n",
    "\n",
    "Un fichier CSV permet de traiter des données présentées dans un tableau, avec plus de facilité.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* On peut lire un fichier $\\texttt{CSV}$ à l'aide d'un tableur comme EXCEL ou OPENOFFICE\n",
    "\n",
    "* Nous souhaiterions ouvrir un fichier $\\texttt{CSV}$ avec $\\texttt{Python}$ et exploiter les données."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exemple**\n",
    "\n",
    "Considérons le fichier $\\texttt{csv}$ $\\texttt{\"tableau.csv\"}$ correspondant à\n",
    "\n",
    "|   |       A      |       B      |\n",
    "|---|:------------:|:------------:|\n",
    "| 1 | Valeurs de x | Valeurs de y |\n",
    "| 2 |       0      |      0,5     |\n",
    "| 3 |       2      |     -0,5     |\n",
    "| 4 |       5      |      -2      |\n",
    "| 5 |       7      |      -3      |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Lecture en tant que fichier texte**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valeurs de x;Valeurs de y\n",
      "0;0,5\n",
      "2;-0,5\n",
      "5;-2\n",
      "7;-3\n",
      "\n"
     ]
    }
   ],
   "source": [
    "f=open('tableau.csv','r')\n",
    "print(f.read())\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Utiliser le module csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour mieux accéder à n'importe quel élément de chacune de ces lignes, on préfera utiliser le module $\\texttt{csv}$\n",
    "\n",
    "**Important** Saisir en préambule :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Lire un fichier csv**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lire le fichier $\\texttt{'doc.csv'}$ nous permettra soit d'afficher les données qu'il contient soit de collecter une partie d'entre elles et de les stocker dans une liste ou un dictionnaire ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|                      |             Commande             | Rôle                |\n",
    "|----------------------|:--------------------------------:|:---------------------|\n",
    "| Ouvrir  $\\texttt{f}$ | $\\texttt{f=open('doc.csv','r')}$ |Ouvre $\\texttt{f}$ en mode LECTURE  $\\texttt{r}$  |\n",
    "| Ouvrir $\\texttt{F}$  |   $\\texttt{F=csv.reader(f,delimiter=';')}$  |  Ouvre l'objet fichier $\\texttt{F}$ grâce au module $\\texttt{CSV}$   |\n",
    "| | | Le paramètre  $\\texttt{delimiter=';'}$ précise que $\\texttt{';'}$ sépare les éléments d'une ligne de $\\texttt{'doc.csv'}$ |\n",
    "| Parcourir  $\\texttt{F}$ | $\\texttt{for a in F :}$ | On parcourt les lignes de $\\texttt{F}$. $\\texttt{F}$ est donc itérable ! |\n",
    "| Fermer $\\texttt{f}$  |       $\\texttt{f.close()}$       | Fermer $\\texttt{f}$ |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Valeurs de x', 'Valeurs de y']\n",
      "['0', '0,5']\n",
      "['2', '-0,5']\n",
      "['5', '-2']\n",
      "['7', '-3']\n"
     ]
    }
   ],
   "source": [
    "import csv\n",
    "f=open('tableau.csv','r')\n",
    "F=csv.reader(f,delimiter=';')\n",
    "for ligne in F :\n",
    "    print(ligne)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les éléments de $\\texttt{F}$ sont les listes des éléments de chaque ligne de $\\texttt{'tableau.csv'}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Ajouter une ligne de données à un fichier csv**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|                      |             Commande             | Rôle                |\n",
    "|----------------------|:--------------------------------:|:---------------------|\n",
    "| Ouvrir  $\\texttt{f}$ | $\\texttt{f=open('doc.csv','a')}$ |Ouvre $\\texttt{f}$ en mode $\\texttt{a}$  |\n",
    "| Ouvrir $\\texttt{F}$  |   $\\texttt{F=csv.writer(f,delimiter=';')}$  |  Ouvre l'objet fichier $\\texttt{F}$ grâce au module $\\texttt{CSV}$   |\n",
    "| | | Le paramètre  $\\texttt{delimiter=';'}$ précise que $\\texttt{';'}$ sépare les éléments d'une ligne de $\\texttt{'doc.csv'}$ |\n",
    "| Écrire  $\\texttt{F}$ | $\\texttt{F.writerow(['donnee1','donnee2'])}$ | On ajoute la ligne  $\\texttt{'donnee1';'donnee2'}$ au fichier $\\texttt{'doc.csv'}$ |\n",
    "| Fermer $\\texttt{f}$  |       $\\texttt{f.close()}$       | Fermer $\\texttt{f}$ |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exemple**\n",
    "\n",
    "On souhaite ajouter à la fin du fichier $\\texttt{tableau.csv}$, sur la même ligne, les nombres $10$ et $20$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import csv\n",
    "f=open('tableau.csv','a')\n",
    "F=csv.writer(f,delimiter=';')\n",
    "F.writerow(['10','20'])\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color:#f0f0fa;\">\n",
    "<br/>\n",
    "**Exercice** : \n",
    "<ol>\n",
    "<li>Écrire un script $\\texttt{Python}$ qui calcule :</li>\n",
    "<ul>\n",
    "<li>la moyenne des éléments de la plage $\\texttt{A2:A6}$ notée $\\texttt{a}$</li>\n",
    "\n",
    "<li>la moyenne des éléments de la plage $\\texttt{B2:B6}$ notée $\\texttt{b}$</li>\n",
    "\n",
    "</ul>\n",
    "\n",
    "<li>Modifier ce script pour qu'il affiche ces nombres sur une même ligne, dans le fichier  $\\texttt{tableau.csv}$:</li>\n",
    "</ol>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|   |       A       |       B      |       C       |  D  |\n",
    "|---|:-------------:|:------------:|:-------------:|:---:|\n",
    "| 1 |  Valeurs de x | Valeurs de y |               |     |\n",
    "| 2 |       0       |      0,5     |               |     |\n",
    "| 3 |       2       |     -0,5     |               |     |\n",
    "| 4 |       5       |      -2      |               |     |\n",
    "| 5 |       7       |      -3      |               |     |\n",
    "| 6 | 10            | 20           |               |     |\n",
    "| 7 | moyenne des x | 4.8          | moyenne des y | 3.0 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.8 3.0\n"
     ]
    }
   ],
   "source": [
    "import csv\n",
    "import numpy as np\n",
    "\n",
    "f=open('tableau.csv','r')\n",
    "F=csv.reader(f,delimiter=';')\n",
    "X=[]\n",
    "Y=[]\n",
    "for s in F :                 # F est iterable\n",
    "    x=s[0].replace(',','.')  # Remplace la virgule par un .\n",
    "    y=s[1].replace(',','.')\n",
    "    X.append(x)\n",
    "    Y.append(y)\n",
    "\n",
    "A=X[1::]\n",
    "B=Y[1::]\n",
    "\n",
    "a = np.mean([float(a) for a in A])\n",
    "b = np.mean([float(b) for b in B])\n",
    "print(a,b)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import csv\n",
    "import numpy as np\n",
    "\n",
    "#Lecture des donnees\n",
    "f=open('tableau.csv','r')\n",
    "F=csv.reader(f,delimiter=';')\n",
    "X=[]\n",
    "Y=[]\n",
    "for s in F :                 # F est iterable\n",
    "    x=s[0].replace(',','.')  # Remplace la virgule par un .\n",
    "    y=s[1].replace(',','.')\n",
    "    X.append(x)\n",
    "    Y.append(y)\n",
    "\n",
    "A=X[1::]\n",
    "B=Y[1::]\n",
    "\n",
    "a = np.mean([float(a) for a in A])\n",
    "b = np.mean([float(b) for b in B])\n",
    "f.close()\n",
    "\n",
    "#Ecriture des moyennes\n",
    "f=open('tableau.csv','a')\n",
    "F=csv.writer(f,delimiter=';')\n",
    "F.writerow(['moyenne des x',str(a),'moyenne des y',str(b)])\n",
    "f.close()"
   ]
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}