Chapitre 2 - Les fonctions et les fichiers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapitre 2 - Les fonctions et les fichiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-- *A Python Course for the Humanities by Folgert Karsdorp and Maarten van Gompel*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le chapitre précédent a, espérons-le, aiguisé votre appétit. Dans ce chapitre, nous allons nous concentrer sur l'une des tâches les plus importantes de la recherche en sciences humaines: le traitement du texte. L'un des objectifs du traitement de texte est de nettoyer vos données pour ensuite faire leur analyse. Un autre objectif banal consiste à convertir une collection de textes en un format différent: par exemple de fichiers textes vers fichiers XML TEI. Dans ce chapitre, nous allons vous fournir les outils nécessaires pour travailler avec des collections de textes, les nettoyer et effectuer quelques analyses de données rudimentaires sur eux."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lire des fichiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Supposons que vous ayez un texte stocké sur votre ordinateur. Comment pouvons-nous lire ce texte en utilisant Python? Python fournit une fonction très simple appelée `open` avec laquelle on peut lire des textes. Dans le dossier `data`, vous trouverez quelques petits extraits de texte que nous utiliserons dans ce chapitre. Regardez-les si vous en avez l'envie. Nous pouvons ouvrir ces fichiers avec la commande suivante:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fichier_ouvert = open('data/cid.v1071.1682.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant, affichons la variable `fichier_ouvert`. Que pensez-vous qu'il arrivera ? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(fichier_ouvert)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"Je ne pensais pas que ça ferait ça\" est probablement ce qui vous passe à l'esprit. Python n'affiche pas le contenu du fichier, mais seulement une mention mystérieuse d'un certain `TextIOWrapper`. Ce truc de `TextIOWrapper` est la façon de Python de dire qu'il a ouvert une connexion au fichier `data/cid.v1071.1682.txt`. \n",
    "\n",
    "Mais cela nous donne également des informations auxquelles nous devrions prêter attention. Regardez la partie qui commence `encoding=`. `UTF-8` est le modèle d'encodage des caractères du fichier (vous pouvez en apprendre un peu plus sur la chaîne Computerphile : https://www.youtube.com/watch?v=MijmeoH9LT4 ). Par défaut, Python3 (contrairement à Python 2) gère ses données en UTF-8. On aurait pu cependant faire ce qui suit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "encodage_latin = open('data/cid.v1071.1682.txt', encoding='latin')\n",
    "print(encodage_latin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous avez pour `encodage_latin` `encoding='latin'` dans la description de ce `TextIOWrapper`. Vous devrez vous assurer de toujours spécifier votre encodage comme UTF-8 si vous travaillez avec des textes grecs dans Windows. Cependant, les systèmes Linux et Mac ne devraient pas en avoir besoin.\n",
    "\n",
    "Maintenant, si nous voulons *lire* le contenu du fichier, nous devons ajouter la fonction `read` comme suit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(fichier_ouvert.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`read` est une fonction qui fonctionne sur les objets` TextWrapper` et nous permet de lire le contenu d'un fichier dans Python. Assignons le contenu du fichier à la variable `texte`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ajoutez `encoding='UTF-8'` si nécessaire\n",
    "fichier_ouvert = open('data/cid.v1071.1682.txt') \n",
    "texte = fichier_ouvert.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La variable `texte` contient le contenu du fichier `data/cid.v1071.1682.txt` et nous pouvons le manipuler désormais comme n'importe quelle autre chaîne. Après avoir lu le contenu d'un fichier, le `TextWrapper` n'a plus besoin d'être ouvert. En fait, il est bon de le fermer dès que vous n'en avez plus besoin. Pour ce faire, il suffit d'utiliser la méthode `close()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fichier_ouvert.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Juste pour récapituler certaines des choses que nous avons apprises dans le chapitre précédent. Pouvez-vous écrire un bloc de code qui définit la variable `nombre_de_e` et compte combien de fois la lettre *e* se trouve dans le « texte »? (Astuce: utilisez une boucle `for` et une instruction `if`).\n",
    "\n",
    "Prenez aussi le temps de comprendre `assert` qui nous permet de vérifier vos travaux. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombre_de_e = 0\n",
    "# Votre code ici\n",
    "\n",
    "# Ce code vérifiera ce que vous avez écrit\n",
    "assert nombre_de_e == 180, \"On devrait trouver 180 'e'\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enfin, il existe une autre syntaxe pour gérer un fichier à ouvrir et lire : il s'agit d'utiliser la déclaration `with` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"data/cid.v1071.1682.txt\") as fichier_cid:\n",
    "    texte = fichier_cid.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette méthode a cela de particulier qu'elle ferme d'elle-même le fichier qui a été ouvert. Tout comme un `if`, le with concerne l'ensemble du bloc ouvert en dessous du `with` et permet de faire des opérations sur le fichier. On remarque l'utilisation de `as` : en français, on traduirait cette ligne en `avec le fichier ouvert cid.v1071.1682.txt en tant que variable fichier_cid`.\n",
    "\n",
    "Par ailleurs, les variables modifiées dans cet ensemble sont encore disponibles à la fin. Mais le fichier sera clos. Pouvez-vous deviner ce qui se passera avec les lignes suivantes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(texte)\n",
    "fichier_cid.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`I/O Operation` signifie `Input/Output` et vise les méthodes de lecture et d'écriture de fichiers. Notre fichier ayant été clos après `with`, il n'est plus possible de le lire."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ce que l'on a appris\n",
    "\n",
    "Pour finir cette section, voici un récapitulatif des concepts appris. Lisez la liste et posez des questions si certaines choses ne sont pas claires.\n",
    "\n",
    "- `open()`\n",
    "- `UTF-8`\n",
    "- `.close()`\n",
    "- `.read()`\n",
    "- le fonctionnement de `TextIOWrapper`\n",
    "- `with ___ as ___ :`\n",
    "- `assert ___ , ___`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Écrire notre première fonction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans l'exercice précédent, vous avez probablement écrit une boucle qui itère sur tous les caractères de `texte` et ajoute 1 à` nombre_de_e` chaque fois que le programme trouve la lettre *e*. Le comptage d'objets dans un texte ou dans une liste est chose courante.\n",
    "\n",
    "Par conséquent, Python fournit la méthode `count`. Cette fonction prend comme argument l'élément que vous voulez compter. En utilisant cette fonction, la solution à l'exercice ci-dessus peut maintenant être réécrite comme suit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombre_de_e = texte.count(\"e\")\n",
    "print(nombre_de_e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En fait, `count` prend comme argument toute chaîne que vous aimeriez trouver. Nous pourrions aussi bien compter combien de fois la conjonction `et` se produit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(texte.count(\"et\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La chaîne `et` est trouvée 10 fois dans notre texte. Cela signifie-t-il que le mot *et* apparaît 10 fois dans notre texte? En fait non, *et* n'apparaît que 8 fois ... Pourquoi Python affiche-t-il 10?\n",
    "\n",
    "Si nous voulons compter combien de fois le mot *et* apparaît dans le texte et non la chaîne «et», nous pouvons entourer *et* d'espaces, comme ceci:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(texte.count(\" et \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bien que cela l'affaire dans ce cas particulier, ce n'est pas très fiable pour compter les mots dans un texte. Que faire s'il y a des instances de *et* suivies d'une virgule ou d'un point ? Il nous faudrait alors interroger le texte plusieurs fois pour chaque contexte possible de *et* : `et`, ` et `, `et.`, `et,`, `et:`, etc. C'est pour cela que nous allons aborder ce problème en utilisant une méthode un peu plus sophistiquée.\n",
    "\n",
    "Rappelez-vous, dans le chapitre précédent, nous avons vu la méthode `split`. Que fait cette méthode? La méthode `split` fonctionne sur une chaîne et divise une chaîne sur les espaces et retourne une liste de plus petites chaînes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(texte.split())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tout ce que vous avez appris jusqu'ici devrait vous permettre d'écrire du code qui compte certains éléments apparaissant dans une liste. Écrivez un bloc de code qui définit la variable `nombre_de_resultats` et compte combien de fois le mot *à* (assigné à `a_compter`) apparaît dans la liste de mots appelée `mots`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mots = texte.split()\n",
    "a_compter = \"la\"\n",
    "# Votre code ici\n",
    "\n",
    "# Ce test ne devrait pas lancer d'erreur si tout va bien\n",
    "assert nombre_de_resultats == 3, \"Il devrait y avoir 6 résultats\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons voir cet exercice étape par étape. Nous aimerions savoir à quelle fréquence l'article défini *la* apparaît dans notre texte. Dans un premier temps, nous divisons la chaîne `texte` en une liste de mots:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mots = texte.split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puis on va appeler la méthode `count` sur `mots` afin de trouver le nombre de `la` dans `mots`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_compter = \"la\"\n",
    "nombre_de_resultats = mots.count(a_compter)\n",
    "print(nombre_de_resultats)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bon. Très bien. Mais disons que nous nous intéressons aussi à `une`, pour faire des petites statistiques sur l'usage du défini et de l'indéfini. Il faudrait que l'on adapte les lignes précédentes pour chercher le mot `une`. Mais qu'arriverait-il si ensuite nous voulions aussi compter `l'`, `le`, `un`, etc. ? Cela serait insupportable, et honnêtement, on n’a pas créé les langages de programmation pour que nous ayons à répéter 100 fois la même chose, bien au contraire.\n",
    "\n",
    "Donc ce qu'on aimerait, c'est avoir une fonction qui ferait ça. Et si on regarde bien, notre fonction aurait besoin de deux choses : un texte et un élément à compter. Et elle nous renverrait comme résultat un nombre d'occurrences. Les éléments dont a besoin la fonction sont appelés arguments ou paramètres (`arguments/args` ou `parameters/params`). Le résultat que la fonction nous donne est appelé valeur de retour (`return value`).\n",
    "\n",
    "Dans ce chapitre et le précédent, on a vu pas mal de fonctions. Une fonction fait quelque chose, souvent grâce à des paramètres que vous lui donnez, et généralement elle renvoie un résultat.\n",
    "\n",
    "On a aussi vu des méthodes. Les méthodes se différencient des fonctions dans leur rédaction : du côté des fonctions, on fait `len(chaîne)`, du côté des méthodes, on fait `chaîne.count(\" et \")`. Nous verrons cela plus en détail beaucoup plus tard. Une méthode est une fonction un peu particulière, mais est régie par le même vocabulaire : arguments, paramètres, valeurs de retour.\n",
    "\n",
    "Bien sûr, on peut créer ses propres fonctions. Séparer ta tâche en une multiplicité de tâches est même une obligation en programmation : cela permet de lire les choses plus facilement et d'éviter des répétitions constantes. Les fonctions sont définies avec la déclaration `def` qui est suivie d'un nom de fonction et de paramètres puis du `:` :\n",
    "\n",
    "```python\n",
    "def fonction_avec_parametres(parametre1, parametre2, parametre3):\n",
    "    # Le code de la fonction\n",
    "    \n",
    "def fonction_sans_parametre():\n",
    "    # le code la fonction\n",
    "```\n",
    "\n",
    "Ces fonctions peuvent aussi avoir une valeur de retour. Cela permet d'accéder aux résultats calculés dans la fonction. Cette valeur de retour est renvoyée par la déclaration `return` :\n",
    "\n",
    "```python\n",
    "def carre(x):\n",
    "    return x*x\n",
    "```\n",
    "\n",
    "Retour à notre problème. On veut écrire une fonction appelée `compter_dans_une_chaine`. Elle prend deux paramètres : \n",
    "1. un objet que l'on veut compter\n",
    "2. une chaîne dans laquelle on veut trouver cet élément\n",
    "\n",
    "Elle retournera le nombre d'objets en tant qu'entier :\n",
    "\n",
    "```python\n",
    "def compter_dans_une_autre_chaine(aiguille, botte_de_foin):\n",
    "    # En programmation, on utilise souvent aiguille et botte de foin \n",
    "    # (needle et haystack en anglais)\n",
    "    # pour parler de chose à trouver et d'élément à trouver.\n",
    "    # Ici, ce n'est pas forcément très clair cela dit !\n",
    "```\n",
    "\n",
    "Comprenez-vous la syntaxe et les différentes nouvelles déclarations au-dessus ? Maintenant, tout ce qui nous reste à faire est d'écrire le corps de cette fonction :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compter_dans_une_autre_chaine(aiguille, botte_de_foin): \n",
    "    mots_de_foin = botte_de_foin.split()\n",
    "    nombre_daiguilles = mots_de_foin.count(aiguille)               \n",
    "    return nombre_daiguilles                         "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lisons la chose encore une fois :\n",
    "\n",
    "1. D'abord on définit une fonction en utilisant def suivi du nom de la fonction et de parenthèses et de `:` (ligne 1);\n",
    "2. La fonction prend deux arguments `aiguille` et `botte_de_foin` (ligne 1);\n",
    "3. Dans cette fonction, on définit une variable `mots_de_foin` qui correspond à la chaîne découpée en mots (ligne 2);\n",
    "4. Dans cette fonction, nous définissons ensuite une variable `nombre_daiguilles` et nous lui assignons le résultat de `count()` sur `mots_de_foin` et `aiguille` (ligne 3);\n",
    "5. On retourne la valeur de la variable `nombre_daiguilles` (ligne 4).\n",
    "\n",
    "Testons notre petite fonction! Nous allons compter combien de fois `\"à\"` apparaître dans notre `texte`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(compter_dans_une_autre_chaine(\"à\", texte))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilisez la fonction que nous avons définie et afficher combien de fois le mot `mon` apparaît."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Le concept de scope / portée\n",
    "\n",
    "Vous trouverez souvent dans le cadre de documentation le terme de \"portée\" voire le terme de *\"scope\"*. Ce terme couvre le concept de capacité à accéder à des variables à différents endroits du code. Par exemple, on a défini dans la fonction au-dessus la variable `mots_de_foin`. Et elle fonctionne bien puisque la fonction retourne un résultat. Essayons ça :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(compter_dans_une_autre_chaine(\"ton\", texte))\n",
    "print(mots_de_foin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une erreur familière ! La fonction `mots_de_foin` est dite inexistante. Pourtant, elle a bien existé puisque j'ai eu le résultat `4` au final.\n",
    "\n",
    "En fait, les variables dans les fonctions ont une portée limitée à la fonction. Elle n'existe que dans le cadre de la fonction et n’est pas accessible ensuite. C'est pour cela que l'on utilise la déclaration `return` d'ailleurs, sinon, on ne pourrait pas avoir le résultat !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Un fonction de décompte plus générale"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notre fonction `compter_dans_une_autre_chaine()` est un morceau utile qui va nous permettre de limiter la répétition de notre code et de le rendre trop verbeux. \n",
    "\n",
    "Cela dit, il serait intéressant de savoir combien de fois chaque mot apparaît dans le texte, on pourrait utiliser une boucle, ajouter 1 pour chaque mot, etc. Mais cela serait vraiment long.\n",
    "\n",
    "Il y a deux manières de faire cela rapidement, qui évitent un tel problème :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La version longue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans le chapitre précédent, vous vous êtes familiarisé-e avec la structure `dictionary`. Rappelez-vous qu'un dictionnaire se compose de clés et de valeurs et vous permet de récupérer rapidement une valeur. Nous allons utiliser un dictionnaire pour écrire la fonction `comptage` qui prend comme argument une liste et retourne un` dictionary` avec les mots comme clefs et en valeur le nombre de fois que ces mots sont dans la liste. Nous allons d'abord écrire du code sans la déclaration de fonction. Si cela fonctionne, nous l'écrirons dans une fonction.\n",
    "\n",
    "Nous commençons par définir une variable `decompte` qui est un dictionnaire vide:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "decompte = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ensuite, nous allons boucler tous les mots de notre liste `mots`. Pour chaque mot, nous vérifions si le dictionnaire le contient déjà. Si ce n'est pas le cas, nous appelons la méthode `count` de notre liste `mots` pour découvrir la fréquence d'apparition du mot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for mot in mots:\n",
    "# A chaque élément dans la variable `mots`, j'assigne la valeur dans une variable `mot`\n",
    "    if mot not in decompte:\n",
    "        # Si le mot n'est pas dans les clefs du dictionnaire decompte\n",
    "        decompte[mot] = mots.count(mot)\n",
    "        # Je assigne à la clef mot le nombre de fois que la valeur de `mot`\n",
    "        #    apparaît dans `mots`\n",
    "print(decompte)\n",
    "print(decompte['mon'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "N'hésitez pas à relire le chapitre 1 si nécessaire .\n",
    "\n",
    "Remarquez que l'on n’a rien fait si le mot était déjà dans notre dictionnaire. On n'a pas besoin puisque l'on a déjà fait le décompte !\n",
    "\n",
    "Maintenant que notre code marche, on peut le transformer en fonction ! On définit la fonction `comptage` comme vue plus haut. On a besoin cette fois d'un seul argument :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def comptage(mots):  \n",
    "    decompte = {}\n",
    "    for mot in mots:\n",
    "        if mot not in decompte:\n",
    "            decompte[mot] = mots.count(mot)\n",
    "    return decompte"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Normalement, la répétition qui suit va être ennuyante, mais au cas où :\n",
    "\n",
    "1. On définit une fonction `comptage()` via `def` en lui donnant un paramètre (`mots`)\n",
    "2. Je crée un dictionnaire vide `decompte` qui me servira de réceptacle\n",
    "3. Pour chaque élément dans la valeur `mots`, j'assigne sa valeur dans une variable `mot`\n",
    "    1. Si le mot n'est pas dans les clefs du dictionnaire decompte, alors\n",
    "        1. Je définis la cle du dictionnaire decompte représentée par `mot`\n",
    "        2. J'y assigne comme valeur le nombre de fois qu'il apparaît dans la liste `mots`\n",
    "4. Une fois la boucle finie, je renvoie le résultat de la boucle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(comptage(mots))\n",
    "vocabulaire_cid = comptage(mots)\n",
    "print('\"mon\" apparaît ' + str(vocabulaire_cid['mon']) + ' fois.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essayons de mettre en pratique ce que l'on a vu jusque là. On va lire le fichier `data/misanthrope.acte3.scene4.txt`, le convertir en liste de mot et assigner à la variable `compte_de_mais` le nombre de fois que mais apparaît dans le texte :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code ici\n",
    "\n",
    "# Le test suivant ne devrait pas créer d'erreurs\n",
    "assert compte_de_mais == 4, \"Il y a 4 'mais'\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Le nombre de lignes écrites par vous-mêmes ne devrait pas dépasser les 6 ou 7 lignes*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Une alternative à la fonction de comptage : éviter les doublons avec `set`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le problème de la fonction d'avant, c'est qu'elle passe sur certaines valeurs plusieurs fois et que l'on est obligé de faire un if pour que cela fonctionne correctement. On peut parler de code non optimisé: une tâche est faite un bon nombre de fois sans avoir d'impact et prend du temps que l'on pourrait gagner.\n",
    "\n",
    "Aussi, il serait bon de savoir quelles sont les valeurs uniques de la liste de mots. Pour cela, on utilise le type `set()` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = ['a', 'a', 'b', 'b', 'c', 'c', 'c']\n",
    "unique_x = set(x)\n",
    "y = [1, 1, 4, 3, 1, 2, 2, 4]\n",
    "print(unique_x)\n",
    "print(set(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les sets sont des sortes de liste où les valeurs sont forcément unique. En transformant une liste en set, on supprime les doublons. Attention cependant, un set n'est pas ordonné et ne peut donc pas être accédé par des index :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "unique_x[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cependant, on peut lui ajouter des valeurs. Au lieu d'utiliser `append()` on utilise `add()` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "unique_x.add(\"test\")\n",
    "unique_x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "À partir de cela, on peut faire une fonction plus simple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def comptage2(mots):\n",
    "    sans_doublon = set(mots)\n",
    "    compteur = {}\n",
    "    for mot in sans_doublon:\n",
    "        compteur[mot] = mots.count(mot)\n",
    "        print(mot)\n",
    "    return compteur"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On vérifie que cela marche :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "decompte = comptage2(mots)\n",
    "print(decompte[\"et\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Documenter une fonction : méthode Sphinx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tout comme il est bien de documenter avec des # les lignes de votre code afin de mieux le comprendre, il est encore mieux de commenter ses fonctions. On distingue plusieurs méthodes de documentation : la documentation [reStructuredText (rst)](https://docs.python.org/devguide/documenting.html) et la documentation Google sont les plus communes. Voyons un exemple de la RST !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def comptage2(mots):\n",
    "    \"\"\" Compte et stocke le décompte de chaque mot dans une liste de mots\n",
    "    \n",
    "    :param mots: Liste de mosts\n",
    "    :type mots: list\n",
    "    :returns: Dictionnaire où les clefs sont les mots et les valeurs le nombre d'occurrences\n",
    "    :rtype: dict\n",
    "    \"\"\"\n",
    "    sans_doublon = set(mots)\n",
    "    compteur = {}\n",
    "    for mot in sans_doublon:\n",
    "        compteur[mot] = mots.count(mot)\n",
    "    return compteur"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Qu'avons-nous fait ?\n",
    "\n",
    "1. Nous avons utilisé le commentaire en triple guillemet `\"\"\"` qui permet de faire des commentaires en multilignes.\n",
    "2. La première ligne est consacrée à la description de ce à quoi sert la fonction\n",
    "3. On décrit un paramètre via `:param mots:` : la syntaxe est fixe `:param ` suivi du nom de mon paramètre et de `:` puis on décrite ce paramètre, ce qui est attendu\n",
    "4. Quand cela fait sens, on peut compléter `:param mots:` par `:type mots:` qui donne le type de données attendues (`list`, `str`, `dict`, `int`, `TextIOWrapper`, etc.)\n",
    "5. Une fois tous les paramètres décrits, on décrit ce qui est renvoyé après `:returns:`\n",
    "6. Quand cela fait sens, on peut compléter `:returns:` par `:rtype:` (pour *returns type*) comme pour les paramètres."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice\n",
    "\n",
    "Écrire une fonction `statistiques_mots` qui prend un chemin de fichier et qui renvoie un dictionnaire de compte d'occurrences. Documentez votre fonction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code ici\n",
    "\n",
    "\n",
    "# Cette portion vérifie que votre code fonction\n",
    "# En finissant la ligne par un \"\\\", on échappe le saut de ligne\n",
    "assert statistiques_mots(\"data/liaisons.118.txt\")[\"et\"] == 15, \\\n",
    "    \"Il y a 52 occurrences de et dans le texte du fichier W\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "#### Ce que l'on a appris\n",
    "\n",
    "Pour finir cette section, voici un récapitulatif des concepts appris. Lisez la liste et posez des questions si certaines choses ne sont pas claires.\n",
    "\n",
    "- `def`\n",
    "- paramètres et argument\n",
    "- portée des variables (*scope*)\n",
    "- documentation reStructuredText\n",
    "- `set()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nettoyer des données textuelles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans la section précédente, nous avons écrit du code pour calculer une distribution de fréquence des mots dans un texte stocké sur notre ordinateur. La méthode `split()` est une manière rapide pour diviser une chaîne en une liste de mots. Mais si nous regardons de plus près nos distributions de fréquence, nous remarquons beaucoup de bruit. Par exemple, le pronom *on* apparaît 1 fois, mais nous trouvons aussi `qu'on` survenant une fois. Et `et` et `Et` sont différents. Bien sûr, nous aimerions ajouter ces chiffres ensemble.\n",
    "\n",
    "Il y a deux stratégies à suivre pour corriger nos distributions de fréquences. Le premier est de trouver une meilleure procédure pour diviser notre texte en mots. La seconde consiste à nettoyer notre texte et à passer ce résultat propre à la méthode `split`. Pour l'instant nous suivrons nous occuperons du deuxième.\n",
    "\n",
    "Certains mots de notre texte sont en majuscules. Pour minuter ces mots, Python fournit la méthode `lower`. Il fonctionne sur des chaînes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'E'\n",
    "x_lower = x.lower()\n",
    "print(x_lower)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut appliquer cette fonction à notre texte compet pour obtenir un texte en minuscule de la même manière :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "texte = \"Les virgules, si on y pense, vraiment, je vous assure, sont SupErFlues.\"\n",
    "texte_lower = texte.lower()\n",
    "print(texte_lower)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cela résout notre problème de la compréhension des mots en majuscules, nous laissant avec le problème de la ponctuation. La méthode `replace` est justement la fonction que nous recherchons. Il prend deux arguments: (1) la chaîne que nous aimerions remplacer et (2) la chaîne qui servira de remplacement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "phrase = 'Mais. Arrêtez. De. Me. Couper. Dans. Mon. Élocution. S\\'il. Vous. Plait'\n",
    "sans_points = phrase.replace(\".\", \"\")\n",
    "print(sans_points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarquez que pour supprimer les `.`, on a fourni une chaîne vide `\"\"`. On aurait pu les remplacer par le mot `point`, mais cela ne nous aurait pas vraiment avancés."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nettoyez cette chaîne en supprimant les virgules, les points et les majuscules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "texte = \"Les virgules, si on y pense, vraiment, je vous assure, sont superflues.\"\n",
    "# Votre code ici\n",
    "\n",
    "# Et on vérifie avec le test.\n",
    "# Notez que si le copier coller est bien, il est mal de copier la chaîne en dessous au dessus.\n",
    "# Le test marcherait mais cela serait un peu malhonnête.\n",
    "print(texte == \"les virgules si on y pense vraiment je vous assure sont superflues.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et si on voulait supprimer toute la ponctuation d'un texte, pas seulement les points et les virgules ? On va écrire une fonction `supprimer_ponctuation` qui va faire ce que son nom indique. Il y a plein de manières d'écrire cette fonction, on va vous en montrer deux. La première stratégie est de répeter `replace` sur la même chaîne en changeant à chaque fois la l'élément de ponctuation par une chaîne vide."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def supprimer_ponctuation(texte):\n",
    "    \"\"\" Supprimer les caractères de ponctuation d'un texte\n",
    "    \n",
    "    :param texte: Texte à nettoyer\n",
    "    :type texte: str\n",
    "    :returns: Texte sans ponctuation\n",
    "    :rtype: str\n",
    "    \"\"\"\n",
    "    ponctuation = '!@#$%^&*()_-+={}[]:;\"\\'|<>,.?/~`'\n",
    "    for marqueur in ponctuation:\n",
    "        texte = texte.replace(marqueur, \"\")\n",
    "    return texte\n",
    "\n",
    "texte_court = \"Les virgules, si l'on y pense, vraiment, je vous assure, sont superflues.\"\n",
    "print(supprimer_ponctuation(texte_court))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'autre stratégie qui permet d'arriver au même résultat n'utilise pas la fonction `replace`. Cela consiste à itérer sur la chaîne de caractère et de vérifier s’ils sont acceptables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def supprimer_ponctuation2(texte):\n",
    "    \"\"\" Supprimer les caractères de ponctuation d'un texte\n",
    "    \n",
    "    :param texte: Texte à nettoyer\n",
    "    :type texte: str\n",
    "    :returns: Texte sans ponctuation\n",
    "    :rtype: str\n",
    "    \"\"\"\n",
    "    ponctuation = '!@#$%^&*()_-+={}[]:;\"\\'|<>,.?/~`'\n",
    "    nouveau_texte = \"\"\n",
    "    for charactere in texte:\n",
    "        if charactere not in ponctuation:\n",
    "            nouveau_texte += charactere\n",
    "    return nouveau_texte\n",
    "\n",
    "\n",
    "texte_court = \"Les virgules, si l'on y pense, vraiment, je vous assure, sont superflues.\"\n",
    "print(supprimer_ponctuation2(texte_court))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est temps de faire votre propre fonction. À partir du test et de la documentation, compléter le code ci-dessous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nettoyer_texte(texte, ponctuation):\n",
    "    \"\"\" Cette fonction transforme les majuscules en minuscules et supprime la ponctuation\n",
    "    \n",
    "    :param texte: Texte à nettoyer\n",
    "    :type texte: str\n",
    "    :param ponctuation: Charactères à supprimer\n",
    "    :type ponctuation: str\n",
    "    :returns: Texte sans les charactères et en minuscule\n",
    "    :rtype: str\n",
    "    \"\"\"\n",
    "    # Votre code ici\n",
    "    \n",
    "# Le test qui vérifie tout\n",
    "texte_court = \"Les virgules, il paraît, sont superflues. Les points - au contraire - ne le sont pas!\"\n",
    "assert nettoyer_texte(texte_court, \"!,-.\") == \\\n",
    "    \"les virgules il paraît sont superflues les points  au contraire  ne le sont pas\", \\\n",
    "    \"Des caractères n'ont pas été supprimés ou transformés\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et maintenant, tout ensemble ! On va :\n",
    "- ouvrir le fichier `data/misanthrope.acte3.scene4.txt` et récupérer son texte,\n",
    "- on supprimera la ponctuation\n",
    "- on remplacera les apostrophes et les traits d'unions par des espaces\n",
    "- on fera des statistiques d'occurrences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def separateur_de_texte(texte):\n",
    "    \"\"\" Cette fonction remplace les apostrophes et les traits d'unions par des espaces\n",
    "    \n",
    "    :param texte: Texte à nettoyer\n",
    "    :type texte: str\n",
    "    :returns: Texte simplifié\n",
    "    :rtype: str\n",
    "    \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code ici\n",
    "\n",
    "\n",
    "# Les tests\n",
    "assert decompte[\"on\"] == 3\n",
    "assert decompte[\"moi\"] == 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aller plus loin : évaluer le temps d'une fonction\n",
    "\n",
    "**Cette partie n'est pas nécessaire pour avancer dans le cours. Cependant, il peut être intéressant de se pencher sur comment on évalue les performances d'un morceau de code**\n",
    "\n",
    "L'optimisation de code est une tâche extrêmement importante dans le développement d'une application. Par exemple, imaginons que nous offrions une possibilité de faire une recherche sans accent dans 10.000 fichiers à nos utilisateurs-rices en ligne. Chaque recherche va devoir ouvrir, convertir les fichiers en fichiers sans accents, convertir la recherche de notre utilisateur-rice. Autant dire que si votre code met plus de 20 secondes à trouver les résultats, votre utilisateur-rice ne fera pas beaucoup de recherches.\n",
    "\n",
    "Il s'agit alors de pouvoir évaluer comment une fonction se comporte et combien de temps elle peut prendre en la comparant avec une autre méthode d'écriture. Vous trouverez ci-dessous un exemple de morceau de code qui permet de comparer deux fonctions. Amusez-vous avec la variable `nombre_de_repetitions` !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ceci est un import. Nous verrons cela plus en détails plus tard mais il s'agit d'importer \n",
    "# la chose portant le nom 'default_timer' de la librairie timeit\n",
    "from timeit import default_timer\n",
    "\n",
    "# On met en place un nombre de répétitions. Comparer une seule itération serait peu correct.\n",
    "nombre_de_repetitions = 10000\n",
    "\n",
    "# On prend l'heure à la seconde fractionnelle près\n",
    "temps_replacement_1 = default_timer()\n",
    "# On boucle sur range(10000) : range sera un generator qui créera toute les valeurs\n",
    "# entre 0 et 10000 exclu\n",
    "for intervention in range(nombre_de_repetitions):\n",
    "    # On supprime la ponctuation mais nous n'avons pas besoin du résultat donc on assigne\n",
    "    # pas celui-ci à une variable\n",
    "    supprimer_ponctuation(texte)\n",
    "# On compare l'heure qu'il est avec l'heure que l'on avait avant.\n",
    "# Cette comparaison est notre temps d'exécution\n",
    "temps_replacement_1 = default_timer() - temps_replacement_1\n",
    "\n",
    "\n",
    "temps_replacement_2 = default_timer()\n",
    "for intervention in range(nombre_de_repetitions):\n",
    "    supprimer_ponctuation2(texte)\n",
    "temps_replacement_2 = default_timer() - temps_replacement_2\n",
    "\n",
    "\n",
    "print(\"Temps pris par la fonction 1 pour \"+ str(nombre_de_repetitions) +\n",
    "      \" itérations : \" + str(temps_replacement_1))\n",
    "\n",
    "print(\"Temps pris par la fonction 2 pour \"+ str(nombre_de_repetitions) +\n",
    "      \" itérations : \" + str(temps_replacement_2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "#### Ce que l'on a appris\n",
    "\n",
    "Pour finir cette section, voici un récapitulatif des concepts appris. Lisez la liste et posez des questions si certaines choses ne sont pas claires.\n",
    "- `lower()`\n",
    "- `replace(__, __)`\n",
    "- (Aller plus loin) `range()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ecrire dans un fichier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On est arrivé loin ! Il reste bien sûr encore plein de choses à voir, mais bon... Réjouissons-nous du chemin déjà parcouru !\n",
    "\n",
    "Regardons comment écrire simplement dans un fichier:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# On en profite pour rappeler et que les termes input et output sont très souvent utilisés\n",
    "# en programmation\n",
    "\n",
    "output = open(\"resultats/premier-resultat.txt\", mode=\"w\")\n",
    "output.write(\"Mon premier résultat.\")\n",
    "output.close()\n",
    "\n",
    "# Ou l'équivalent :\n",
    "with open(\"resultats/deuxieme-resultat.txt\") as fichier_texte:\n",
    "    fichier_texte.write(\"Mon 2eme résultat\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Allez-y, ouvrez ces fichiers dans votre explorateur de fichiers. Vous verrez que les deux fichiers comportent les données ici définies.\n",
    "\n",
    "Si on regarde bien, les syntaxes sont très proches de ce que l'on avait fait auparavant pour lire. La différence ? La définition du paramètre `mode` avec la valeur `w` (pour *write*, écrire). Sinon, le reste est le même : on ouvre, on ferme ou on utilise `with` qui le fait lui-même.\n",
    "\n",
    "En fait, la lecture de fichier se fait en mode `r` pour *read* (lecture). Le type d'interaction à venir avec un fichier sera donc défini par le mode utilisé à son ouverture. Mais comment se fait-il que l'on puisse ne pas définir mode ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Les arguments optionnels ou défauts de python\n",
    "\n",
    "En fait, Python fournit pour ses arguments la possibilité de définir des valeurs par défaut à la création de la fonction, regardez plutôt :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def supprimer_ponctuation(texte, ponctuation='?,.!'):\n",
    "    \"\"\" Supprimer les caractères de ponctuation d'un texte\n",
    "    \n",
    "    :param texte: Texte à nettoyer\n",
    "    :type texte: str\n",
    "    :param ponctuation: Caractères à supprimer\n",
    "    :type ponctuation: str\n",
    "    :returns: Texte sans ponctuation\n",
    "    :rtype: str\n",
    "    \"\"\"\n",
    "    for marqueur in ponctuation:\n",
    "        texte = texte.replace(marqueur, \"\")\n",
    "    return texte\n",
    "\n",
    "a_tester = \"Je. suis. fatigué. de. devoir. écrire. des. exemples, non ?\"\n",
    "assert supprimer_ponctuation(a_tester) == supprimer_ponctuation(a_tester, \"?.,\")\n",
    "assert supprimer_ponctuation(a_tester) == supprimer_ponctuation(a_tester, ponctuation=\"?.,\")\n",
    "assert supprimer_ponctuation(a_tester) != supprimer_ponctuation(a_tester, ponctuation=\",\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici, `ponctuation` a une valeur par défaut `'?,.!'`. Cela signifie que si l'on ne donne pas de valeur à cet argument, cette valeur sera fournie par la définition de la fonction.\n",
    "\n",
    "Lisez la phrase précédente jusqu'à la comprendre.\n",
    "\n",
    "Maintenant, on remarque que `ponctuation` peut-être soit utilisé en le donnant dans l'ordre original (en deuxième position) ou en utilisant son nom : Python fournit aussi pour les fonctions la possibilité d'utiliser les arguments nommés (aussi appelées arguments mots-clefs, `named argument`, `keyword argument` et en raccourci `kwargs`). Voyez plutôt :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert supprimer_ponctuation(a_tester, \",?,\") == \\\n",
    "    supprimer_ponctuation(texte=a_tester, ponctuation=\",?,\")\n",
    "assert supprimer_ponctuation(a_tester, \",?,\") == \\\n",
    "    supprimer_ponctuation(ponctuation=\",?,\", texte=a_tester)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Relisez bien ce qui vient d'être dit, prenez le temps. Il est très important de comprendre cela avant d'avancer.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ce que l'on a appris\n",
    "\n",
    "Pour finir cette section, voici un récapitulatif des concepts appris. Lisez la liste et posez des questions si certaines choses ne sont pas claires.\n",
    "\n",
    "- `open(_, mode=\"w\")`\n",
    "- `.write()`\n",
    "- *keyword arguments*\n",
    "- valeurs par défaut dans les fonctions\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans cet exercice final, on va vous demander de calculer la distribution totale des mots dans l'intégralité d'*Horace* de Corneille. Le texte a été copié depuis le projet Théâtre Classique ( http://www.theatre-classique.fr/pages/programmes/edition.php?t=..%2Fdocuments%2FCORNEILLEP_HORACE.xml )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ecrire_colonne(distribution, fichier):\n",
    "    \"\"\" Ecrit dans un fichier chaque mot en clef de distribution avec la fréquence associée\n",
    "    dans un fichier donné.\n",
    "    \n",
    "    :param distibution: Dictionnaire où la clef est un mot et la valeur le nombre d'occurrence\n",
    "    :type distribution: dict\n",
    "    :param fichier: Fichier ouvert pour l'écriture\n",
    "    :type fichier: TextIOWrapper\n",
    "    \"\"\"\n",
    "    fichier.write(\"Mot;Distribution\\n\")\n",
    "    for mot, frequence in distribution.items():\n",
    "        fichier.write(mot + \";\" + str(frequence) + '\\n')\n",
    "\n",
    "# Ouvrir le fichier et stocker son contenu\n",
    "\n",
    "# Nettoyer le texte\n",
    "\n",
    "\n",
    "# Calculer la distribution\n",
    "\n",
    "# Ouvrir le fichier `frequence_horace.txt` pour écrire\n",
    "\n",
    "# Utiliser la fonction ecrire_colonne pour écrire dans ce fichier\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p><small><a rel=\"license\" href=\"http://creativecommons.org/licenses/by-sa/4.0/\"><img alt=\"Creative Commons License\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-sa/4.0/88x31.png\" /></a><br /><span xmlns:dct=\"http://purl.org/dc/terms/\" property=\"dct:title\">Python Programming for the Humanities</span> by <a xmlns:cc=\"http://creativecommons.org/ns#\" href=\"http://fbkarsdorp.github.io/python-course\" property=\"cc:attributionName\" rel=\"cc:attributionURL\">http://fbkarsdorp.github.io/python-course</a> is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-sa/4.0/\">Creative Commons Attribution-ShareAlike 4.0 International License</a>. Based on a work at <a xmlns:dct=\"http://purl.org/dc/terms/\" href=\"https://github.com/fbkarsdorp/python-course\" rel=\"dct:source\">https://github.com/fbkarsdorp/python-course</a>.</small></p>"
   ]
  }
 ],
 "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"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "228px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}