Chapitre 1 et 2 - Exercices - Correction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chapitre 1 et 2 : Exercices supplémentaires\n",
    "==="
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ces exercices vous permettront de mettre en pratique les connaissances accumulées pendant les chapitres 1 et 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 1\n",
    "\n",
    "Écrivez une fonction qui, en fonction d'un chemin de fichier qui contient un poème, numérotera les lignes du poèmes suivi d'une tabulation (marquée par \"\\t\") et retournera cette nouvelle version du texte.\n",
    "\n",
    "Les lignes vides ne seront pas numérotées.\n",
    "\n",
    "**Aide** : \n",
    "- `.split()` peut prendre un argument correspondant à la valeur sur laquelle découper un texte. `.split('\\n')` découpera un texte sur les nouvelles lignes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def numeroter_poeme(chemin_de_fichier):\n",
    "    \"\"\" Numérote un poème\n",
    "    \n",
    "    :param chemin_de_fichier: Chemin du fichier texte contenant le poème\n",
    "    :type chemin_de_fichier: str\n",
    "    :returns: Liste de vers où le numéro de ligne est indiqué \n",
    "              à gauche avant une tabulation \n",
    "    :rtype: list\n",
    "    \"\"\"\n",
    "    # On ouvre le fichier et on stocke son \"lecteur\" dans fichier_ouvert\n",
    "    with open(chemin_de_fichier) as fichier_ouvert:\n",
    "        # On lit le fichier et on stocke sa valeur dans texte\n",
    "        texte = fichier_ouvert.read()\n",
    "    # On crée une variable d'index qui nous servira à compter les lignes\n",
    "    numero_vers = 1\n",
    "    # On crée une variable qui nous permet de stocker les vers dans une liste\n",
    "    poeme = []\n",
    "    # on boucle sur les lignes découpées d'après .split(\"\\n\")\n",
    "    for line in texte.split(\"\\n\"):\n",
    "        # Line est désormais équivalent à une des lignes du fichier original\n",
    "        # pour vérifier, vous pouvez décommentez la ligne suivante\n",
    "        # print(line) \n",
    "        \n",
    "        # Il est possible qu'une ligne soit vide.\n",
    "        # Une ligne vide est ne vaut pas True (boolean(\"\") = False )\n",
    "        # On peut donc faire un if \n",
    "        if line:\n",
    "            # Pour concaténer un nombre à une chaîne, on doit le typer/caser.\n",
    "            # On utiliser donc str()\n",
    "            poeme.append(str(numero_vers)+\"\\t\"+line)\n",
    "\n",
    "            # On incrémente (augmente de 1) notre numéro de vers pour qu'au prochain vers\n",
    "            # le numéro corresponde à la bonne ligne\n",
    "            numero_vers += 1\n",
    "    \n",
    "    # Une fois la boucle finie (et donc hors de l'indentation de la boucle)\n",
    "    # on s'assure de retourner la valeur\n",
    "    return poeme\n",
    "\n",
    "# Code pour tester le résultat\n",
    "poeme = numeroter_poeme(\"data/lanuitdelamort.michel.txt\")\n",
    "\n",
    "# Pour débugguer\n",
    "print(poeme)\n",
    "# Pour tester\n",
    "assert \"5\\tJamais, jamais le dernier jour\" in poeme\n",
    "assert \"13\\tElle monte et les couvrira.\" in poeme"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 2\n",
    "\n",
    "A partir du travail effectué en exercice 1, créer une fonction qui renvoie une liste de vers annotés en tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def numeroter_poeme(chemin_de_fichier):\n",
    "    \"\"\" Numérote un poème\n",
    "    \n",
    "    :param chemin_de_fichier: Chemin du fichier texte contenant le poème\n",
    "    :type chemin_de_fichier: str\n",
    "    :returns: Liste de vers où le numéro de ligne est indiqué \n",
    "              à gauche avant une tabulation \n",
    "    :rtype: list\n",
    "    \"\"\"\n",
    "    # On ouvre le fichier et on stocke son \"lecteur\" dans fichier_ouvert\n",
    "    with open(chemin_de_fichier) as fichier_ouvert:\n",
    "        # On lit le fichier et on stocke sa valeur dans texte\n",
    "        texte = fichier_ouvert.read()\n",
    "    # On crée une variable d'index qui nous servira à compter les lignes\n",
    "    numero_vers = 1\n",
    "    # On crée une variable qui nous permet de stocker les vers dans une liste\n",
    "    poeme = []\n",
    "    # on boucle sur les lignes découpées d'après .split(\"\\n\")\n",
    "    for line in texte.split(\"\\n\"):\n",
    "        # Line est désormais équivalent à une des lignes du fichier original\n",
    "        # pour vérifier, vous pouvez décommentez la ligne suivante\n",
    "        # print(line) \n",
    "        \n",
    "        # Il est possible qu'une ligne soit vide.\n",
    "        # Une ligne vide est ne vaut pas True (boolean(\"\") = False )\n",
    "        # On peut donc faire un if \n",
    "        if line:\n",
    "            # Pour écrire un tuple, on met entre parenthèse et on joint \n",
    "            # par des virgules\n",
    "            poeme.append((numero_vers, line))\n",
    "\n",
    "            # On incrémente (augmente de 1) notre numéro de vers pour qu'au prochain vers\n",
    "            # le numéro corresponde à la bonne ligne\n",
    "            numero_vers += 1\n",
    "    \n",
    "    # Une fois la boucle finie (et donc hors de l'indentation de la boucle)\n",
    "    # on s'assure de retourner la valeur\n",
    "    return poeme\n",
    "\n",
    "# Code pour tester le résultat\n",
    "poeme = numeroter_poeme(\"data/lanuitdelamort.michel.txt\")\n",
    "\n",
    "# Pour débugguer\n",
    "print(poeme)\n",
    "\n",
    "# Pour tester\n",
    "assert (5, \"Jamais, jamais le dernier jour\") == poeme[4]\n",
    "assert (13, \"Elle monte et les couvrira.\") == poeme[12]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 2 bis (Bonus)\n",
    "\n",
    "*Cet exercice nécessitant la réussite du précédent, il est conseillé de passer à l'exercice 3 avant de le commencer*.\n",
    "\n",
    "Dans cet exercice, on traitera à la fois les vers et les strophes. Pour faire ceci, la fonction `numeroter_poeme_avec_strophe` devra prendre en compte que deux sauts de ligne (ou une ligne vide) équivaut à un changement de strophe.\n",
    "\n",
    "La valeur de retour de la fonction sera une liste de listes correspondant aux strophes de tuples correspondant aux vers avec numéros. Exemple :\n",
    "\n",
    "```python\n",
    "[[(1, 'Mon doulz ami, vueilliez moy pardonner,'),\n",
    "  (2, 'Se je ne puis, si tost com je vouldroye,'),\n",
    "  (3, 'Parler a vous, car ainçois ordener'),\n",
    "  (4, 'Me fault comment sera, ne par quel voye.'),\n",
    "  (5, 'Car mesdisans me vont gaitant'),\n",
    "  (6, 'Qui du meschief et du mal me font tant,'),\n",
    "  (7, 'Que je ne puis joye ne bien avoir,'),\n",
    "  (8, 'Pour le desir que j’ay de vous veoir.')],\n",
    " [(9, 'Si pry a Dieu qu’il leur vueille donner'),\n",
    "  (10, 'La mort briefment ; car leur vie m’anoye,'),\n",
    "  (11, 'Pour ce qu’en dueil me font mes jours finer'),\n",
    "  (12, 'Sanz vous veoir, ou est toute ma joye'),\n",
    "  (13, 'Car ilz se vont entremettant'),\n",
    "  (14, 'De moy gaitier nuit et jour, mais pourtant'),\n",
    "  (15, 'Ne vous oubli, ce pouez vous savoir,'),\n",
    "  (16, 'Pour le desir que j’ay de vous veoir.')],\n",
    " [(17, 'Mais ne sçaront ja eulx si fort pener,'),\n",
    "  (18, 'Que, maugré tous, bien briefment ne vous voie.'),\n",
    "  (19, 'Car tant feray, se g’y puis assener,'),\n",
    "  (20, 'Que vous verray, quoy qu’avenir m’en doye,'),\n",
    "  (21, 'Et vous feray savoir quant.'),\n",
    "  (22, 'Mon doulz ami, deportez vous atant.'),\n",
    "  (23, 'Car g’y mettray peine, sachiez de voir,'),\n",
    "  (24, 'Pour le desir que j’ay de vous veoir.')]]\n",
    "```\n",
    "\n",
    "**Aide** \n",
    "- une ligne vide est équivalent à `False` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cet exercice est une variante un peu plus complexe des exercices précédents\n",
    "# Il s'agira de faire des sous listes contenant des strophes.\n",
    "# Les strophes sont indiquées par une/des ligne(s) vide(s) séparant des lignes pleines\n",
    "# Il faudra donc, lors d'un changement de ligne, changer potentiellement de sous-liste\n",
    "def numeroter_poeme_avec_strophe(chemin):\n",
    "    \"\"\" Numérote un poème avec des sous-listes représentant les strophes\n",
    "    \n",
    "    :param chemin: Chemin du fichier texte contenant le poème\n",
    "    :type chemin: str\n",
    "    :returns: Liste de vers où le numéro de ligne est indiqué \n",
    "              à gauche avant une tabulation \n",
    "    :rtype: list\n",
    "    \"\"\"\n",
    "    # On ouvre le fichier et on stocke son \"lecteur\" dans fichier_ouvert\n",
    "    with open(chemin) as fichier_ouvert:\n",
    "        # On lit le fichier et on stocke sa valeur dans texte\n",
    "        texte = fichier_ouvert.read()\n",
    "    # On crée une variable d'index qui nous servira à compter les lignes\n",
    "    numero_vers = 1\n",
    "    # On crée une variable qui nous permet de stocker les vers dans une liste\n",
    "    # Puisque nous commencerons par une ligne pleine\n",
    "    # Nous créons directement la strophe \n",
    "    # Les premiers crochets (poeme = [  ]) représentent le poème\n",
    "    # les deuxièmes ( poeme =  [] ) représentent la strophe\n",
    "    poeme = [[]]\n",
    "    \n",
    "    # on boucle sur les lignes découpées d'après .split(\"\\n\")\n",
    "    for line in texte.split(\"\\n\"):\n",
    "        # Line est désormais équivalent à une des lignes du fichier original\n",
    "        # pour vérifier, vous pouvez décommentez la ligne suivante\n",
    "        # print(line) \n",
    "        \n",
    "        # Il est possible qu'une ligne soit vide.\n",
    "        # Une ligne vide est ne vaut pas True (boolean(\"\") = False )\n",
    "        # On peut donc faire un if \n",
    "        if line:\n",
    "            # Pour écrire un tuple, on met entre parenthèse et on joint par des virgules\n",
    "            # On ajoute ce poème à la dernière strophe ouverte\n",
    "            # Notre poème étant une liste faite de sous-listes représentant les strophes,\n",
    "            # on accède à la dernière strophe/liste via poeme[-1]\n",
    "            poeme[-1].append((numero_vers, line))\n",
    "\n",
    "            # On incrémente (augmente de 1) notre numéro de vers pour qu'au prochain vers\n",
    "            # le numéro corresponde à la bonne ligne\n",
    "            numero_vers += 1\n",
    "            \n",
    "        # Si on a pas de ligne pleine, on est entre deux strophes\n",
    "        # C'est à ce moment là qu'il va falloir créer une nouvelle strophe en prévision\n",
    "        # de la prochaine ligne pleine.\n",
    "        else:\n",
    "            # Il est imaginable que pour la clarté du texte, on ait deux lignes vides\n",
    "            # Dans ce cas, on va vérifier que notre dernière strophe a bien été remplie\n",
    "            # Avant de créer une autre ligne vide\n",
    "            if len(poeme[-1]):\n",
    "                # Pour créer une nouvelle strophe,\n",
    "                # On ajoute une liste au poeme\n",
    "                poeme.append([])\n",
    "    \n",
    "    # Une fois la boucle finie (et donc hors de l'indentation de la boucle)\n",
    "    # on s'assure de retourner la valeur\n",
    "    return poeme\n",
    "        \n",
    "poeme = numeroter_poeme_avec_strophe(\"data/Ballade.XXVIII.dePisan.txt\")\n",
    "\n",
    "# On débuggue\n",
    "print(poeme)\n",
    "\n",
    "# On vérifie\n",
    "assert poeme[0] == [(1, 'Mon doulz ami, vueilliez moy pardonner,'),\n",
    "  (2, 'Se je ne puis, si tost com je vouldroye,'),\n",
    "  (3, 'Parler a vous, car ainçois ordener'),\n",
    "  (4, 'Me fault comment sera, ne par quel voye.'),\n",
    "  (5, 'Car mesdisans me vont gaitant'),\n",
    "  (6, 'Qui du meschief et du mal me font tant,'),\n",
    "  (7, 'Que je ne puis joye ne bien avoir,'),\n",
    "  (8, 'Pour le desir que j’ay de vous veoir.')]\n",
    "assert poeme[-1][0] == (17, 'Mais ne sçaront ja eulx si fort pener,')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 3\n",
    "\n",
    "*Avant de lire la consigne, ouvrez [data/debat.folieamour.labbe.txt](data/debat.folieamour.labbe.txt)*\n",
    "\n",
    "**Aide** :\n",
    "- On peut vérifier qu'une ligne commence par une chaîne de caractère en utilisant `.startswith(chaine)` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Pour le desir que j’ay de vous veoir.\".startswith(\"Pour\"))\n",
    "print(\"Pour le desir que j’ay de vous veoir.\".startswith(\"POUR\"))\n",
    "print(\"Pour le desir que j’ay de vous veoir.\".startswith(\"le desir\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le fichier data/debat.folieamour.labbe.txt contient un dialogue entre Folie et Amour écrit par Louise Labbé. Vous produirez à partir de ce fichier une liste de réplique et de didascalie de telle sorte que :\n",
    "\n",
    "- les répliques de personnages soient des `tuple` prenant la forme `(index_de_ligne, \"réplique\", nom_de_personnage, texte de la replique)`\n",
    "- les didascalies soient des tuples prenant la forme `(index_de_ligne, \"didascalie\", False, texte de la didascalie)`\n",
    "- les lignes vides soient ignorées"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def debat(chemin):\n",
    "    \"\"\" Numérote un débat en stockant les informations nécessaires\n",
    "    \n",
    "    Les fichiers respectent la forme suivante :\n",
    "    \n",
    "    - Une réplique == Une ligne\n",
    "    - Il peut y avoir des lignes vides entre les répliques\n",
    "    - Une réplique commence par un nom de personnage en Majuscule\n",
    "    - Si il est en minuscule, il s'agit d'une didascalie\n",
    "    \n",
    "    :param chemin: Chemin du fichier texte contenant le débat\n",
    "    :type chemin: str\n",
    "    :returns: Une liste de tuple permettant d'identifier un numéro de ligne, le type de ligne, \n",
    "    le nom de l'intervenant le cas échéant et enfin le texte de la ligne défait de ses métadonnées.\n",
    "    :rtype: list\n",
    "    \"\"\"\n",
    "    # On ouvre le fichier et on stocke son \"lecteur\" dans fichier_ouvert\n",
    "    with open(chemin) as fichier_ouvert:\n",
    "        # On lit le fichier et on stocke sa valeur dans texte\n",
    "        texte = fichier_ouvert.read()\n",
    "        \n",
    "    # On crée une variable d'index qui nous servira à compter les lignes\n",
    "    num_ligne = 1\n",
    "    # On crée une variable qui nous permet de stocker les lignes dans une liste\n",
    "    texte_parse = []\n",
    "    \n",
    "    # on boucle sur les lignes découpées d'après .split(\"\\n\")\n",
    "    for line in texte.split(\"\\n\"):\n",
    "        # Line est désormais équivalent à une des lignes du fichier original\n",
    "        # pour vérifier, vous pouvez décommentez la ligne suivante\n",
    "        # print(line) \n",
    "        \n",
    "        # Il est possible qu'une ligne soit vide.\n",
    "        # Une ligne vide est ne vaut pas True (boolean(\"\") = False )\n",
    "        # On peut donc faire un if \n",
    "        if line:\n",
    "            # Le premier mot d'une ligne nous informe du type de ligne\n",
    "            # Si il commence par FOLIE. ou AMOUR., la ligne est un dialogue\n",
    "            # Sinon, c'est une didascale\n",
    "            # Note : il y a des façons plus \"intelligentes\" de faire cette partie,\n",
    "            #        notamment à partir d'expression régulière. Il faudra attendre \n",
    "            #        le dit chapitre pour les voir\n",
    "            if line.startswith(\"FOLIE.\"):\n",
    "                # On va chercher à enlever l'information de personnage de la ligne\n",
    "                # Pour faire cela, on va remplacer l'information\n",
    "                propre = line.replace(\"FOLIE.\", \"\")\n",
    "                # str.strip() permet d'enlever les espaces en début et fin de ligne\n",
    "                # afin de normaliser celle-ci\n",
    "                propre = propre.strip()\n",
    "                texte_parse.append(\n",
    "                    (num_ligne, \"réplique\", \"FOLIE\", line.replace(\"FOLIE.\", \"\").strip())\n",
    "                )\n",
    "            elif line.startswith(\"AMOUR.\"):\n",
    "                # On applique la même logique qur sur le if précédent\n",
    "                # en évitant de créer de nouvelles variables\n",
    "                texte_parse.append(\n",
    "                    (num_ligne, \"réplique\", \"AMOUR\", line.replace(\"AMOUR.\", \"\").strip())\n",
    "                )\n",
    "            else:\n",
    "                # On a une didascalie \n",
    "                # On ajoute simplement la ligne au texte\n",
    "                texte_parse.append(\n",
    "                    (num_ligne, \"didascalie\", False, line)\n",
    "                )\n",
    "                \n",
    "\n",
    "            # On incrémente (augmente de 1) notre numéro de vers pour qu'au prochain vers\n",
    "            # le numéro corresponde à la bonne ligne\n",
    "            num_ligne += 1\n",
    "    \n",
    "    # Une fois la boucle finie (et donc hors de l'indentation de la boucle)\n",
    "    # on s'assure de retourner la valeur\n",
    "    return texte_parse\n",
    "    \n",
    "# Tests\n",
    "resultats = debat(\"data/debat.folieamour.labbe.txt\")\n",
    "assert isinstance(resultats, list) == True, \"Le resultat doit être une liste\"\n",
    "assert resultats[3] == (\n",
    "    4,\n",
    "    \"réplique\",\n",
    "    \"AMOUR\",\n",
    "    \"II n'en ira pas ainsi : car avant que tu m'eschapes, je te donneray à connoitre que tu ne te dois atacher à moy.\"\n",
    ")\n",
    "assert resultats[16] == (\n",
    "    17,\n",
    "    \"didascalie\",\n",
    "    False,\n",
    "    \"Folie se fait invisible, tellement, qu'Amour ne la peut assener.\"\n",
    ")\n",
    "assert resultats[8] == (\n",
    "    9,\n",
    "    \"réplique\",\n",
    "    \"FOLIE\",\n",
    "    \"Tu es Amour, fils de Venus.\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bonus : d'une fonction qui \"parse\" un texte à une fonction qui écrit du xml\n",
    "\n",
    "La fonction `numeroter_poeme_avec_strophe` permet de faire d'un fichier texte un ensemble de fichiers python. Il est encore plus intéressant de voir ce que l'on peut faire avec cela :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pensez à exécuter la cellule qui contient la définition de la fonction numeroter_poeme_avec_strophe\n",
    "poeme = numeroter_poeme_avec_strophe(\"data/Ballade.XXVIII.dePisan.txt\")\n",
    "\n",
    "def poeme_strophe_to_tei(poeme, titre, auteur, chemin_template_tei=\"data/xml/template_tei_exercice.xml\"):\n",
    "    \"\"\" Transforme un poeme sous la forme d'une liste de listes de vers en un texte de TEI\n",
    "    \n",
    "    Le template est un fichier XML où je dois pouvoir trouver les chaînes:\n",
    "    \n",
    "    - $titre$ que je remplacerai par le titre fourni\n",
    "    - $auteur$ que je remplacerai par l'auteur-e fourni-e\n",
    "    - $poeme$ que je remplacerai par le XML de mon poeme\n",
    "    \n",
    "    :param poeme: Contenu du poeme\n",
    "    :type poeme: list\n",
    "    :param titre: Titre du poeme\n",
    "    :type titre: str\n",
    "    :param auteur: Nom de l'auteur\n",
    "    :type auteur: str\n",
    "    :param chemin_template_tei: (Optionnel) Chemin du template\n",
    "    :type chemin_template_tei: str\n",
    "    :returns: Poeme en tei sous la forme d'une chaine de caractères\n",
    "    :rtype: str\n",
    "    \"\"\"\n",
    "    # Je vais utiliser les guillemets simples afin de ne pas avoir à échapper constamment\n",
    "    # les guillemets doubles\n",
    "    # J'ouvre une div poeme (je finis ma ligne par un saut de ligne)\n",
    "    tei_poeme = '<div type=\"textpart\" subtype=\"poeme\">\\n'\n",
    "    \n",
    "    # Je vais boucler sur mes strophes\n",
    "    for strophe in poeme:\n",
    "        # A ma première itération, strophe est égal à poeme[0]\n",
    "        # A ma deuxième, strophe est égal à poeme[1]\n",
    "        # etc. jusqu'à ce qu'il n'y ait plus d'élément dans poeme\n",
    "        \n",
    "        # Une strophe est marquée par un <lg> en TEI\n",
    "        # Je concatène ma chaine représentant du XML à ma chaine précédente\n",
    "        tei_poeme += \"<lg>\\n\"\n",
    "        \n",
    "        # Mes vers font partie de ma strophe sous la forme d'une liste\n",
    "        # Ces vers sont des tuples : je peux les dézipper/unziper/unpacker\n",
    "        # Pour ce faire, je sépare directement ma variable-tuple en deux variable\n",
    "        for numero_vers, vers in strophe:\n",
    "            # C'est équivalent à :\n",
    "            # for tuple_de_vers in strophe:\n",
    "            #     numero_vers = tuple_de_vers[0]\n",
    "            #     vers = tuple_de_vers[1]\n",
    "            \n",
    "            # Ici j'écris mon vers dans la tei de mon poème\n",
    "            # Mon vers est constitué de <l> avec un attribut n et du texte\n",
    "            # Le numero de vers étant un nombre, je dois le caster\n",
    "            tei_poeme += '<l n=\"'+str(numero_vers)+'\">'+vers+'</l>\\n'\n",
    "        \n",
    "        # Je ferme ma strophe et sautre une ligne\n",
    "        tei_poeme += \"</lg>\\n\"\n",
    "        \n",
    "    # Je ferme enfin mon poeme\n",
    "    tei_poeme += \"</div>\\n\"\n",
    "    \n",
    "    # Je lis mon template et je stock son lecteur dans lecteur_template\n",
    "    with open(chemin_template_tei) as lecteur_template:\n",
    "        # Je lis et je stocke le contenu du template dans la variable xml_final\n",
    "        xml_final = lecteur_template.read()\n",
    "        \n",
    "    # Je remplace le titre\n",
    "    xml_final = xml_final.replace(\"$titre$\", titre)\n",
    "    \n",
    "    # Je remplace l'auteur\n",
    "    xml_final = xml_final.replace(\"$auteur$\", auteur)\n",
    "    \n",
    "    # Je remplace le poeme\n",
    "    xml_final = xml_final.replace(\"$poeme$\", tei_poeme)\n",
    "    \n",
    "    # Je retourne le xml_final\n",
    "    return xml_final\n",
    "\n",
    "tei = poeme_strophe_to_tei(poeme, \"Ballade XXVIII\", \"Christine de Pisan\")\n",
    "\n",
    "# Et on affiche le résultat\n",
    "print(tei)\n",
    "# (On aurait pu aussi l'enregistrer après l'avoir afficher...)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}