Fichiers_Textes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1><font color='red'>Les fichiers textes en Python</font></h1>\n",
    "\n",
    "\n",
    "<h2><font color='red'>Les chaines de caractères en Python</font></h2>\n",
    "\n",
    "Une chaine de caractère ( objet de type `str`) en Python est définie à l'aide de **guillements**, simples ou doubles, et est affectée à une variable grâce à l'opérateur `=`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "##Vous pouvez exécuter cette cellule IPython avec CTRL+Entree\n",
    "\n",
    "a=\"Je suis une chaine !\"\n",
    "b='Moi aussi !'\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'intérêt est de pouvoir utiliser les guillemets simples dans une chaîne de caractère entourée de guillemets doubles, et réciproquement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a=' Yoda a dit :\"Use the Force,Luke\" !'\n",
    "b=\" Vous êtes sûr que Yoda l'a dit ?\"\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est cependant possible d'utiliser des guillemets simples ( doubles )  dans une chaine de caractère entourée de guillemets simples ( respectivement doubles ), en les prédédant du **caractère d'échappement** `\\`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a=\" Yoda a dit :\\\"Use the Force,Luke\\\" !\"\n",
    "b=' Vous êtes sûr que Yoda l\\'a dit ?'\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testez le code ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(\"Luke !\\nI'm your Father !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est donc possible d'écrire des chaines de caractères sur plusieurs lignes, en utilisant le caractère spécial **retour chariot** `\\n`. Ce caractère est présent dans toutes les tables de correspondance binaire/caractère.\n",
    "\n",
    "Cependant cette chaine est peu lisible, et Python propose d'écrire des chaines multiligne en les encadrant par un triple guillemet `\"\"\"` ou `'''`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(\"\"\"Il y a bien longtemps dans une galaxie lointaine, très lointaine...\n",
    "\n",
    "C'est un temps d'incertitude. De mauvais présages s'emparent de la galaxie\n",
    "avec l'infuence croissante de Premier Ordre, mais une lueur d'espoir apparaît\n",
    "grâce aux force héroïques de la Résistance.\n",
    "\n",
    "Alors qu'ils luttent contre la puissance sombre de l'ennemi , ces héros\n",
    "courageux peuvent encore éveiller l'habileté et la force nécessaires pour\n",
    "forger un nouvel avenir...\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une chaine de caractère est un objet **itérable** en Python, c'est-à-dire que l'on peut parcourir la chaine de caractère, et obtenir un caractère spécial à partir de son indice ( qui commence par 0 !)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "droid='Z6P0'\n",
    "droid[2]=='P'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi accéder à des sous-chaines comme lors des exemples suivants :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(droid[1:3])# la sous-chaine du caractère d'indice 1 inclu au caratère d'indice 3 exclu.\n",
    "print(droid[1:])#la sous-chaine du caractère d'indice 1 inclu jusqu'à la fin.\n",
    "print(droid[:2])#La sous-chaine du début jusqu'au caractère d'indice 2 exclu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi connaître la longueur d'une chaine de caractère grâce à la fonction *built-in* `len()` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(len(droid))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les chaines de caractères supportent aussi l'opérateur d'appartenance `in` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print('bac' in 'Chewbacca')\n",
    "print('Chewie' in 'Chewbacca')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut ainsi parcourir l'intégralité de la chaine grâce à une boucle `for` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for letter in droid :\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><font color='red'> Modifier des chaines de caractère</font></h2>\n",
    "\n",
    "Les chaines de caractères sont des objets **immuables** en Python, c'est-àdire qu'il ne peuvent être modifiés directement.\n",
    "Ainsi, il est impossible de remplacer une lettre directement par son index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "droid[0]='Z'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le type de l'erreur est clairement indiqué : `TypeError: 'str' object does not support item assignment`, c'est à dire qu'un objet `str` ne supporte pas l'assignation directe.\n",
    "\n",
    "Voyons comment modifier la chaine de caractère `droid`, en remplaçant la sous-chaine de départ `Z6` par la chaine `C3` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "droid.replace('Z6','C3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant demandons d'imprimer la variable `droid` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(droid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que s'est-il passé réellement ?\n",
    "En fait la **méthode** `replace()` a créé une nouvelle chaine de caractère, à partir de la chaine `Z6PO`. Cependant la variable `droid` fait toujours référence à la chaine `Z6PO`.\n",
    "\n",
    "Pour pouvoir effectivement obtenir la bonne chaine de caractère, il faut donc l'affecter à la variable `droid` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(f\"Avant remplacement : {droid} \")##Un exemple de `f-string`, la chaine {droid} est remplacée par le contenu\n",
    "droid=droid.replace('Z6','C3')#de la variable `droid`\n",
    "print(f\"Après remplacement : {droid}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il existe de nombreuses méthodes permettant de travailler avec les chaines de caractères, nous allons en voir quelques unes, mais vous pouvez obtenir l'ensemble des méthodes à la [page dédiée de Python 3](https://docs.python.org/3/library/string.html?highlight=str#module-string).\n",
    "\n",
    "Les chaines de caractères sont sensibles à la **casse**, c'est-à-dire aux majuscules et aux minuscules. La chaine `\"toto\"` est différente de la chaine `\"TOTO\"`. Il existe des méthodes permettant de passer de l'une à l'autre, et d'effectuer d'autres changements. Par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "chaine=\"Use the Force, Luke !\"\n",
    "print(chaine)\n",
    "print(chaine.upper())\n",
    "print(chaine.lower())\n",
    "print(chaine.capitalize())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ensuite nous pouvons **concaténer**, c'est-à-dire ajouter des chaines de caractères.\n",
    "Nous utiliserons la méthode `join()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "droides= \" \".join([\"C3P0\",\"R2D2\",\"BB8\"])\n",
    "print(droides)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On voit ici que la **liste** ( car entourées de crochets `[]` ) des trois chaines est **concaténée** en une seule, avec comme séparateur un espace `\" \"`. Vous pouvez tester la ligne ci-dessus avec d'autres séparateurs.\n",
    "\n",
    "Il est aussi possible de séparer la chaine à partir d'un caractère quelconque, ou d'une chaine de caractère, grâce à la méthode `split()` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(droides.split(\" \"))\n",
    "print(droides.split(\"2\"))\n",
    "print(droides.split(\"R2D2\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarquez que les espaces sont conservés dans les chaines des listes n°2 et 3.\n",
    "\n",
    "Lorsqu'on souhaite supprimer un caractère, ou une chaine de caractère, on utilise la méthode `replace()`, en donnant comme deuxième argument une chaine vide :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(droides.replace(\"R2\",\"\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enfin, il est possible de connaître l'**index** d'un caractère ou d'une chaine, ou du moins l'index de la première occurence du caractère, à l'aide de la méthode `find()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "copilote='Chewbacca'\n",
    "print(copilote.find('a'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette méthode admet un deuxième argument, qui est l'index de la position de départ de la recherche. Ainsi, en prenant en compte le résultat précédent :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(copilote.find('a',6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant, vous en savez suffisamment pour passer à la manipulation des fichiers textes !\n",
    "\n",
    "\n",
    "<h2><font color='red'>Manipuler des fichiers textes</font></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, tout est objet, et les fichiers ne font pas exception.\n",
    "Un fichier sera donc considéré comme un objet sur lequel nous effectuerons des modifications. Python se chargera seul des gestions spécifiques liées au système d'exploitation. Il suffira de demander l'ouverture du fichier avec la structure suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open('fichier_essai.txt','r',encoding='utf8') as file :\n",
    "    pass ## pass signifie juste \"ne rien faire\" !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bon, d'accord, il y a une erreur...  Mais prenons le temps de l'analyser.\n",
    "\n",
    "Python nous informe qu'il n'y a pas de fichier nommé `fichier_essai.txt` dans le dossier courant ( i.e. celui dans lequel sont les notebooks ).\n",
    "\n",
    "Recommençons avec le code suivant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open('fichier_essai.txt','w',encoding='utf8') as file :\n",
    "    pass ## pass signifie juste \"ne rien faire\" !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'exécution renvoie-t-elle une erreur ?\n",
    "Et bien non ! Car ici, le fichier a été ouvert en **mode d'écriture** avec l'argument `'w'` pour *write*, c'est-à-dire qu'on a ouvert un fichier pour écrire à l'intérieur. Dans ce cas Python a deux possibilités :\n",
    "* soit le fichier existe, et à ce moment Python l'ouvre et **le vide**.\n",
    "* soit le fichier n'existe pas, et Python le crée et l'ouvre.\n",
    "Vous devriez d'ailleurs trouver ce fichier dans le répertoire courant par l'explorateur de fichier.\n",
    "\n",
    "Le paramètre `encoding='utf8'` est nécessaire pour vérifier que le fichier a bien été ouvert avec l'encodage en norem internationale.\n",
    "\n",
    "Dans la cellule précédente, le fichier avait été demandé en **mode lecture**, avec l'argument `'r'` pour *read*. Or le fichier n'existait pas, ce qui a déclenché une erreur.\n",
    "\n",
    "Ouvrons donc en lecture un fichier présent dans le répertoire de travail, à savoir le fichier `Code_Jedi.txt`, et lisons son contenu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "##Cette cellule sert à remettre à zéro le fichier Il faut donc l'éxécuter maintenant\n",
    "with open(\"Code_Jedi.txt\",\"w\",encoding=\"utf8\") as file :\n",
    "    file.write(\"\"\"Les Jedi sont les gardiens de la paix dans la galaxie.\n",
    "Les Jedi utilisent leurs pouvoirs pour défendre et protéger.\n",
    "Les Jedi respectent la vie, en toutes ses formes.\n",
    "Les Jedi servent autrui plutôt que les dominer, pour le bien de la galaxie.\n",
    "Les Jedi cherchent à s'améliorer à travers le savoir et l'instruction.\"\"\")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open('Code_Jedi.txt','r',encoding='utf8') as file :\n",
    "    for line in file :\n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On obtient bien le contenu du fichier, mais si vous ouvrez dans un éditeur de texte quelconque le fichier `Code_Jedi.txt`, vous constaterez que des lignes blanches supplémentaires sont apparues.\n",
    "\n",
    "En fait le contenu du fichier, présent dans la variable `file`, est un itérable, qui contient chaque ligne, sous la forme d'une chaine de caractère,  **y compris le caractère de retour charriot `\\n`**. Celui-ci insère donc un saut de ligne supplémentaire à la fin de l'instruction print.\n",
    "Il faut donc le supprimer, en utilisant la méthode `replace()` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open('Code_Jedi.txt','r',encoding='utf8') as file :\n",
    "    for line in file :\n",
    "        print(line.replace(\"\\n\",\"\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voilà qui est mieux...\n",
    "\n",
    "Cependant, ce code Jedi n'est pas le code originel, nous souhaiterions donc le remplacer par celui-ci. Voici comment faire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "code_originel=\"\"\"Il n'y a pas d'émotion, il y a la paix.\n",
    "Il n'y a pas d'ignorance, il y a la connaissance.\n",
    "Il n'y a pas de passion, il y a la sérénité.\n",
    "Il n'y a pas de chaos, il y a l'harmonie.\n",
    "Il n'y a pas de mort, il y a la Force.\"\"\"\n",
    "\n",
    "with open('Code_Jedi.txt','w',encoding='utf8') as file:\n",
    "    file.write(code_originel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En exécutant la cellule précédente afin d'afficher le contenu du nouveau code, on constate que le texte a bien été remplacé.\n",
    "\n",
    "Mais comment faire alors pour simplement **ajouter** du texte a un fichier déjà complété ?\n",
    "Il suffit d'ouvrir le fichier en **mode append**, avec l'argument `'a'` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "code_skywalker=\"\"\"\\nLes Jedi sont les gardiens de la paix dans la galaxie.\n",
    "Les Jedi utilisent leurs pouvoirs pour défendre et protéger.\n",
    "Les Jedi respectent la vie, en toutes ses formes.\n",
    "Les Jedi servent autrui plutôt que les dominer, pour le bien de la galaxie.\n",
    "Les Jedi cherchent à s'améliorer à travers le savoir et l'instruction.\"\"\"\n",
    "\n",
    "#Attention au \\n en début de chaine pour sauter une ligne !\n",
    "with open('Code_Jedi.txt','a',encoding='utf8') as file :\n",
    "    file.write(code_skywalker)\n",
    "    \n",
    "##le fichier étant fermé, lisons de nouveau son contenu :\n",
    "with open('Code_Jedi.txt','r',encoding='utf8') as file :\n",
    "    for line in file :\n",
    "        print(line.replace(\"\\n\",\"\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4><font color='blue'> Exercice n°1</font></h4>\n",
    "\n",
    "A partir de la variable `code_skywalker`, et sans la modifier, créer une variable `code_sith` telle que :\n",
    "\n",
    "1. Le mot \"Jedi\" est remplacé par le mot \"Sith\".\n",
    "2. Les négations \"ne\" et \"pas\" sont ajoutées aux bonnes positions, sauf pour la ligne 2 où \"pour défendre et protéger\" est supprimé.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "##Votre code Ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4><font color='blue'> Exercice n°2</font></h4>\n",
    "\n",
    "Créer un fichier `Code_Sith.txt` dans le répertoire courant, contenant le contenu de la variable `code_sith`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "##Votre code ici"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}