Chapitre 1 - Au début était la variable.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapitre 1 : Au début était la variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-- Source : *A Python Course for the Humanities by Folgert Karsdorp and Maarten van Gompel*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(\"A vos marques, prêts, partez!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tout le monde peut apprendre comment programmer et le meilleur moyen d'apprendre, c'est de faire. Dans ce tutoriel, nous vous demanderons d'écrire beaucoup de code. Cliquez sur un bloc de code dans ce tutoriel, comme celui d'au-dessus, et appuyez sur ctrl+entrée pour le lancer. Commençons dès lors et écrivons notre premier petit programme!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quiz!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans la boîte ci-dessous, écris un programme simple qui calcule combien de minutes il y a en 7 semaines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Félicitations ! Tu as écrit ton premier petit programme et tu l'as fait sans aide! Bon, maintenant, on va essayer d'aller plus loin qu'une simple calculette. Avant que l'on vous demande d'écrire un autre programme, parlons d'abord de ce que l'on appelle l'assignation (`assignment`).\n",
    "\n",
    "On peut assigner des valeurs aux variables en utilisant l'opérateur `=`. Une variable est juste un nom auquel on assigne une valeur particulière. Un peu comme une boîte dans laquelle on rangerait des choses et sur laquelle on écrirait au marqueur noir un nom pour se souvenir de son contenu. Le bloc suivant contient deux opérations. D'abord, on assigne 2 à la variable `x`. `x` contient donc désormais `2`. Après on fait ce que l'on veut avec cette valeur. On peut par exemple l'afficher en utiliser la commande `print()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "x = 2\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant qu'on a enregistré la valeur 2 dans `x`, on peut utiliser cette variable pour faire ce qui suit :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(x * x)\n",
    "print(x == x)\n",
    "print(x > 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Peux-tu te rendre compte de ce qui se passe ici ?\n",
    "\n",
    "Les variables peuvent bien sûr contenir autre chose que des nombres. Elles peuvent contenir du texte, appelé chaîne de caractère ou _string_ en anglais. Par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "book = \"Les Mains Sales\"\n",
    "print(book)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une chaîne de caractère en python doit être comprise entre des guillemets (simples ou doubles). Sans ces guillemets, Python pense que l'on fait appel à des variables. Il s'agit d'un élément de distinction primordial. `book` est une variable qui contient la chaîne `\"Les Mains Sales\"`.\n",
    "\n",
    "Regardons ce qu'il se passe si on oublie les guillemets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "book = Les"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les messages d'erreur sont une partie importante de la programmation et savoir comment les interpréter est essentiel. Cette erreur nous informe que le nom `Les` n'est pas défini. Cela veut dire qu'il n'y a aucune variable qui existe avec le nom `Les`. Désormais, quand vous verrez ce message, vous saurez ce qu'il veut dire. Pour le corriger, vous devez soit définir une variable qui se nome `Les` soit, si vous vouliez assigner la chaîne \"The\" à `book` la mettre dans des guillemets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les noms de variables sont des choses arbitraires. *On* donne à une certaine valeur un nom, et le choix de ce nom est clairement libre. Il est cependant recommandé d'utiliser des noms de variables qui font sens et qui nous permettront de nous rappeler de leur contenu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# À éviter...\n",
    "banane = \"Les Mains Sales\"\n",
    "print(banane)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous avez le droit d'utiliser le nom `banane` pour contenir le titre `\"Les Mains Sales\"` mais vous êtes d'accord que pour vous et pour les autres, se rappeler que l'un contient l'autre va être difficile.\n",
    "\n",
    "Les variables peuvent évoluer, on peut mettre à jour nos variables.\n",
    "\n",
    "Disons que nous avons compté le nombre de mémoires dans le bureau :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nombre_de_memoires = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et après une soutenance tardive, on en obtient un nouveau. On met alors à jour le nombre de livres :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nombre_de_memoires = nombre_de_memoires + 1\n",
    "print(nombre_de_memoires)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Des mises à jour comme celles-ci arrivent souvent. Python et d'autres langages fournissent un raccourci : vous pouvez écrire la même chose en faisant `+=`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nombre_de_memoires += 5\n",
    "print(nombre_de_memoires)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La dernière chose à savoir sur ces variables pour le moment c'est que l'on peut assigner la valeur d'une variable à une autre variable. On en verra un peu plus à ce sujet plus tard, mais pour l'instant, apprenons les bases de ce mécanisme. \n",
    "\n",
    "**Avant d'exécuter le code suivant, pouvez-vous prévoir ce que Python va afficher ?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "livre = \"The Lord of the Flies\"\n",
    "en_cours_de_lecture = livre\n",
    "print(en_cours_de_lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant que vous avez compris l'assignation de valeurs à des variables, il est temps de faire un exercice. Nous voulons que vous écriviez du code qui définit une variable, *nom*, et que vous assignez comme valeur votre prénom. Si votre nom est plus petit que 5 lettres, utilisez votre nom de famille. Si vous nom de famille est trop court, utilisez la combinaison de votre prénom et nom de famille."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Écrivez le code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ce que l'on a appris"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "-  variable\n",
    "-  valeur\n",
    "-  assignation de valeur\n",
    "-  différence entre variables et valeurs\n",
    "-  chaînes (*string*)\n",
    "-  nombres entiers (*integer*)\n",
    "-  faire évoluer des variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manipulation de chaînes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De nombreuses disciplines dans les sciences humaines travaillent sur des textes. Tout naturellement, la programmation pour les sciences humaines se concentrera beaucoup sur la manipulation des textes. Dans le dernier quiz, il vous a été demandé de définir une variable qui pointe vers une chaîne représentant votre nom. Nous avons déjà vu une certaine arithmétique de base dans notre tout premier calcul. Non seulement les nombres, mais aussi les chaînes peuvent être ajoutées, ou, plus précisément, *concaténées*, ensemble aussi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "livre = \"Les Mains Sales\"\n",
    "print(nom + \" aime \" + livre + \"?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La chaîne est faite d'un certain nombre de caractères. Il est possible d'accéder à chacun des caractères grâce à l'`indexation`. Par exemple, pour trouver la première lettre de votre nom, vous pouvez taper :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "premiere_lettre = nom[0]\n",
    "print(premiere_lettre)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarquez que pour accéder à la première lettre, nous avons utilisé l'index `0`. Cela peut sembler bizarre, mais c'est simplement que Python indexe à partir de 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant que vous connaissez cela, accédez à la dernière lettre de votre nom:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est peu pratique d'avoir à connaître la longueur d'une chaîne pour accéder à la dernière lettre de celle-ci. Python fournit un moyen simple d'accéder à une chaîne depuis l'arrière:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "derniere_lettre = nom[-1]\n",
    "print(derniere_lettre)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sinon, il y a la fonction `len()` qui retourne la longueur de chaîne:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(len(nom))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question \n",
    "Pouvez-vous expliquer ce qui suit ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(nom[len(nom)-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Écrivez un programme qui écrit dans la variable `avant_derniere` et assignez-y la valeur de l'avant-dernière lettre de votre nom."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous commencez à devenir un-e véritable expert-e dans l'indexation des chaînes. Maintenant, que se passe-t-il si nous voulons savoir quelles sont les deux ou trois dernières lettres de notre nom? En Python, nous pouvons utiliser ce qu'on appelle des index de tranches ou des tranches pour faire court (*slices*). Pour trouver les deux premières lettres de notre nom, nous tapons:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "premiere_deux_lettres = nom[0:2]\n",
    "print(premiere_deux_lettres)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'index `0` est optionnel, on aurait pu tout à fait taper `nom[:2]`. Cela se traduit en français par : prendre tous les caractères jusqu'à arriver à l'index `2`. On peut aussi commencer au caractère `2` et aller jusqu'à la fin:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "sauf_les_deux_premieres = nom[2:]\n",
    "print(sauf_les_deux_premieres)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parce que nous n'avons pas spécifié de fin, Python a continué jusqu'à la fin de la chaîne. Si l'on avait voulu trouver les deux dernières lettres de notre nom, on aurait pu taper :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "dernieres_deux_lettres = nom[-2:]\n",
    "print(dernieres_deux_lettres)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Regardez ce qui suit. Le comprenez vous ?? \n",
    "<div style=\"display:block; text-align:center;\"><img src=\"http://www.nltk.org/images/string-slicing.png\" align=center /></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Définissez une variable `lettres_du_milieu` et assignez-y l'ensemble des caractères de votre `nom` sauf les deux premières et deux dernières :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En utilisant les deux mots suivants, pouvez-vous écrire un code qui affichera \"*humanités*\" en utilisant uniquement les tranches et la concaténation ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "mot1 = \"humanisant\"\n",
    "mot2 = \"opportunités\"\n",
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ce que nous avons appris"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "-  concaténation (p. ex. somme de chaînes de caractères)\n",
    "-  indexation\n",
    "-  tranches\n",
    "-  `len()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les Listes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prenez, si vous le voulez, la chaîne suivante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "phrase = \"Le nom Python est dérivé de la série télévisée Monty Python's Flying Circus.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les mots sont composés de caractères, de même que les chaînes en Python. Maintenant, pour la phrase ci-dessus, il semble plus naturel de la décrire en termes de mots qu'en termes de caractères. Disons que nous voulons accéder au premier mot de notre phrase. Si nous tapons:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "premier_mot = phrase[0]\n",
    "print(premier_mot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python imprime seulement la première lettre de notre phrase. (Pensez-y si vous ne comprenez pas pourquoi.) Nous pouvons transformer notre phrase en une `list` de mots (représentés par des chaînes) en utilisant la méthode `split()` comme suit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "mots = phrase.split()\n",
    "print(mots)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En utilisant la fonction `split` sur notre phrase, Python scinde la phrase sur les espaces et retourne une liste de mots. À bien des égards, une liste fonctionne comme une chaîne. Nous pouvons accéder à tous ses composants en utilisant des index et nous pouvons utiliser des index de tranches pour accéder à certaines parties de la liste. Essayons!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Écrivez un petit programme qui définit une variable `premier_mot` et attribuez-lui le premier mot de notre liste `mots`. Jouez un peu avec les index pour voir si vous comprenez vraiment comment cela fonctionne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Copier votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une liste est une sorte de container dans lequel on peut enregistrer tout type d'information. On accède aux valeurs des listes  en utilisant les index et tranches. On peut aussi ajouter de nouveaux objets. Pour cela, on utilise la méthode `append`. Voyons comment cela marche. Disons que l'on veut garder nos bonnes lectures dans une liste. On commence avec une liste vide et on ajoute peu à peu nos livres:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Commencer avec un liste vide\n",
    "bonnes_lectures = []\n",
    "# Ajouter les livres\n",
    "bonnes_lectures.append(\"Twilight\")\n",
    "bonnes_lectures.append(\"Pour en finir avec le jugement de Dieu\")\n",
    "print(bonnes_lectures)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puis, si jamais on n'aime plus un de ces livres, ou que l'on s'est trompé, on peut le changer :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "bonnes_lectures[0] = \"Dracula\"  # Rien ne vaut l'original. Et puis lui ne brille pas.\n",
    "print(bonnes_lectures)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voilà un autre petit exercice. Changez le nom de votre deuxième bonne lecture:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous venons de changer un élément dans une liste. Notez que si vous faites la même chose pour une chaîne, vous obtiendrez une erreur:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "python = \"Pythen\"\n",
    "python[4] = \"o\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C'est parce que les `strings` (chaînes) et d'autres types d'objets sont *immuables* (`immutable` dans la langue de Shakespeare). Cela veut dire qu'elles ne peuvent pas être changées, au contraire des `list` qui sont des `mutables`. Voyons d'autres moyens de modifier ces listes :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### remove()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Supposons que notre collection de bonnes lectures s'est beaucoup élargie et nous aimerions supprimer certains des livres de la liste. Python fournit la méthode `remove()` qui agit sur une liste et prend comme argument les éléments que nous voulons supprimer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "bonnes_lectures = [\n",
    "    \"Orgueil et Préjugés \",\n",
    "    \"Le Père Goriot \",\n",
    "    \"Les Hauts de Hurlevent \",\n",
    "    \"L'Étranger \",\n",
    "    \"Les poèmes de Paul Celan\",\n",
    "    \"Voyage au bout de la nuit\",\n",
    "    \"Fifi Brindacier\"\n",
    "]\n",
    "\n",
    "bonnes_lectures.remove(\"Fifi Brindacier\")\n",
    "\n",
    "print(bonnes_lectures)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si nous essayons de supprimer un livre qui n'est pas dans notre collection, Python déclenche une erreur :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "bonnes_lectures.remove(\"Les Mains Sales\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans une variable `bonnes_lectures` initialisée comme une liste vide, ajoutez au moins trois de vos livres favoris (si vous n'arrivez pas à vous décider, prenez en ici https://fr.wikipedia.org/wiki/Les_cent_livres_du_si%C3%A8cle ) et affichez les deux derniers que vous avez ajoutés:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tout comme avec les chaînes, on peut concaténer des listes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# D'abord on initie deux listes\n",
    "bonnes_lectures = [\n",
    "    \"Orgueil et Préjugés \",\n",
    "    \"Le Père Goriot \",\n",
    "    \"Les Hauts de Hurlevent \",\n",
    "    \"L'Étranger \",\n",
    "    \"Les poèmes de Paul Celan\",\n",
    "    \"Voyage au bout de la nuit\",\n",
    "    \"Fifi Brindacier\"\n",
    "]\n",
    "\n",
    "lectures_regrettables = [\"50 nuances de Gris\", \"Twilight\"]\n",
    "\n",
    "lectures = bonnes_lectures + lectures_regrettables\n",
    "print(lectures)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### sort()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C'est toujours sympa de pouvoir trier ses affaires, encore plus nos étagères. On peut utiliser la méthode `sort()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "bonnes_lectures.sort()\n",
    "print(bonnes_lectures)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Listes Imbriquées (`nested list`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jusque là, on a pu s'amuser avec des listes de chaînes. Cependant, une liste peut contenir ce qu'elle veut, comment des entiers (`integers`) et des listes. Pouvez-vous expliquer, ligne par ligne, ce qui se passe ici :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "liste_imbriquee = [[1, 2, 3, 4], [5, 6, 7, 8]]\n",
    "print(liste_imbriquee[0])\n",
    "print(liste_imbriquee[0][0])\n",
    "print(liste_imbriquee[1][1])\n",
    "print(liste_imbriquee[-1][-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous pouvons utiliser ça pour améliorer notre liste de bonnes lectures en ajoutant un score pour chaque livre que l'on a. Une entrée dans notre collection se composera d'un score dans l'intervalle de 1 et 10 et du titre de notre livre. Le premier élément est le titre; le deuxième le score: `[titre, score]`. Nous initialisons une liste vide:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "bonnes_lectures = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et on y ajoute deux livres:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "bonnes_lectures.append([\"Les poèmes de Paul Celan\", 8])\n",
    "bonnes_lectures.append([\"Voyage au bout de la nuit\", 9])\n",
    "print(bonnes_lectures)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mettez à jour `bonnes_lectures` avec quelques livres de votre choix et donnez-leur un score. Pouvez-vous afficher le score du premier livre de la liste ? Et le titre de l'avant-dernier ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ce que nous avons appris"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "-  liste\n",
    "-  *mutable* vs. *immutable*\n",
    "-  `.split()`\n",
    "-  `.append()`\n",
    "-  listes imbriquées\n",
    "-  `.remove()`\n",
    "-  `.sort()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionnaires"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notre petite collection de bonnes lectures commence à ressembler à quelque chose et nous pouvons désormais la manipuler de différentes manières. Maintenant, imaginez que notre liste soit très grande et nous aimerions rechercher le score que nous avons donné à un livre en particulier. Comment allons-nous trouver ce livre?  Avec une liste, cela sera difficile. Mais Python fournit une autre structure de données plus appropriée, appelée `dictionary`. Un `dictionnaire` est similaire aux dictionnaires que vous avez à la maison. Il se compose d'entrées ou de clés (`keys`) qui contiennent une valeur. Définissons-en un:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "dictionnaire = {\"livre\": \"Assemblage de feuilles imprimées et réunies en un volume, broché ou relié\",\n",
    "           \"épée\": \"Arme de main faite d'une lame d'acier pointue fixée à une poignée munie d'une garde.\",\n",
    "           \"archive\": \"Pièce, document d'archives.\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Regardez de près la nouvelle syntaxe. Remarquez les accolades et les deux-points. Les clés sont situées sur le côté gauche des deux points; les valeurs (`values`) sur le côté droit. Pour rechercher la valeur d'une clé donnée, nous 'indexons' le dictionnaire en utilisant cette clé:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "description = dictionnaire[\"épée\"]\n",
    "print(description)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On parle d'*indexer* car nous utilisons la même syntaxe avec des crochets  que celle de l'indexation de listes ou de chaînes. La différence est que nous n'utilisons pas de numéro de position pour indexer un dictionnaire, mais une clé. Comme les listes, les dictionnaires sont *mutables*, ce qui signifie que nous pouvons ajouter et supprimer des entrées. Définissons un dictionnaire vide et y ajoutons quelques livres. Les titres seront nos clés et les scores leurs valeurs. Regardez la syntaxe pour ajouter une nouvelle entrée:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "bonnes_lectures = {}\n",
    "bonnes_lectures[\"Les poèmes de Paul Celan\"] = 8\n",
    "bonnes_lectures[\"Voyage au bout de la nuit\"] = 9\n",
    "print(bonnes_lectures)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "D'une certaine manière, c'est similaire à ce que nous faisions pour la `list` avant. Avant, nous indexions avec des nombres qui correspondaient à un certain livre. Là, nous utilisons directement le titre du livre. Pouvez-vous imaginer à quel point cela sera utile ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mettez à jour la nouvelle structure de données de bonnes lectures avec vos propres livres. Essayez d'afficher le score que vous avez donné pour l'un des livres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### keys(), values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comme indiqué précédemment, notre dictionnaire possède un ensemble de clés. Pour retrouver la liste des index de ces livres dans notre collection, il suffit juste de demander celle-ci à la variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "bonnes_lectures.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De la même manière, on peut demander les valeurs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "bonnes_lectures.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou on peut demander les paires (clef, valeur) avec la méthode `items`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(bonnes_lectures.items())\n",
    "print(bonnes_lectures)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Détails : Générateurs et tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Générateurs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que se passe-t-il quand vous tentez d'exécuter le code suivant ? **Avant de l'exécuter, essayez d'expliquer ce que ce code doit faire**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bonnes_lectures.keys()[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les méthodes `.keys()`, `⋅values()` et `.items()` ne produisent en fait pas des listes, mais ce que l'on appelle en python des générateurs (`generator`). Les générateurs ont cela de particulier qu'ils sont des sortes de listes qui n'acceptent pas l'indexation, puisqu'elles n'ont pas été encore calculées. Cela permet dans certains cas d'éviter de charger trop la mémoire d'un ordinateur.\n",
    "\n",
    "Pour transformer un générateur en liste, on peut la retyper (ou `cast`) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bonnes_lectures_liste = list(bonnes_lectures.keys())\n",
    "print(bonnes_lectures_liste[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En dehors de cette légère différence quant à l'indexation, les `generators` de clés et de valeurs ont les mêmes propriétés globales que les listes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(bonnes_lectures.keys()))\n",
    "print(len(bonnes_lectures_liste))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Les tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avez-vous remarqué que le résultat de `print(bonnes_lectures.items())` renvoie une liste d'éléments eux-mêmes groupés entre parenthèses ? Essayons de copier le résultat :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bonne_lecture_tuple = [\n",
    "    ('Les poèmes de Paul Celan', 8),\n",
    "    ('Voyage au bout de la nuit', 9)\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et maintenant, essayez de comprendre le code suivant et lancez-le :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(bonne_lecture_tuple[0][0])\n",
    "print(len(bonne_lecture_tuple))\n",
    "print(bonne_lecture_tuple[1][0])\n",
    "print(bonne_lecture_tuple[1][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puis faites de même avec ce qui suit :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bonne_lecture_tuple[0][0] = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bonne_lecture_tuple[0].append(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comprenez-vous ce qui se passe ?\n",
    "\n",
    "En fait, les `tuples` sont des listes simplifiées et *immutables*. Elles sont indexables, mais, comme les chaînes, ne supportent pas les changements. Cela peut-être pratique pour partager des données qui ne doivent pas bouger, mais où l'indexation est pratique. Par ailleurs, les tuples permettent des assignations pratiques telles que le code qui suit: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "titre, note = bonne_lecture_tuple[0]\n",
    "print(titre)\n",
    "print(note)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ce que nous avons appris"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "-  dictionnaires (`dictionary`)\n",
    "-  indexation et accès aux valeurs des dictionnaires\n",
    "-  ajouter des objets aux dictionnaires\n",
    "-  `.keys()`\n",
    "-  `.values()`\n",
    "- les générateurs (`generator`)\n",
    "- les tuples (`tuple`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les condition simples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une grande partie de la programmation a à voir avec l'exécution d'un certain morceau de code si une condition particulière est vérifiée. Nous avons déjà vu deux conditions au tout début du chapitre (`x == x`, `x < 6`). Ici, nous donnons un bref aperçu. Pouvez-vous comprendre ce que toutes les conditions font?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(\"2 < 5 est\", 2 < 5)\n",
    "print(\"3 > 7 est\", 3 >= 7)\n",
    "print(\"3 == 4 est\", 3 == 4)\n",
    "print(\"école == devoirs est\", \"école\" == \"devoirs\")\n",
    "print(\"Python != perl est\", \"Python\" != \"perl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Si, ou si, et sinon (if, elif and else)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le dictionnaire est une meilleure structure de données pour notre collection de bonnes lectures. Cependant, même avec les dictionnaires, nous pourrions oublier les livres que nous avons ajoutés à la collection. Que se passe-t-il si nous essayons d'obtenir le score d'un livre qui n'est pas dans notre collection (en espérant que cela n'arrive jamais !)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "bonnes_lectures[\"Le Retour du Roi\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous obtenons une erreur. Une `KeyError`, qui signifie simplement \"*la clé que vous m'avez demandé de rechercher n'est pas dans le dictionnaire*\". Nous en apprendrons beaucoup plus sur la gestion des erreurs plus tard, mais pour l'instant nous voudrions empêcher notre programme de l'émettre. Écrivons un petit programme qui imprime \"X est dans la collection\" si un livre particulier est dans la collection et \"X n'est pas dans la collection\" si ce n'est pas le cas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "livre = \"Le Retour du Roi\"\n",
    "if livre in bonnes_lectures:\n",
    "    print(livre + \" est dans la collection\")\n",
    "    print(\"On peut bien sûr écrire plus de code ici.\")\n",
    "else:\n",
    "    print(livre + \" n'est pas dans la collection\")\n",
    "    print(\"On peut bien sûr écrire plus de code ici aussi.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Beaucoup de syntaxe nouvelle d'un coup. Allons-y étape par étape.\n",
    "\n",
    "D'abord, on demande si la valeur assignée à `livre` est dans notre collection. La partie après `if` sera évaluée en `True` (Vrai) ou `False` (Faux). Vérifions :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "livre in bonnes_lectures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parce que le livre n'est pas dans notre collection, Python retourne `False`. Faisons la même chose avec un livre que l'on sait être dans notre collection :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\"Voyage au bout de la nuit\" in bonnes_lectures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bien sûr qu'il est dans la collection. Retournons à notre déclaration `if` (`statement`). Si l'expression après `if` vaut `True`, notre programme passera à la ligne suivante et affichera `book + \"est dans la collection\"`. Essayons cela aussi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "if \"Voyage au bout de la nuit\" in bonnes_lectures:\n",
    "    print(\"On l'a!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "if livre in bonnes_lectures:\n",
    "    print(\"On l'a!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notez que l'instruction d'impression dans le dernier bloc de code n'est pas exécutée. C'est parce que la valeur que nous avons assignée à `livre` n'est pas dans notre collection et donc la partie après `if` n'a pas valu `True`. Dans notre petit programme ci-dessus, nous avons utilisé une autre déclaration à côté de `if`, à savoir `else`. Il ne devrait pas être trop difficile de comprendre ce qui se passe ici. La partie après `else` sera exécutée si l'instruction `if` est évaluée à `False`. En français: si le livre n'est pas dans la collection, alors afficher que ce n'est pas le cas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indentation!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avant de continuer, nous devons d'abord vous expliquer que la disposition de notre code n'est pas ici juste pour faire jolie. Contrairement à d'autres langages, Python n'utilise pas d'accolades pour marquer le début et la fin des blocs. Le seul délimiteur est un deux-points (`:`) et l'indentation du code. Cette indentation doit être utilisée de manière cohérente dans tout votre code. La convention consiste à utiliser 4 espaces comme indentation (certains environnements de développement transforment automatiquement une tabulation en 4 espaces). Cela signifie qu'après avoir utilisé un deux-points (comme dans notre instruction `if`), la ligne suivante devrait être indentée de quatre espaces de plus que la ligne précédente.\n",
    "\n",
    "On se retrouve parfois dans une situation où plusieurs conditions sont excluantes, pas seulement un `if` et un `else` mais plusieurs autres conditions entre les deux. Pour cela, Python fournit l'instruction `elif`. Son utilisation est similaire à `if` et` else`. Notez cependant que vous ne pouvez utiliser `elif` qu'après une instruction `if`! Au-dessus nous avons demandé si un livre était dans la collection. Nous pouvons faire la même chose pour des parties de chaînes ou pour des éléments d'une liste. Par exemple nous pourrions tester si la lettre *a* est dans le mot *banane*:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"a\" in \"banane\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bien sûr, la suite vaudra `False`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\"z\" in \"banane\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essayons une combinaison `if-elif-else` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "mot = \"complémentaires\"\n",
    "if \"a\" in mot:\n",
    "    print(mot + \" contient la lettre a et s\")\n",
    "elif \"s\" in mot:\n",
    "    print(mot + \" containt la lettre s\")\n",
    "else:\n",
    "    print(\"Mais où avez-vous trouvé ce mot !?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exerçons un peu nos nouvelles compétences. Écrivez un petit programme qui définit une variable `poids`. Si le poids est plus grand que 50 kg, affichez \"Il y a des frais de 25 € pour les colis lourds.\" Si ce n'est pas le cas, affichez: \"Merci pour votre commande. Les frais de port sont gratuits.\" Changez la valeur du poids pour voir les deux résultats. (Astuce: utilisez les opérateurs `<` ou `>`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant, nous avons deux autres situations :\n",
    "- Afficher \"Il y a des frais de 50€ pour des colis très lourds\" pour les objets de plus de 100 kg\n",
    "- Afficher \"Les frais sont de 10€\" pour les objets de plus de 5kgs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Et, ou, non (`and, or, not`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jusqu'à présent, nos conditions étaient conçues de conditions uniques. Cependant, très souvent, nous devrons tester plusieurs conditions et ensuite exécuter un bloc particulier. Python fournit un certain nombre de façons de le faire. Le premier est avec l'instruction `and`. `and` nous permet de juxtaposer deux expressions qui doivent être vraies afin de rendre l'expression entière évaluée à `True`. Voyons voir comment cela fonctionne:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "mot = \"banane\"\n",
    "if \"a\" in mot and \"b\" in mot:\n",
    "    print(\"a et b sont dans \" + mot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si l'une des expressions est évaluée à `False`, rien ne sera affiché:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "if \"a\" in mot and \"z\" in mot:\n",
    "    print(\"a et w sont dans \" + mot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remplacez `and` avec `or` dans l'expression `if` ci-dessous. Que se passe-t-il ? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "mot = \"banane\"\n",
    "if \"a\" in mot and \"z\" in mot:\n",
    "    print(\"a et/ou z sont dans \" + mot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans le bloc de code ci-dessous, pouvez-vous ajouter une instruction `else` qui affiche qu'aucune des lettres n'a été trouvée?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "mot = 'strike'\n",
    "if \"a\" in mot and \"z\" in mot:\n",
    "    print(\"A et z sont dans \" + mot)\n",
    "elif \"a\" in mot or \"z\" in mot:\n",
    "    print(\"a ou z sont dans \" + mot)\n",
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enfin, nous pouvons utiliser `not` pour tester les conditions qui ne sont pas vraies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "if \"z\" not in mot:\n",
    "    print(\"z n'est pas dans \" + mot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les objets, tels que les chaînes ou les entiers ou les listes sont `True`, car ils existent. \n",
    "\n",
    "Mais, les chaînes, les listes, les dictionnaires, etc. vides sont `False`, car d'une certaine manière ils n'existent pas. Nous pouvons utiliser ce principe pour - par exemple - seulement exécuter un morceau de code si une liste contient des valeurs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nombres = [1, 2, 3, 4]\n",
    "if nombres:\n",
    "    print(\"J'ai trouvé une liste pleine !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant, si la liste était vide, cela reviendrait donc à `False`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nombres = []\n",
    "if nombres:\n",
    "    print(\"J'ai trouvé une liste pleine !\")\n",
    "else:\n",
    "    print('Rien du tout')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pouvez-vous écrire un bloc qui affiche \"C'est une liste vide\" si la liste fournie ne contient rien ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nombres = []\n",
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pouvez-vous faire la même chose mais cette fois-ci avec `len()`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nombres = []\n",
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ce que l'on a appris"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "-  conditions\n",
    "-  indentation\n",
    "-  `if`\n",
    "-  `elif`\n",
    "-  `else`\n",
    "-  `True`\n",
    "-  `False`\n",
    "-  les objets vides sont `False`\n",
    "-  `not`\n",
    "-  `in`\n",
    "-  `and`\n",
    "-  `or`\n",
    "-  conditions multiples\n",
    "-  `==`\n",
    "-  `<`\n",
    "-  `>`\n",
    "-  `!=`\n",
    "-  `KeyError`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les Boucles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La programmation est très utile quand nous pouvons effectuer une même action sur un ensemble d'éléments différents. Par exemple, étant donné une liste de mots, nous aimerions connaître la longueur de tous les mots, pas seulement un. Vous  pouvez bien sûr le faire en parcourant tous les index d'une liste de mots et en imprimant la longueur des mots un à la fois, en prenant autant de lignes de code que vous avez d'index. Inutile de dire que c'est plutôt long et désagréable. Et vous devez connaître le nombre de mots.\n",
    "\n",
    "Python fournit la déclaration `for` qui nous permet d'itérer à travers n'importe quel objet itératif et effectuer des actions sur ses éléments. Le format de base d'une déclaration `for` est:\n",
    "\n",
    "`for x in iterable:`\n",
    "\n",
    "Cela se traduit en français par \"pour chaque élément - que l'on stockera dans x - trouvable dans la variable iterable\". Par exemple, pour imprimer les lettres de bananes une à une:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for lettre in \"banane\":\n",
    "    print(lettre)\n",
    "    \n",
    "    \n",
    "print(lettre)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le code dans la boucle est exécuté autant de fois qu'il y a de lettres, avec une valeur différente pour la variable `lettre` à chaque itération. Relisez la phrase précédente autant de fois que nécessaire, prenez votre temps. N'hésitez pas à poser des questions à ce moment-là.\n",
    "\n",
    "De même, nous pouvons afficher tous les éléments qui sont contenus dans une liste:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "couleurs = [\"jaune\", \"rouge\", \"vert\", \"bleu\", \"violet\"]\n",
    "for nimportequoi in couleurs:\n",
    "    print(\"C'est la couleur \" + nimportequoi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puisque les dictionnaires sont des objets itératifs, nous pouvons aussi parcourir notre collection de bonnes lectures. Cela va parcourir les *clés* d'un dictionnaire:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for livre in bonnes_lectures:\n",
    "    print(livre)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous pouvons également parcourir à la fois les clés et les valeurs d'un dictionnaire, ceci se fait comme cela :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "bonnes_lectures.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for livre, note in bonnes_lectures.items():\n",
    "    print(livre + \" a une note de \" + str(note))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'utilisation de `items()` va, à chaque itération, retourner un `tuple` clé-valeur. Dans l'exemple ci-dessus, la variable `livre` boucle sur les clés du dictionnaire, et la variable `note` boucle sur les valeurs.\n",
    "\n",
    "Cette manière est la manière la plus élégante de boucler sur des dictionnaires, mais essayez de voir si vous comprenez également l'alternative suivante:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for livre in bonnes_lectures:\n",
    "    print(livre + \" a une note de \" + str(bonnes_lectures[livre]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bonus : caster en chaîne"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exécutez le bloc suivant:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "livre = \"Voyage au bout de la nuit\"\n",
    "print(livre + \" a une note de \" + bonnes_lectures[livre])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous avez une `TypeError` : Python vous dit que, en somme, il n'est pas capable de convertir le nombre entier en chaîne, et que, du coup, il ne peut pas additionner un nombre et une chaîne. C'est pour cela que plus haut, nous devions utiliser `str()` qui type automatiquement un objet en chaîne.\n",
    "\n",
    "Prenez le temps et essayez de comprendre les blocs suivants:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "entier = 1\n",
    "chaine = \"1\"\n",
    "print(int(chaine) + entier)\n",
    "print(chaine + str(entier))\n",
    "\n",
    "print(type(entier))\n",
    "print(type(chaine))\n",
    "print(type(int(chaine) + entier))\n",
    "print(type(chaine + str(entier)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction `len()` retourne la longueur d'un objet itérable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "len(\"banane\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous pouvons utiliser cette fonction pour afficher la longueur de chaque mot dans la liste des couleurs. Écrivez votre code dans la case ci-dessous:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "couleurs = [\"jaune\", \"rouge\", \"vert\", \"bleu\", \"violet\"]\n",
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant, écrivez un petit programme qui boucle sur la liste `couleurs` et qui ajoute les couleurs qui contiennent la lettre r dans l'autre liste `couleurs_avec_un_r`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "couleurs = [\"jaune\", \"rouge\", \"vert\", \"bleu\", \"violet\"]\n",
    "couleurs_avec_un_r = []\n",
    "# Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ce que l'on a appris"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "- les boucles\n",
    "- `for`\n",
    "- les objets iterables / itératifs\n",
    "- l'assignation de variables dans une boucle `for`\n",
    "- typer/caster des valeurs\n",
    "- `TypeError`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice de fin de chapitre"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous avons vu beaucoup de choses. Il est maintenant temps de mettre tout ce que nous avons appris à l'épreuve. L'exercice suivant pourrait être assez difficile, mais vous avez les moyens de le faire!\n",
    "\n",
    "Ce que nous voulons que vous fassiez, c'est écrire du code qui compte le nombre total de *a* présent dans le texte, en fonction du dictionnaire de fréquence de mot suivant. Vous devez le faire sur la base d'une distribution de fréquence de mots représentée par un dictionnaire. Dans ce dictionnaire `distribution`, les clés sont des mots et les valeurs sont les fréquences. Affectez votre décompte de `a` à la variable `nombre_de_a`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "distribution = {'1821': 1, '2006': 1, 'Depuis': 1, 'Enseignement': 1, 'Fondée': 1, \n",
    "'L': 1, 'Recherche': 1, 'Technologies': 1, 'a': 1, 'appliquées': 1, \n",
    "'aux': 1, 'chartes': 2, 'd': 1, 'dans': 1, 'de': 3, 'des': 2, 'du': 1, \n",
    "'en': 1, 'est': 2, 'et': 2, 'fondamentales': 1, 'formant': 1, 'formation': 1, \n",
    "'française': 1, 'grand': 1, 'grande': 1, 'histoire': 2, 'intitulé': 1, 'l': 6, \n",
    "'la': 3, 'le': 1, 'master': 1, 'ministère': 1, 'nationale': 2, 'numériques': 1, \n",
    "'ouvert': 1, 'par': 1, 'placée': 1, 'possède': 1, 'promotion': 1, 'sciences': 1, \n",
    "'sous': 1, 'spécialisée': 1, 'statut': 1, 'supérieur': 1, 'tutelle': 1, 'un': 1, \n",
    "'une': 2, 'vingtaine': 1, '«': 1, '»': 1, 'École': 3, 'Éducation': 1, 'à': 1, 'école': 1, \n",
    "'établissement': 1, 'étudiants': 1}\n",
    "\n",
    "nombre_de_a = 0\n",
    "# On code ici\n",
    "\n",
    "\n",
    "# Ce code vérifie\n",
    "if nombre_de_a == 30:\n",
    "    print('Bien joué!')\n",
    "else:\n",
    "    print('La réponse est incorrecte, essaye encore!')"
   ]
  },
  {
   "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": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}