Notebook 3 - correction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center>Initiation à la programmation (Python)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fichiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est possible de lire des fichiers (texte) en Python. Pour cela, il faut commencer par l'ouvrir :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "fichier = open('haiku.txt', encoding='utf8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Un vieil étang et\\nUne grenouille qui plonge,\\nLe bruit de l'eau.\\n\""
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fichier.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En python, les fichiers sont itérables : avec une boucle `for`, on peut les lire ligne par ligne :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18 caractères : Un vieil étang et\n",
      "\n",
      "27 caractères : Une grenouille qui plonge,\n",
      "\n",
      "19 caractères : Le bruit de l'eau.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "fichier = open('haiku.txt', encoding='utf8')\n",
    "for ligne in fichier:\n",
    "    print(str(len(ligne)) + ' caractères : ' + ligne)\n",
    "fichier.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 1\n",
    "Nous voulons mémoriser le nombre d'étudiants par étage dans un fichier. La première ligne indique le nombre d'étudiants au rez-de-chaussée, la seconde au premier étage... Le fichier `bibliothèque.txt` décrit de cette manière une bibliothèque de 10 étages. \n",
    "\n",
    "Ecrire un programme qui lit un fichier et construit une liste dans laquelle chaque élément correspond à l'occupation d'un étage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 7, 2, 5, 8, 5, 1, 0, 5, 4]\n"
     ]
    }
   ],
   "source": [
    "nbEtudiantsParEtage=[]\n",
    "fichier=open('bibliothèque.txt', encoding='utf8')\n",
    "for l in fichier:\n",
    "    nbEtudiantsParEtage.append(int(l))\n",
    "print(nbEtudiantsParEtage)\n",
    "fichier.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 2\n",
    "On veut faire l'opération inverse, écrire dans un fichier une liste qui donne l'occupation étage par étage d'une bibliothèque. On peut écrire dans un fichier de cette manière :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "fichier = open('fichier.txt', 'w', encoding='utf8') #le paramètre 'w' indique que l'on ouvre le fichier en mode éciture  (write)\n",
    "fichier.write('un peu de texte')\n",
    "fichier.write('encore un peu de texte\\n')#si l'on veut revenir à ligne, il faut écrire le caractère retour à la ligne, qui s'écrit \\n\n",
    "fichier.write(\"et l'on termine\")\n",
    "fichier.close()#il faut explicitement fermer le fichier, sinon on est pas sûr que ce que l'on a écrit est bien enregistré"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "fichier = open('bibliothèque2.txt', 'w', encoding='utf8')\n",
    "for étage in nbEtudiantsParEtage:\n",
    "    fichier.write(str(étage)+'\\n')\n",
    "fichier.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionnaires"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les listes permettent de manipuler ensemble des valeurs indexées par des nombres entiers :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-11-27T12:29:43.163251Z",
     "start_time": "2017-11-27T12:29:43.157241Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Marseille\n"
     ]
    }
   ],
   "source": [
    "villes=['Paris', 'Lyon', 'Marseille', 'Toulouse', 'Bordeaux', 'Lille', 'Nice']\n",
    "print(villes[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les **dictionnaires** étendent cette idée en permettant d'indexer avec d'autres types que les entiers :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-11-27T12:29:43.496572Z",
     "start_time": "2017-11-27T12:29:43.485589Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2265375\n"
     ]
    }
   ],
   "source": [
    "population={'Bordeaux' :1196122, 'Lyon' :2265375, 'Lille' :1182127, 'Marseille' :1743990, 'Paris' :2475808, 'Toulouse' :1312304, 'Nice' :1006289}\n",
    "print(population['Lyon'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un dictionnaire associe des **clés** à des **valeurs**. 2265375 est a valeur associée à la clé 'Lyon'\n",
    "\n",
    "Alors que les listes sont délimitées par des crochets `[]`, les dictionnaires sont délimités par des accolades `{}`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comme pour les listes, on peut modifier une valeur en l'indexant avec la clé correspondante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-11-27T12:29:44.198136Z",
     "start_time": "2017-11-27T12:29:44.191758Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2475808\n",
      "12475808\n"
     ]
    }
   ],
   "source": [
    "print(population['Paris'])\n",
    "population['Paris']=12475808\n",
    "print(population['Paris'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De la même manière, on peut ajouter des élements à un dictionnaire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-11-27T12:30:15.816370Z",
     "start_time": "2017-11-27T12:30:15.813279Z"
    }
   },
   "outputs": [],
   "source": [
    "population['Nantes']=934165"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 3\n",
    "Monsieur Jean Dupont habite au 1 chemin de la liberté, 69001 Lyon. Son numéro de téléphone est le 01 02 03 04 05. Construisez un dictionnaire le représentant. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Nom': 'Dupont',\n",
       " 'Prénom': 'Jean',\n",
       " 'Adresse': '1 chemin de la liberté',\n",
       " 'Code postal': '69001',\n",
       " 'Ville': 'Lyon',\n",
       " 'Téléphone': '01 02 03 04 05'}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{'Nom': 'Dupont',  'Prénom': 'Jean',  'Adresse': '1 chemin de la liberté',  'Code postal': '69001',  'Ville': 'Lyon', 'Téléphone': '01 02 03 04 05'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 4\n",
    "Cette fois-ci, construisez le dictionnaire en allant récupérer les informations dans le fichier JeanDupont.txt\n",
    "\n",
    "*Rappel* : pour lire un fichier, on peut s'y prendre de la manière suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-11-27T14:35:23.580431Z",
     "start_time": "2017-11-27T14:35:23.574289Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nom:Dupont\n",
      "\n",
      "Prénom:Jean\n",
      "\n",
      "Adresse:1 chemin de la liberté\n",
      "\n",
      "Code postal:69001\n",
      "\n",
      "Ville:Lyon\n",
      "\n",
      "Téléphone:01 02 03 04 05\n"
     ]
    }
   ],
   "source": [
    "fichier=open('JeanDupont.txt', encoding='utf8')\n",
    "for ligne in fichier:\n",
    "    print(ligne)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Indice* : regardez le résultat de l'instrution suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Paris', 'Lyon', 'Marseille']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Paris,Lyon,Marseille'.split(',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Nom': 'Dupont',\n",
       " 'Prénom': 'Jean',\n",
       " 'Adresse': '1 chemin de la liberté',\n",
       " 'Code postal': '69001',\n",
       " 'Ville': 'Lyon',\n",
       " 'Téléphone': '01 02 03 04 05'}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fichier=open('JeanDupont.txt', encoding='utf8')\n",
    "d={}\n",
    "for ligne in fichier:\n",
    "    ligne=ligne.strip() #on enlève le caractère retour à la ligne qui est à la fin de la ligne\n",
    "    ligneDécoupée=ligne.split(':')\n",
    "    clé=ligneDécoupée[0]\n",
    "    valeur=ligneDécoupée[1] \n",
    "    #on peut écrire la même chose de manière condensée:\n",
    "    # clé,valeur=ligne.split(':')\n",
    "    d[clé]=valeur\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-11-27T14:10:17.078738Z",
     "start_time": "2017-11-27T14:10:17.073660Z"
    }
   },
   "source": [
    "## Exercice 5\n",
    "A présent, construisez tout un carnet d'adresse à partir du fichier `carnet.txt`. Ce sera une liste de dictionnaires, chaque dictionnaire représentant une personne. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "nomDuFichier='carnet.txt'\n",
    "carnet=[]#cette liste sera une liste de dictionnaire, un par personne\n",
    "dct={}#ce dictionnaire servira à lire les champs de chaque personne \n",
    "fichier=open(nomDuFichier, encoding='utf8')\n",
    "for l in fichier:#On parcourt successivement toutes les lignes du fichier\n",
    "    if l!='\\n':#Si la ligne n'est pas une ligne vide, on est encore en train de lire les champs d'une personne\n",
    "        clé,valeur = l.strip().split(':') #On extrait la clé et la valeur de la ligne\n",
    "        dct[clé]=valeur#on complète le dictionnaire\n",
    "    else: #Sinon, la ligne ne comprend qu'un retour à la ligne, c'est donc que l'on vient de lire l'ensemble des champs représentant une personne\n",
    "        carnet.append(dct)#Le dictionnaire est donc complet, on le rajoute au carnet (à la liste)\n",
    "        dct={}#on continue avec un dictionnaire vide, pour traiter la personne suivante"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 6\n",
    "Ecrire un programme qui affiche le numéro de téléphone d'une personne à partir de son nom de famille."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "01.55.93.62.85\n"
     ]
    }
   ],
   "source": [
    "nom='Boisclair'\n",
    "for personne in carnet :\n",
    "    if personne['Nom']==nom:\n",
    "        print(personne['Téléphone'])\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 7\n",
    "Ecrire un programme construit la liste de tous les noms de famille qui se trouvent dans le carnet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "noms=[]\n",
    "for personne in carnet:\n",
    "    noms.append(personne['Nom'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Marleau',\n",
       " 'Dostie',\n",
       " 'Fournier',\n",
       " 'Duclos',\n",
       " 'Grandpré',\n",
       " 'Louis',\n",
       " 'Paquet',\n",
       " 'Gaulin',\n",
       " 'Doucet',\n",
       " 'Fréchette',\n",
       " 'Cousteau',\n",
       " 'Guernon',\n",
       " 'Lacroix',\n",
       " 'Laforest',\n",
       " 'Labrosse',\n",
       " 'Boisclair',\n",
       " 'Petit',\n",
       " 'Panetier',\n",
       " 'Lépicier',\n",
       " 'Rancourt',\n",
       " 'Garcia',\n",
       " 'Harquin',\n",
       " 'Roussel',\n",
       " 'Dufresne',\n",
       " 'Fortier',\n",
       " 'Champagne',\n",
       " 'Méthot',\n",
       " 'Bonami',\n",
       " 'Daviau',\n",
       " 'Dupéré',\n",
       " 'Brunelle',\n",
       " 'Laforest',\n",
       " 'Faure',\n",
       " 'Tollmache',\n",
       " 'Margand',\n",
       " 'Bériault',\n",
       " 'Brunault',\n",
       " 'Daoust',\n",
       " 'Dostie',\n",
       " 'Lavoie',\n",
       " 'Duffet',\n",
       " 'Brodeur',\n",
       " 'Cliche',\n",
       " 'St-Jean',\n",
       " 'Croteau',\n",
       " 'Poissonnier',\n",
       " 'Varieur',\n",
       " 'Bourgeau',\n",
       " 'Corbeil']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "noms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 8\n",
    "\n",
    "* La fonction `sort` permet de trier une liste :\n",
    "```python\n",
    "lst=['Paris', 'Lyon', 'Marseille']\n",
    "lst.sort()\n",
    "print(lst)\n",
    "```\n",
    "```\n",
    "['Lyon', 'Marseille', 'Paris']\n",
    "```\n",
    "\n",
    "\n",
    "Sachant cela, écrire un programme qui écrit dans le fichier `carnetTrié.txt` le même carnet d'adresse, mais trié par ordre alphabétique "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Boisclair\n",
      "Bonami\n",
      "Bourgeau\n",
      "Brodeur\n",
      "Brunault\n",
      "Brunelle\n",
      "Bériault\n",
      "Champagne\n",
      "Cliche\n",
      "Corbeil\n",
      "Cousteau\n",
      "Croteau\n",
      "Daoust\n",
      "Daviau\n",
      "Dostie\n",
      "Dostie\n",
      "Doucet\n",
      "Duclos\n",
      "Duffet\n",
      "Dufresne\n",
      "Dupéré\n",
      "Faure\n",
      "Fortier\n",
      "Fournier\n",
      "Fréchette\n",
      "Garcia\n",
      "Gaulin\n",
      "Grandpré\n",
      "Guernon\n",
      "Harquin\n",
      "Labrosse\n",
      "Lacroix\n",
      "Laforest\n",
      "Laforest\n",
      "Lavoie\n",
      "Louis\n",
      "Lépicier\n",
      "Margand\n",
      "Marleau\n",
      "Méthot\n",
      "Panetier\n",
      "Paquet\n",
      "Petit\n",
      "Poissonnier\n",
      "Rancourt\n",
      "Roussel\n",
      "St-Jean\n",
      "Tollmache\n",
      "Varieur\n"
     ]
    }
   ],
   "source": [
    "noms.sort()\n",
    "fichier=open('carnetTrié.txt', 'w', encoding='utf8')\n",
    "for nom in noms:\n",
    "    for personne in carnet:\n",
    "        if personne['Nom']==nom:\n",
    "            print(nom)\n",
    "            fichier.write('Nom:'+personne['Nom']+'\\n')\n",
    "            fichier.write('Prénom:'+personne['Prénom']+'\\n')\n",
    "            fichier.write('Adresse:'+personne['Adresse']+'\\n')\n",
    "            fichier.write('Code postal:'+personne['Code postal']+'\\n')\n",
    "            fichier.write('Ville:'+personne['Ville']+'\\n')\n",
    "            fichier.write('Téléphone:'+personne['Téléphone']+'\\n')\n",
    "            fichier.write('\\n')\n",
    "            break\n",
    "fichier.close()"
   ]
  }
 ],
 "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.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}