Leçon 1 - Introduction à Jupyter Notebook et à la programmation en Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# _Leçon 1_: Introduction à Jupyter Notebook et à la programmation en Python\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <b>A la fin de la formation, vous pourrez:</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Téléchargez et installez Anaconda avec Jupyter Notebook.</li>\n",
    "        <li>Ouvrir votre premier document Jupyter Notebook.</li>\n",
    "        <li>Apprendre le contrôle des versions et la gestion du code avec Git et GitHub.</li>\n",
    "        <li>Ecrire votre première ligne de code.</li>\n",
    "        <li>Apprendre et appliquer les variables, types et opérateurs Python de base.</li>\n",
    "        <li>Employer les variables, les types et les opérateurs dans des boucles et des conditions pour effectuer des tâches simples.</li>\n",
    "        <li>Capturer et répondre efficacement aux exceptions.</li>\n",
    "        <li>Utiliser des ensembles pour extraire des données uniques des listes.</li>\n",
    "        <li>Développer et utiliser du code réutilisable en encapsulant les tâches dans des fonctions.</li>\n",
    "        <li>Rassembler les fonctions en classes flexibles et extensibles.</li>\n",
    "    </ul>\n",
    "</div>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.1 Installation d'un ordinateur portable Python et Jupyter avec Anaconda\n",
    "\n",
    "![Vue d'ensemble de Jupyter](images/jupyter-overview.jpg)\n",
    "\n",
    "Anaconda est une suite de progiciels de sciences des données populaires pour Python et comprend Jupyter Notebook qui est un carnet interactif vous permettant de créer et de partager des documents contenant du code vivant. Il s'agit d'un Jupyter Notebook et vous pourrez suivre l'apprentissage au fur et à mesure.\n",
    "\n",
    "Notre premier objectif est d'installer Anaconda et de créer un Jupyter Notebook afin que vous puissiez démarrer ce tutoriel. Si vous voulez l'essayer dans un navigateur (y compris son propre tutoriel), alors [suivez ce lien](https://jupyter.org/try).\n",
    "\n",
    "Pour installer Anaconda, et tous les paquets Python afin que vous puissiez travailler sur votre propre ordinateur:\n",
    "\n",
    "- Allez à la [page de téléchargement sur Anaconda](https://www.anaconda.com/download/);\n",
    "\n",
    "![Télécharger Anaconda](images/anaconda-1.jpg)\n",
    "\n",
    "- Choisissez la version **Python 3.x** pour l'installation. Choisissez le paquet approprié pour votre ordinateur (Windows, MacOS ou Linux). Si vous êtes sous Windows, vous devrez également choisir entre 64 bits ou 32 bits. La plupart des ordinateurs supportent actuellement le 64 bits mais, si vous n'êtes pas sûr, choisissez la version 32 bits.\n",
    "\n",
    "- Après le téléchargement, exécutez le logiciel et installez tous les paramètres par défaut.\n",
    "\n",
    "- Vous verrez que vous avez la possibilité de lancer Anaconda, ou Jupyter Notebook. Pour l'instant, nous allons passer directement à Jupyter Notebook.\n",
    "\n",
    "- La première page qui s'ouvre dans la vue du dossier (ou de l'arbre) de Jupyter Notebook. Ici, vous pouvez voir une liste de fichiers. Les Jupyter Notebooks se terminent par l'extension \".ipynb\".\n",
    "\n",
    "![Vue de l'arbre de Jupyter Notebook](images/jupyter-01.png)\n",
    "\n",
    "- Créez un nouveau bloc-notes en cliquant sur \"New\" et sélectionnez \"Python 3\" comme noyau que vous souhaitez exécuter.\n",
    "\n",
    "![Jupyter Notebook créer de nouvelles](images/jupyter-02.png)\n",
    "\n",
    "- C'est un nouveau carnet et c'est ce que vous devriez voir :\n",
    "\n",
    "![Jupyter Notebook](images/jupyter-04.png)\n",
    "\n",
    "- Vous pouvez faire un tour de l'interface du portable à partir de \"Aide -> Tour de l'interface utilisateur\", ou vous pouvez apprendre quelques raccourcis à partir de \"Aide -> Raccourcis clavier\".\n",
    "\n",
    "![Raccourcis clavier Jupyter Notebook](images/jupyter-03.png)\n",
    "\n",
    "Vous devrez lancer Jupyter Notebooks chaque fois que vous voudrez travailler sur ces tutoriels. N'oubliez pas d'enregistrer vos fichiers `.ipynb` où vous pourrez les trouver facilement. Vous pouvez également télécharger tous les carnets à partir de ce dépôt et, si vous les exécutez dans Jupyter Notebook, vous pouvez exécuter le code ici, ou cliquer sur le texte pour voir comment la version MarkDown du HTML est écrite pour coder ce texte.\n",
    "\n",
    "Dans la section suivante, vous apprendrez comment cloner ce dépôt.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Références:</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li><a href=\"https://www.anaconda.com/\">Anaconda</a></li>\n",
    "        <li><a href=\"https://jupyter.org/\">Project Jupyter</a></li>\n",
    "        <li><a href=\"https://docs.conda.io/projects/conda/en/4.6.0/_downloads/52a95608c49671267e40c689e0bc00ca/conda-cheatsheet.pdf\">Conda Cheatsheet</a></li>\n",
    "    </ul>\n",
    "</div>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 Contrôle des versions et gestion des codes avec Git et GitHub\n",
    "\n",
    "Le tutoriel suivant est adapté [du tutoriel \"Hello World\" de GitHub](https://guides.github.com/activities/hello-world/) et de leur manuel [\"Git Handbook\"](https://guides.github.com/introduction/git-handbook/). GitHub est une implémentation particulière de Git. Il se trouve que c'est là que ces leçons sont hébergées, mais vous pouvez utiliser tout autre service, tel que [GitLab](https://about.gitlab.com/), [Bitbucket](https://bitbucket.org/) ou même le vénérable [SourceForge](https://sourceforge.net/).\n",
    "\n",
    "[Git](https://git-scm.com/) est un système de contrôle de version distribué, libre et gratuit, conçu pour gérer tout type de projet, du plus petit au plus grand, avec rapidité et efficacité. Les systèmes de contrôle de version suivent l'historique des changements au fur et à mesure que les personnes et les équipes collaborent sur les projets. Au fur et à mesure de l'évolution du projet, les équipes peuvent effectuer des tests, corriger des bugs et contribuer au nouveau code avec la certitude que toute version peut être récupérée à tout moment. \n",
    "\n",
    "Les développeurs peuvent consulter l'historique du projet pour savoir :\n",
    "\n",
    "- Quelles modifications ont été apportées ?\n",
    "- Qui a effectué les changements ?\n",
    "- Quand les modifications ont-elles été apportées ?\n",
    "- Pourquoi les changements étaient-ils nécessaires ?\n",
    "\n",
    "Git lui-même fonctionne en ligne de commande (c'est-à-dire dans une fenêtre de terminal, et en dehors de l'interface graphique plus familière que vous utilisez pour interagir avec le système d'exploitation de votre ordinateur). Il y a de nombreuses commandes à apprendre, mais nous ne passerons en revue que le sous-ensemble le plus basique dont vous avez besoin pour l'instant. Git dispose d'une [série de vidéos de base](https://git-scm.com/video/get-going) que vous pouvez suivre pour en savoir plus.\n",
    "\n",
    "Un _repository_, ou projet Git, englobe l'ensemble des fichiers et des dossiers associés à un projet, ainsi que l'historique des révisions de chaque fichier. L'historique des fichiers apparaît sous la forme d'instantanés dans le temps appelés _commits_, et les commits existent sous la forme d'une relation de liste liée, et peuvent être organisés en plusieurs lignes de développement appelées _branches_. Comme Git est un système de contrôle de version distribué, les dépôts sont des unités autonomes et toute personne possédant une copie du dépôt peut accéder à l'ensemble de la base de code et à son historique. En utilisant la ligne de commande ou d'autres interfaces faciles d'utilisation, un dépôt git permet également : l'interaction avec l'historique, le clonage, la création de branches, le commit, la fusion, la comparaison des changements entre les versions du code, et plus encore.\n",
    "\n",
    "Travailler dans des dépôts permet de garder les projets de développement organisés et protégés. Les développeurs sont encouragés à corriger les bugs ou à créer de nouvelles fonctionnalités, sans craindre de faire dérailler les efforts de développement de la ligne principale. Git facilite cela grâce à l'utilisation de branches thématiques : des pointeurs vers des engagements dans l'histoire qui peuvent être facilement créés et dépréciés lorsqu'ils ne sont plus nécessaires.\n",
    "\n",
    "Grâce à des plateformes comme GitHub, Git offre également davantage de possibilités de transparence et de collaboration sur les projets. Les dépôts publics aident les équipes à travailler ensemble pour construire le meilleur produit final possible.\n",
    "\n",
    "Cette leçon, par exemple, existe dans un dépôt GitHub public et open-source avec contrôle de version Git.\n",
    "\n",
    "[GitHub](https://github.com) est un dépôt d'hébergement Git qui fournit aux développeurs des outils pour améliorer le code grâce à des fonctionnalités en ligne de commande, de gestion de problèmes (discussions en fil de discussion), des demandes d'extraction et la révision du code. Vous pouvez en savoir plus sur [GitHub's _flow_ ici](https://guides.github.com/introduction/flow/).\n",
    "\n",
    "Pour compléter la partie suivante de ce tutoriel, vous aurez besoin d'un compte [GitHub.com](http://github.com/) et d'un accès à Internet. Vous n'avez pas besoin de savoir comment coder, utiliser la ligne de commande ou installer Git.\n",
    "\n",
    "![Créer un compte GitHub](images/01-02-01-github-create-account.jpg)\n",
    "\n",
    "### Créer un dépôt de tutoriels\n",
    "\n",
    "Un _repository_ est généralement utilisé pour organiser un seul projet. Les dépôts peuvent contenir des dossiers et des fichiers, des images, des vidéos, des feuilles de calcul et des ensembles de données - tout ce dont votre projet a besoin. Nous vous recommandons d'inclure un README, ou un fichier contenant des informations sur votre projet. GitHub permet d'en ajouter un facilement en même temps que vous créez votre nouveau dépôt. Il offre également d'autres options courantes telles qu'un fichier de licence.\n",
    "\n",
    "Votre dépôt \"hello-world\" peut être un endroit où vous stockez des idées, des ressources, ou même où vous partagez et discutez avec d'autres. Vous pouvez l'appeler comme vous voulez, mais vous aurez besoin d'un dépôt pour cette leçon et les tutoriels suivants. Profitons-en pour créer un premier dépôt. Vous pouvez l'appeler par exemple \"cours sur la préparation de données\".\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "    <b>Pour les comptes GitHub gratuits, tout ce que vous faites est public. Ne stockez pas d'informations personnelles importantes, et n'exprimez pas de comportements qui pourraient vous embarrasser ou mettre votre sécurité en danger.</b>\n",
    "</div>\n",
    "\n",
    "Pour créer un nouveau dépôt, vous devez avoir créé votre compte GitHub. Ensuite, vous devez vous connecter à votre compte GitHub : \n",
    "\n",
    "- Dans le coin supérieur droit, à côté de votre avatar ou identicon, cliquez sur __+__ puis sélectionnez __Nouveau dépôt__.\n",
    "- Donnez à votre dépôt le nom de `data-wrangling-course` (ou tout autre nom que vous préférez).\n",
    "- Rédigez une brève description.\n",
    "- Sélectionnez __Initialisez ce dépôt avec un LISEZ-MOI__.\n",
    "\n",
    "![Créer un nouveau dépôt](images/github-create-new-repo.png)\n",
    "\n",
    "- Cliquez sur __Create repository__.\n",
    "\n",
    "### Créer une branche\n",
    "\n",
    "La _Branching_ est la façon de travailler sur différentes versions d'un dépôt à la fois.\n",
    "\n",
    "Par défaut, votre dépôt possède une branche nommée `master` qui est considérée comme la branche définitive. Nous utilisons les branches pour expérimenter et faire des modifications avant de les livrer à `master`.\n",
    "\n",
    "Lorsque vous créez une branche à partir de la branche `master`, vous faites une copie, ou un instantané, de `master` tel qu'il était à ce moment là. Si quelqu'un d'autre apportait des modifications à la branche `master` pendant que vous travaillez sur votre branche, vous pouviez faire ces mises à jour.\n",
    "\n",
    "Ce diagramme montre :\n",
    "\n",
    "- La branche `master`\n",
    "- Une nouvelle branche appelée `feature` (parce que nous faisons du 'feature work' sur cette branche)\n",
    "- Le voyage qu'effectue la branche `feature` avant de se fondre dans le `master`.\n",
    "\n",
    "![Branching](images/github-branching.png)\n",
    "\n",
    "Avez-vous déjà enregistré différentes versions d'un fichier ? Quelque chose comme :\n",
    "\n",
    "- `story.txt`\n",
    "- `story-joe-edit.txt`\n",
    "- `story-joe-edit-reviewed.txt`\n",
    "\n",
    "Les branches accomplissent des objectifs similaires dans les dépôts GitHub.\n",
    "\n",
    "Sur GitHub, les développeurs, les rédacteurs et les concepteurs utilisent les branches pour garder les corrections de bugs et le travail sur les fonctionnalités séparés de la branche master (production). Lorsqu'une modification est prête, ils fusionnent leur branche avec la branche master.\n",
    "\n",
    "Pour créer une nouvelle branche :\n",
    "\n",
    "- Allez à votre nouveau dépôt `data-wrangling-course`.\n",
    "- Cliquez sur le menu déroulant en haut de la liste des fichiers qui indique __branche : master__.\n",
    "- Tapez un nom de branche, `readme-edits`, dans la boîte de texte de la nouvelle branche.\n",
    "- Sélectionnez la case bleue __Create branch__ ou appuyez sur _Enter_ sur votre clavier.\n",
    "\n",
    "![Nouvelle branche](images/github-readme-edits.gif)\n",
    "\n",
    "Vous avez maintenant deux branches, `master` et `readme-edits`. Elles sont exactement les mêmes, mais pas pour longtemps ! Ensuite, nous allons ajouter nos changements à la nouvelle branche.\n",
    "\n",
    "### Faites et validez les changements\n",
    "\n",
    "Maintenant, vous êtes sur la vue du code de votre branche `readme-edits`, qui est une copie de `master`. Faisons quelques modifications.\n",
    "\n",
    "Sur GitHub, les changements sauvegardés sont appelés _commits_. Chaque commit a un _commit message_ associé, qui est une description expliquant pourquoi un changement particulier a été fait. Les messages de commit capturent l'historique de vos changements, afin que les autres contributeurs puissent comprendre ce que vous avez fait et pourquoi.\n",
    "\n",
    "Effectuez et validez des changements :\n",
    "\n",
    "- Cliquez sur le fichier `README.md`.\n",
    "- Cliquez sur l'icône représentant un crayon dans le coin supérieur droit de la vue du fichier à modifier.\n",
    "- Dans l'éditeur, écrivez un peu sur vous-même.\n",
    "- Rédigez un message de validation qui décrit vos modifications.\n",
    "- Cliquez sur le bouton __Commit changes__.\n",
    "\n",
    "![Commit](images/github-commit.png)\n",
    "\n",
    "Ces changements seront apportés au fichier `README` sur votre branche `readme-edits`, donc maintenant cette branche contient un contenu différent de `master`.\n",
    "\n",
    "### Ouvrir une demande de fusion (pull request)\n",
    "\n",
    "Maintenant que vous avez des changements dans une branche de `master`, vous pouvez ouvrir une _pull request_.\n",
    "\n",
    "Les Pull Requests sont le coeur de la collaboration sur GitHub. Lorsque vous ouvrez une _pull request_, vous proposez vos changements et vous demandez à quelqu'un de revoir et de tirer votre contribution et de les fusionner dans sa branche. Les pull request montrent les _diffs_, ou différences, du contenu des deux branches. Les modifications, ajouts et soustractions sont indiqués en vert et en rouge.\n",
    "\n",
    "Dès que vous faites un commit, vous pouvez ouvrir une pull request et lancer une discussion, avant même que le code ne soit terminé.\n",
    "\n",
    "En utilisant le système @mention de GitHub dans votre message de pull request, vous pouvez demander un retour d'information à des personnes ou des équipes spécifiques, qu'elles soient au bout du couloir ou à dix fuseaux horaires de distance.\n",
    "\n",
    "Vous pouvez même ouvrir des pull request dans votre propre dépôt et les fusionner vous-même. C'est un excellent moyen d'apprendre le fonctionnement du GitHub avant de travailler sur des projets plus importants.\n",
    "\n",
    "__Ouvrez une demande de modification du fichier README:__.\n",
    "\n",
    "| __Step__ | __Screenshot__                   |\n",
    "|:------------|:-------------------------|\n",
    "| Cliquez sur l'onglet __Pull Request__, puis à partir de la page Pull Requet, cliquez sur le bouton vert __New Pull Request__.  | ![Onglet Demande d'extraction](images/github-pr-tab.gif) |\n",
    "| Dans la case __Example Comparisons__, sélectionnez la branche que vous avez créée, `readme-edits`, pour la comparer avec `master` (l'original). | ![Pick Branch](images/github-pick-branch.png) |\n",
    "| Regardez vos changements dans les différences sur la page Comparaison, assurez-vous qu'ils correspondent à ce que vous voulez soumettre. | ![Diff](images/github-diff.png) |\n",
    "| Lorsque vous êtes convaincu que ce sont les changements que vous voulez soumettre, cliquez sur le gros bouton vert __Create Pull Request__. | ![Create Pull Request](images/github-create-pr.png) |\n",
    "| Donnez un titre à votre demande de tirage et rédigez une brève description de vos changements. | ![Formulaire de demande d'extraction](images/github-pr-form.png) |\n",
    "\n",
    "Lorsque vous avez terminé votre message, cliquez sur __Create pull request!__\n",
    "\n",
    "### Fusionnez vos changements\n",
    "\n",
    "Lors de cette dernière étape, il est temps de rassembler vos changements - en fusionnant votre branche `readme-edits` avec la branche `master`.\n",
    "\n",
    "- Cliquez sur le bouton vert __Merge pull request__ pour fusionner les modifications dans la branche master.\n",
    "- Cliquez sur __Confirm Merge__.\n",
    "- Continuez et supprimez la branche, puisque ses modifications ont été incorporées, avec le bouton __Delete Branch__ dans la case violette.\n",
    "\n",
    "![Merge](images/github-merge-button.png)\n",
    "\n",
    "![Delete](images/github-delete-button.png)\n",
    "\n",
    "Et cela complète le tutoriel GitHub. Voici ce que vous avez fait :\n",
    "\n",
    "- Création d'un dépôt open source\n",
    "- Création et gestion d'une nouvelle branche\n",
    "- Modification d'un fichier et commit de ces modifications sur GitHub\n",
    "- Ouverture et fusion d'une demande d'intégration (pull request)\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    <p><b>Exercice:</b></p>\n",
    "    <p><a href=\"https://desktop.github.com/\">GitHub dispose d'une application de bureau</a> que vous pouvez utiliser pour gérer vos dépôts et votre code directement depuis votre ordinateur. Elle est dotée d'une interface utilisateur facile à utiliser et facilitera le clonage, l'édition, l'insertion et l'extraction de modifications dans vos dépôts.\n",
    "    <p>Pour cet exercice:</p>\n",
    "    <ul>\n",
    "        <li><a href=\"https://help.github.com/en/desktop/getting-started-with-github-desktop\">Etudier <b>le tutoriel de 'application de bureau de GitHub</b> par vous-même.</a></li>\n",
    "        <li><a href=\"https://desktop.github.com/\">Installer l'application.</a></li>\n",
    "        <li>Vous n'êtes pas obligé, mais il vous sera peut-être plus facile de <a href=\"https://notepad-plus-plus.org/downloads/\">installer <b>Notepad++</b></a> pour modifier le code et le texte.</li>\n",
    "        <li>Refaites ce tutoriel GitHub, mais directement via l'application et sur votre propre bureau. Vous pouvez éditer votre fichier `README` dans Notepad++, puis l'enregistrer et pousser vos modifications dans votre dépôt en utilisant l'app.</li>\n",
    "        <li> Vous devez créer un répertoire de codes pour sauvegarder tous vos projets de codes. Il est essentiel d'être très soigné et organisé en ce qui concerne les répertoires de code pour gérer vos dépôts. Prenez-en l'habitude dès maintenant.</li>\n",
    "    </ul>\n",
    "</div>\n",
    "\n",
    "Dans la section suivante, vous commencerez à apprendre à coder en Python.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Tutoriels et références:</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li><a href=\"https://guides.github.com/activities/hello-world/\">GitHub's 'Hello World' tutorial</a></li>\n",
    "        <li><a href=\"https://git-scm.com/video/get-going/\">Git Basics Get Going</a></li>\n",
    "        <li><a href=\"http://guides.github.com/\">GitHub Guides</a></li>\n",
    "        <li><a href=\"http://youtube.com/githubguides\">GitHub YouTube channel</a></li>\n",
    "        <li><a href=\"https://desktop.github.com/\">GitHub Desktop App</a></li>\n",
    "    </ul>\n",
    "</div>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 Les bases du python\n",
    "\n",
    "Python est un langage interprété avec une syntaxe très simple. La première étape dans l'apprentissage de tout nouveau langage est de coder une application qui ne fera qu'écrire \"Bonjour, le monde !\".\n",
    "\n",
    "Vous aurez ouvert un nouveau carnet dans __Jupyter Notebook__ :\n",
    "\n",
    "![Jupyter Notebook](images/jupyter-04.png)\n",
    "\n",
    "Vous devez enregistrer ce cahier dans un dossier dédié à vos tutoriels pour ce cours. Donnez-lui un nom, comme `Tutoriel de codage Python 1`, ou tout ce qui vous convient. Vous pourriez vous retrouver avec une arborescence de répertoires qui ressemble à celle-ci :\n",
    "\n",
    "    documents/github-code/data-wrangling-course/\n",
    "\n",
    "Notez deux choses :\n",
    "\n",
    "- L'élément de menu déroulant qui dit `code`\n",
    "- La disposition de la zone de saisie de texte en dessous (qui commence par `Dans []:`)\n",
    "\n",
    "Ceci précise que ce bloc doit être utilisé pour le code. Vous pouvez également l'utiliser pour des blocs de texte structurés comme celui-ci en sélectionnant `markdown` dans la liste de menu. Ce tutoriel n'enseignera pas la `markdown`, mais vous pouvez en apprendre davantage [ici](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).\n",
    "\n",
    "Le tutoriel qui suit est similaire à [Learn Python's](https://www.learnpython.org/), bien qu'ici vous pourrez utiliser les exemples sur votre propre ordinateur.\n",
    "\n",
    "### Bonjour, le monde !\n",
    "\n",
    "Pour l'instant, commençons par \"Bonjour, le monde !\".\n",
    "\n",
    "Tapez le texte ci-dessous dans le bloc de code de votre ordinateur portable et appuyez sur `Ctrl-Enter` pour exécuter le code :\n",
    "\n",
    "    print(\"Bonjour, le monde !\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bonjour, le monde !\n"
     ]
    }
   ],
   "source": [
    "print(\"Bonjour, le monde !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous venez de lancer votre premier programme. Voyez comment Jupyter effectue pour vous la surbrillance de code, en changeant les couleurs du texte selon la nature de la syntaxe utilisée. Le terme `print` est un terme protégé et est mis en évidence en vert.\n",
    "\n",
    "Cela montre également à quel point Jupyter Notebook peut être utile. Vous pouvez le traiter comme un document, en enregistrant le fichier et en stockant les résultats de votre programme dans le notebook. Vous pouvez même l'envoyer par e-mail à quelqu'un d'autre et, si cette personne a le Jupyter Notebook, elle peut l'utiliser pour voir ce que vous avez fait. Si vous sauvegardez votre travail dans GitHub, vous pouvez partager les liens avec d'autres personnes sur ce cours et obtenir de l'aide ou des conseils si vous êtes bloqué.\n",
    "\n",
    "À partir de maintenant, nous allons simplement passer par le tutoriel de codage Python et apprendre la syntaxe et les méthodes de codage.\n",
    "\n",
    "### Indentation\n",
    "\n",
    "Python utilise l'indentation pour indiquer les parties du code qui doivent être exécutées ensemble. Les tabulations et les espaces (généralement quatre par niveau) sont pris en charge, et ma préférence va aux tabulations. Ceci fait l'objet d'un débat, mais ne vous en faites pas. Quoi que vous décidiez de faire, c'est très bien, mais **ne mélangez en aucun cas l'indentation par tabulation avec l'indentation par espace.**\n",
    "\n",
    "Dans cet exercice, vous allez attribuer une valeur à une variable, vérifier si une comparaison est vraie, puis - en fonction du résultat - imprimer.\n",
    "\n",
    "Tout d'abord, repérez le petit symbole `+` dans la barre de menu juste après le symbole `enregistrer`. Cliquez dessus et vous obtiendrez une nouvelle boîte dans laquelle vous pourrez taper le code suivant. Lorsque vous avez terminé, appuyez sur la touche `Ctrl-Entrée` ou sur le bouton `Exécuter`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x est égal à 1\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "if x == 1:\n",
    "    # Indenté ... et remarquez comment Jupyter Notebook s'est automatiquement indenté pour vous\n",
    "    print(\"x est égal à 1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tout terme de texte non protégé peut être une variable. Votre `x` aurait pu facilement être votre nom. Habituellement, nous donnons aux variables un nom aussi descriptif que possible afin de pouvoir lire les algorithmes comme du texte (c'est-à-dire que le code se décrit lui-même).\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntaxe</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li> Pour attribuer une variable avec une valeur spécifique, utilisez <code>=</code></li>\n",
    "        <li> Pour tester si une variable a une valeur spécifique, utilisez les opérateurs booléens:</li>\n",
    "        <ul>\n",
    "            <li>égalité : <code>==</code></li>\n",
    "            <li>pas égal : <code>!=</code></li>\n",
    "            <li>plus grand que : <code>&gt;</code></li>\n",
    "            <li>moins que : <code>&lt;</code></li>\n",
    "        </ul>\n",
    "        <li>Vous pouvez également ajouter des commentaires utiles à votre code avec le symbole <code>#</code>. Toute ligne commençant par un <code>#</code> n'est pas exécutée. Je trouve très utile de prendre des notes détaillées sur mes réflexions car, souvent, lorsque vous revenez au code plus tard, vous ne vous souvenez pas pourquoi vous avez fait ce que vous avez fait, ou même ce que votre code est censé faire.</li>\n",
    "    </ul>\n",
    "</div>\n",
    "\n",
    "### Variables et types\n",
    "\n",
    "Python n'est pas \"statiquement typé\". Cela signifie que vous n'avez pas à déclarer toutes vos variables avant de pouvoir les utiliser. Vous pouvez créer de nouvelles variables quand vous le souhaitez. Python est également \"orienté objet\", ce qui signifie que chaque variable est un objet. Cela deviendra de plus en plus important au fur et à mesure que vous gagnerez en expérience.\n",
    "\n",
    "Passons en revue les principaux types de variables :\n",
    "\n",
    "#### Nombres\n",
    "\n",
    "Python supporte deux types de nombres : les nombres entiers et les nombres flottants. Les nombres entiers sont des nombres entiers (par exemple 7), tandis que les nombres flottants sont des nombres fractionnaires (par exemple 7.321). Vous pouvez également convertir des entiers en nombres flottants, et vice versa, mais vous devez être conscient des risques que cela comporte.\n",
    "\n",
    "Suivez le code :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "myint = 7\n",
    "print(myint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.0\n",
      "7.0\n"
     ]
    }
   ],
   "source": [
    "myfloat = 7.0\n",
    "print(myfloat)\n",
    "# Ou vous pourriez convertir l'entier que vous avez déjà\n",
    "myfloat = float(myint)\n",
    "# Notez que le terme \"float\" est vert. C'est un terme protégé.\n",
    "print(myfloat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "# Maintenant, voyez ce qui se passe quand vous convertissez un float en un int\n",
    "myint = int(7.3)\n",
    "print(myint)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarquez comment vous avez perdu de la précision lorsque vous avez converti un `float` en un `int` ? Faites toujours attention, car cela pourrait être la différence entre une porte qui s'adapte à son cadre et une porte qui est beaucoup trop petite.\n",
    "\n",
    "#### Chaines de caractères\n",
    "\n",
    "Les chaînes de caractères sont le terme Python pour le texte. Vous pouvez les définir entre guillemets simples ou doubles. Je vais utiliser des guillemets doubles (puisque vous utilisez souvent une seule citation à l'intérieur des phrases de texte).\n",
    "\n",
    "Essayez ces exemples :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bonjour, le monde !\n",
      "'Parlons des apostrophes...'\n"
     ]
    }
   ],
   "source": [
    "mystring = \"Bonjour, le monde !\"\n",
    "print(mystring)\n",
    "# et en montrant comment utiliser une apostrophe dans une chaîne\n",
    "mystring = \"'Parlons des apostrophes...'\"\n",
    "print(mystring)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous pouvez également appliquer des opérateurs simples à vos variables, ou assigner plusieurs variables simultanément."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "Bonjour, le monde !\n",
      "3 4\n"
     ]
    }
   ],
   "source": [
    "one = 1\n",
    "two = 2\n",
    "three = one + two\n",
    "print(three)\n",
    "\n",
    "hello = \"Bonjour,\"\n",
    "world = \"le monde !\"\n",
    "helloworld = hello + \" \" + world\n",
    "print(helloworld)\n",
    "\n",
    "a, b = 3, 4\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notez cependant que le mélange des types de variables pose des problèmes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-11-a2961e4891f2>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mone\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mtwo\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mhello\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "print(one + two + hello)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python lancera une erreur quand vous ferez une erreur comme celle-ci et l'erreur vous donnera autant de détails que possible sur ce qui vient de se passer. C'est extrêmement utile lorsque vous essayez de \"déboguer\" votre code.\n",
    "\n",
    "Dans ce cas, on vous dit (traduction): `TypeError : type(s) d'opérande non pris en charge pour + : 'int' et 'str'`.\n",
    "\n",
    "Et le contexte doit indiquer clairement que vous avez essayé de combiner deux variables entières avec une chaîne.\n",
    "\n",
    "Vous pouvez également combiner des chaînes de caractères avec des caractères de remplacement pour les variables :\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntaxe</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "       <li>Ajouter des variables à une chaîne de caractères avec des 'F-strings', par exemple <code>F\"Variable {x}\"</code> remplacera le <code>{x}</code> dans la chaîne par la valeur de la variable <code>x</code></li>\n",
    "       <li>Les nombres à virgule flottante peuvent échapper à tout contrôle (imaginez que vous incluez un nombre avec 30 décimales dans une chaîne), et vous pouvez formater cela avec <code>F\"Variable {x:10.4f}\"</code> où <code>10</code> est l'espace alloué à la partie entière (utile si vous devez aligner une colonne de nombres ; vous pouvez également laisser cela de côté pour inclure tous les chiffres significatifs) et le <code>.4f</code> est le nombre de décimales après le point. Adaptez le format selon vos besoins.</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable non formatée : 33.33333333333333%\n",
      "Variable formatée : 33.333%\n",
      "Variable formatée en espace :       33.3%\n"
     ]
    }
   ],
   "source": [
    "variable = 1/3 * 100\n",
    "print(F\"Variable non formatée : {variable}%\")\n",
    "print(F\"Variable formatée : {variable:.3f}%\")\n",
    "print(F\"Variable formatée en espace : {variable:10.1f}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Listes\n",
    "\n",
    "`Lists` est une liste ordonnée de tout type de variable. Vous pouvez combiner autant de variables que vous le souhaitez, et elles peuvent même être de plusieurs types. En règle générale, à moins que vous n'ayez une raison particulière de le faire, les listes contiennent des variables d'un seul type.\n",
    "\n",
    "Vous pouvez également itérer sur une liste (utiliser chaque élément d'une liste dans l'ordre).\n",
    "\n",
    "Une liste est placée entre crochets : `[]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "[2, 3]\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "mylist = []\n",
    "mylist.append(1)\n",
    "mylist.append(2)\n",
    "mylist.append(3)\n",
    "# Chaque élément d'une liste peut être abordé directement. \n",
    "# La première adresse dans une liste Python commence à 0\n",
    "print(mylist[0])\n",
    "# Le dernier élément d'une liste Python peut être adressé comme -1. \n",
    "# Ceci est utile lorsque vous ne savez pas quelle sera la longueur de la liste.\n",
    "print(mylist[-1])\n",
    "# Vous pouvez également sélectionner des sous-ensembles de données dans une liste comme celle-ci\n",
    "print(mylist[1:3])\n",
    "\n",
    "# Vous pouvez aussi faire une boucle dans une liste en utilisant une instruction \"for\".\n",
    "# Notez que `x` est une nouvelle variable qui prend la valeur de chaque élément de la liste dans l'ordre.\n",
    "for x in mylist:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si vous essayez d'accéder à un élément d'une liste qui ne s'y trouve pas, vous obtiendrez une erreur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-13-46c3ae90a572>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmylist\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "print(mylist[10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voyons cela avec un exemple un peu plus complexe. Mais d'abord, une nouvelle syntaxe :\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntaxe</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Vérifiez quel type de variable vous avez avec <code>isinstance</code>, par exemple <code>isinstance(x, float)</code> sera <code>True</code> si x est un float</li>\n",
    "        <li>Vous avez déjà vu <code>for</code>, mais vous pouvez obtenir le décompte de boucle en enveloppant votre liste dans le terme <code>enumerate</code>, par exemple <code>for count, x in enumerate(mylist)</code> vous donnera un décompte pour chaque élément de la liste (la variable 'count' contient l'index et x l'élément de la liste a cet index)</li>\n",
    "        <li>Trier une liste par ordre numérique ou alphabétique peut être fait avec <code>sort</code></li>\n",
    "        <li>Pour obtenir le nombre d'éléments dans une liste, il suffit de demander <code>len(list)</code></li>\n",
    "        <li>Si vous voulez compter le nombre de fois qu'une variable particulière apparaît dans une liste, utilisez <code>list.count(x)</code> (où <code>x</code> est la variable qui vous intéresse)</li>\n",
    "    </ul>\n",
    "</div>\n",
    "\n",
    "Essayez-le vous-même."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nombre de noms dans la liste : 10\n",
      "Nombre de noms nettoyés dans la liste : 4\n",
      "1. Eric\n",
      "2. Jessica\n",
      "3. John\n",
      "4. Lois\n"
     ]
    }
   ],
   "source": [
    "# Imaginons que nous ayons une liste de noms non ordonnés qui, d'une manière ou d'une autre, comporte des numéros aléatoires.\n",
    "# Pour cet exercice, nous voulons imprimer la liste alphabétique des noms sans les numéros.\n",
    "# Ce n'est pas la meilleure façon de faire l'exercice, mais cela illustrera tout un tas de techniques.\n",
    "names = [\"John\", 3234, 2342, 3323, \"Eric\", 234, \"Jessica\", 734978234, \"Lois\", 2384]\n",
    "print(F\"Nombre de noms dans la liste : {len(names)}\")\n",
    "# D'abord, débarrassons-nous de tous les entiers bizarres.\n",
    "new_names = []\n",
    "for n in names:\n",
    "    if isinstance(n, str):\n",
    "        # Vérifier si n est une chaîne de caractères\n",
    "        # Et notez que nous sommes maintenant deux fois en retrait dans cette nouvelle composante\n",
    "        new_names.append(n)\n",
    "# Nous ne devrions maintenant avoir que des noms dans la nouvelle liste. Faisons un tri..\n",
    "new_names.sort()\n",
    "print(F\"Nombre de noms nettoyés dans la liste : {len(new_names)}\")\n",
    "# Enfin, imprimons-les.\n",
    "for i, n in enumerate(new_names):\n",
    "    # En utilisant à la fois i et n dans une chaîne de caractères formatée\n",
    "    # Ajout de 1 à i car les listes commencent à 0\n",
    "    print(F\"{i+1}. {n}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionnaires (Dictionnaries)\n",
    "\n",
    "Les dictionnaires sont l'un des types de données les plus utiles et les plus polyvalents en Python. Ils sont similaires aux tableaux, mais se composent de `paires clé:valeur`. Chaque valeur stockée dans un dictionnaire est accessible par sa clé, et la valeur peut être n'importe quel type d'objet (chaîne de caractères, nombre, liste, etc.).\n",
    "\n",
    "Cela vous permet de créer des enregistrements structurés. Les dictionnaires sont placés dans des `{}`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'John': {'Phone': '012 794 794', 'Email': 'john@email.com'}, 'Jill': {'Phone': '012 345 345', 'Email': 'jill@email.com'}, 'Joss': {'Phone': '012 321 321', 'Email': 'joss@email.com'}}\n"
     ]
    }
   ],
   "source": [
    "phonebook = {}\n",
    "phonebook[\"John\"] = {\"Phone\": \"012 794 794\",\n",
    "                     \"Email\": \"john@email.com\"}\n",
    "phonebook[\"Jill\"] = {\"Phone\": \"012 345 345\",\n",
    "                     \"Email\": \"jill@email.com\"}\n",
    "phonebook[\"Joss\"] = {\"Phone\": \"012 321 321\",\n",
    "                     \"Email\": \"joss@email.com\"}\n",
    "print(phonebook)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notez que vous pouvez imbriquer des dictionnaires et des listes. Le tableau ci-dessus vous montre comment vous pouvez ajouter des valeurs à un dictionnaire existant ou créer des dictionnaires avec des valeurs.\n",
    "\n",
    "Vous pouvez itérer sur un dictionnaire tout comme sur une liste, en utilisant le terme  `.items()`. En Python 3, le dictionnaire maintient l'ordre dans lequel les données ont été ajoutées, mais les anciennes versions de Python ne le font pas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le numéro de téléphone de John est le 012 794 794 et leur adresse électronique est john@email.com\n",
      "Le numéro de téléphone de Jill est le 012 345 345 et leur adresse électronique est jill@email.com\n",
      "Le numéro de téléphone de Joss est le 012 321 321 et leur adresse électronique est joss@email.com\n"
     ]
    }
   ],
   "source": [
    "for name, record in phonebook.items():\n",
    "    print(F\"Le numéro de téléphone de {name} est le {record['Phone']} et leur adresse électronique est {record['Email']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous ajoutez de nouveaux enregistrements comme indiqué ci-dessus, et vous supprimez les enregistrements avec `del` ou `pop`. Ils ont chacun un effet différent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le numéro de téléphone de Jill est le 012 345 345 et leur adresse électronique est jill@email.com\n",
      "Le numéro de téléphone de Joss est le 012 321 321 et leur adresse électronique est joss@email.com\n",
      "{'Phone': '012 345 345', 'Email': 'jill@email.com'}\n",
      "Le numéro de téléphone de Joss est le 012 321 321 et leur adresse électronique est joss@email.com\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "'John'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-17-c6500625ef15>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     12\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[1;31m# Si vous essayez de supprimer un enregistrement qui n'est pas dans le dictionnaire, vous obtenez une erreur\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 14\u001b[1;33m \u001b[1;32mdel\u001b[0m \u001b[0mphonebook\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"John\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 'John'"
     ]
    }
   ],
   "source": [
    "# Première `del`\n",
    "del phonebook[\"John\"]\n",
    "for name, record in phonebook.items():\n",
    "    print(F\"Le numéro de téléphone de {name} est le {record['Phone']} et leur adresse électronique est {record['Email']}\")\n",
    "\n",
    "# Pop retourne l'élément, et le supprime\n",
    "jill_record = phonebook.pop(\"Jill\")\n",
    "print(jill_record)\n",
    "for name, record in phonebook.items():\n",
    "    # Vous pouvez voir que seul Joss est encore dans le système\n",
    "    print(F\"Le numéro de téléphone de {name} est le {record['Phone']} et leur adresse électronique est {record['Email']}\")\n",
    "\n",
    "# Si vous essayez de supprimer un enregistrement qui n'est pas dans le dictionnaire, vous obtenez une erreur\n",
    "del phonebook[\"John\"] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une chose à faire est de prendre l'habitude de tester les variables avant de supposer qu'elles présentent les caractéristiques que vous recherchez. Vous pouvez tester un dictionnaire pour voir s'il a un enregistrement, et renvoyer une réponse par défaut s'il n'en a pas.\n",
    "\n",
    "Vous faites cela avec le terme `.get(\"key\", default)`. La réponse par défaut peut être n'importe quoi, y compris une autre variable, ou simplement `True` ou `False`. Si vous laissez le terme `default` vide (c'est-à-dire `.get(\"key\")`), le résultat sera automatiquement `False` s'il n'y a pas d'enregistrement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aucun enregistrement trouvé.\n"
     ]
    }
   ],
   "source": [
    "# True et False sont des termes spéciaux en Python qui vous permettent de définir des tests\n",
    "jill_record = phonebook.get(\"Jill\", False)\n",
    "if jill_record: # c'est-à-dire si vous avez un enregistrement dans l'étape précédente\n",
    "    print(F\"Le numéro de téléphone de Jill est {jill_record['Phone']}, et leur adresse électronique est {jill_record['Email']}\")\n",
    "else: # l'alternative, si \"if\" renvoie False\n",
    "    print(\"Aucun enregistrement trouvé.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opérateurs de base\n",
    "\n",
    "Les opérateurs sont les différents symboles algébriques (tels que `+`, `-`, `*`, `/`, `%`, etc.). Une fois que vous avez appris la syntaxe, la programmation est surtout des mathématiques.\n",
    "\n",
    "#### Opérateurs arithmétiques\n",
    "\n",
    "Comme vous vous en doutez, vous pouvez utiliser les différents opérateurs mathématiques avec les nombres (entiers et flottants)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.5\n",
      "2\n",
      "49\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "number = 1 +2 * 3 / 4.0\n",
    "# Essayez de prédire quelle sera la réponse ... Python suit-il la hiérarchie des opérations d'ordre ?\n",
    "print(number)\n",
    "\n",
    "# Le modulo (%) renvoie le reste entier d'une division\n",
    "remainder = 11 % 3\n",
    "print(remainder)\n",
    "\n",
    "# Deux multiplications sont équivalentes à une opération de puissance\n",
    "squared = 7 ** 2\n",
    "print(squared)\n",
    "cubed = 2 ** 3\n",
    "print(cubed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Liste des opérateurs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 2, 4, 6, 8]\n",
      "[1, 2, 3, 1, 2, 3, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "even_numbers = [2, 4, 6, 8]\n",
    "# Un de mes premiers professeurs à l'école m'a dit : \"Les gens sont bizarres. Les chiffres sont inégaux.\"\n",
    "# Il a aussi dit : \"Cecil John Rhodes mangeait toujours des tas de cacahuètes non décortiquées au parlement du Cap.\"\n",
    "# \"Vous saviez qu'il était au parlement grâce à l'énorme tas de coquilles sur le sol. Il ne portait jamais non plus de chaussettes\".\n",
    "# \"Vous n'oublierez jamais cela.\" Et je n'ai pas oublié. Je ne sais pas si c'est vrai.\n",
    "uneven_numbers = [1, 3, 5, 7]\n",
    "all_numbers = uneven_numbers + even_numbers\n",
    "# Que pensez-vous qu'il va se passer ?\n",
    "print(all_numbers)\n",
    "\n",
    "# Vous pouvez également répéter des séquences de listes\n",
    "print([1, 2 , 3] * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous pouvons rassembler tout cela en un petit projet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_list contient 1 objets\n",
      "y_list contient 1 objets\n",
      "big_list contient 0 objets\n"
     ]
    }
   ],
   "source": [
    "x = object() # Un objet Python générique\n",
    "y = object()\n",
    "\n",
    "# Modifier ce code pour que x_list et y_list aient chacun 10 objets répétitifs\n",
    "# et concat_list est la concaténation de x_list et y_list\n",
    "x_list = [x]\n",
    "y_list = [y]\n",
    "concat_list = []\n",
    "\n",
    "print(F\"x_list contient {len(x_list)} objets\")\n",
    "print(F\"y_list contient {len(y_list)} objets\")\n",
    "print(F\"big_list contient {len(concat_list)} objets\")\n",
    "\n",
    "# Testez vos listes\n",
    "if x_list.count(x) == 10 and y_list.count(y) == 10:\n",
    "    print(\"On y est presque...\")\n",
    "if concat_list.count(x) == 10 and concat_list.count(y) == 10:\n",
    "    print(\"Super !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Opérateurs de strings\n",
    "\n",
    "Vous pouvez faire un nombre surprenant de choses avec des opérateurs sur des strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "Hello Hello Hello Hello Hello Hello Hello Hello Hello Hello \n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-23-92892e606944>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[1;31m# Mais ne vous emportez pas. Tout ne fonctionnera pas.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 10\u001b[1;33m \u001b[0mnohellos\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"Hello \"\u001b[0m \u001b[1;33m/\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     11\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnohellos\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "# Vous avez déjà vu des enchaînements arithmétiques de cordes\n",
    "helloworld = \"Hello,\" + \" \" + \"World!\"\n",
    "print(helloworld)\n",
    "\n",
    "# Vous pouvez également multiplier les chaînes de caractères pour former une séquence répétitive\n",
    "manyhellos = \"Hello \" * 10\n",
    "print(manyhellos)\n",
    "\n",
    "# Mais ne vous emportez pas. Tout ne fonctionnera pas.\n",
    "nohellos = \"Hello \" / 10\n",
    "print(nohellos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il faut garder à l'esprit que les chaînes de caractères sont des listes de caractères. Cela signifie que vous pouvez effectuer un certain nombre d'opérations de liste sur des chaînes de caractères. Et quelques nouvelles opérations.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntaxe</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li> Obtenez l'index de la première occurrence d'une lettre spécifique avec <code>string.index(\"l\")</code> où <code>l</code> est la lettre que vous recherchez</li>\n",
    "        <li>Comme dans les listes, comptez le nombre d'occurrences d'une lettre spécifique avec <code>string.count(\"l\")</code></li>\n",
    "        <li> Obtenir des portions de chaînes avec <code>string[start:end]</code>, par exemple <code>string[3:7]</code>. Si vous n'êtes pas sûr de la fin d'une chaîne, souvenez-vous que vous pouvez utiliser des nombres négatifs pour compter à partir de la fin, par exemple <code>string[:-3]</code> pour obtenir une portoin du premier caractère au troisième à partir de la fin</li>\n",
    "        <li> Vous pouvez également \"passer\" dans une chaîne de caractères avec <code>string[start:stop:step]</code>, par exemple <code>string[2:6:2]</code> qui sautera un caractère entre les caractères 2 et 5 (c'est-à-dire que 6 est la limite)</li>\n",
    "        <li> Vous pouvez utiliser un \"pas\" négatif pour inverser l'ordre des caractères, par exemple <code>string[::-1]</code></li>\n",
    "        <li> Vous pouvez convertir des chaînes de caractères en majuscules ou en minuscules avec <code>string.upper()</code> et <code>string.lower()</code></li>\n",
    "        <li>Tester si une chaîne commence ou se termine par une sous-chaîne avec:</li>\n",
    "        <ul>\n",
    "            <li><code>string.startswith(substring)</code> qui renvoie <code>True</code> ou <code>False</code></li>\n",
    "            <li><code>string.endswith(substring)</code> qui renvoie <code>True</code> ou <code>False</code></li>\n",
    "        </ul>\n",
    "        <li>Utilisez <code>in</code> pour tester si une chaîne contient une sous-chaîne, ainsi <code>substring in string</code> retournera <code>True</code> ou <code>False</code></li>\n",
    "        <li> Vous pouvez diviser une chaîne en une véritable liste avec <code>.split(s)</code> où <code>s</code> est le caractère spécifique à utiliser pour la division, par exemple <code>s = \",\"</code> ou <code>s = \"\"</code>. Vous pouvez voir comment cela peut être utile pour fractionner un texte qui contient des données numériques.</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String length: 13\n",
      "Index for first 'o': 4\n",
      "Count of 'o': 2\n",
      "Slicing between second and fifth characters: llo,\n",
      "Skipping between 3rd and 2nd-from-last characters: l,Wr\n",
      "Reverse text: !dlroW ,olleH\n",
      "Starts with 'Hello': True\n",
      "Ends with 'Hello': False\n",
      "Contains 'Goodbye': False\n",
      "Split the string: ['Hello,', 'World!']\n"
     ]
    }
   ],
   "source": [
    "a_string = \"Hello, World!\"\n",
    "print(F\"String length: {len(a_string)}\")\n",
    "# Vous pouvez obtenir un index de la première occurrence d'une lettre spécifique\n",
    "# Rappelez-vous que les listes Python sont basées sur 0 ; la première lettre est l'index 0\n",
    "# Notez également l'utilisation de guillemets simples à l'intérieur des guillemets doubles\n",
    "print(F\"Index for first 'o': {a_string.index('o')}\")\n",
    "print(F\"Count of 'o': {a_string.count('o')}\")\n",
    "print(F\"Slicing between second and fifth characters: {a_string[2:6]}\")\n",
    "print(F\"Skipping between 3rd and 2nd-from-last characters: {a_string[3:-2:2]}\")\n",
    "print(F\"Reverse text: {a_string[::-1]}\")\n",
    "print(F\"Starts with 'Hello': {a_string.startswith('Hello')}\")\n",
    "print(F\"Ends with 'Hello': {a_string.endswith('Hello')}\")\n",
    "print(F\"Contains 'Goodbye': {'Goodbye' in a_string}\")\n",
    "print(F\"Split the string: {a_string.split(' ')}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditions\n",
    "\n",
    "Dans la section [Indentation](#Indentation), vous avez vu l'instruction `if` et  l'ensemble des opérateurs `boolean` qui vous permettent de tester différentes variables les unes par rapport aux autres.\n",
    "\n",
    "À cette liste d'opérateurs booléens s'ajoute un nouvel ensemble de comparaisons : `and`, `or` et `in`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Des tests booléens simples\n",
    "x = 2\n",
    "print(x == 2)\n",
    "print(x == 3)\n",
    "print(x < 3)\n",
    "\n",
    "# Utilise `and`\n",
    "name = \"John\"\n",
    "print(name == \"John\" and x == 2)\n",
    "\n",
    "# Utilise `or`\n",
    "print(name == \"John\" or name == \"Jill\")\n",
    "\n",
    "# Utilise `in` sur listes\n",
    "print(name in [\"John\", \"Jill\", \"Jess\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ceux-ci peuvent être utilisés pour créer des comparaisons nuancées en utilisant des \"`if`. Vous pouvez utiliser une série de comparaisons avec `if`, `elif` et `else`.\n",
    "\n",
    "N'oubliez pas que le code doit être correctement indenté, sinon vous obtiendrez un comportement inattendu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x > 2\n",
      "x == 2\n"
     ]
    }
   ],
   "source": [
    "# Des résultats inattendus\n",
    "x = 2\n",
    "if x > 2:\n",
    "    print(\"Testing x\")\n",
    "print(\"x > 2\")\n",
    "# Formé correctement\n",
    "if x == 2:\n",
    "    print(\"x == 2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x < 10 or y > 50\n"
     ]
    }
   ],
   "source": [
    "# Démonstration de tests plus complexes\n",
    "x = 2\n",
    "y = 10\n",
    "if x > 2:\n",
    "    print(\"x > 2\")\n",
    "elif x == 2 and y > 50:\n",
    "    print(\"x == 2 and y > 50\")\n",
    "elif x < 10 or y > 50:\n",
    "    # Mais, souvenez-vous, vous ne savez pas QUELLE condition était vraie\n",
    "    print(\"x < 10 or y > 50\")\n",
    "else:\n",
    "    print(\"Rien n'a fonctionné.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deux cas particuliers sont `not` et `is`.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntaxe</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li><code>not</code> est utilisé pour obtenir l'inverse d'un test booléen particulier, par exemple <code>not(False)</code> renvoie <code>True</code></li>\n",
    "        <li><code>is</code> semblerait, superficiellement, être similaire à <code>==</code>, mais il vérifie si les objets réels sont les mêmes, et non si les valeurs que les objets reflètent sont égales.</li>\n",
    "    </ul>\n",
    "</div>\n",
    "\n",
    "Une démonstration rapide."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "John is John: True\n",
      "John is Jill: False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Utilise `not`\n",
    "name_list1 = [\"John\", \"Jill\"]\n",
    "name_list2 = [\"John\", \"Jill\"]\n",
    "print(not(name_list1 == name_list2))\n",
    "\n",
    "# Utilise `is`\n",
    "name2 = \"John\"\n",
    "for n in name_list1:\n",
    "    print(F\"{name2} is {n}: {name2 is n}\")\n",
    "print(name_list1 == name_list2)\n",
    "print(name_list1 is name_list2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boucles\n",
    "\n",
    "Les `boucles` (loops) itèrent sur une séquence donnée, et - ici - il est essentiel de s'assurer que votre indentation est correcte, sinon vous obtiendrez des résultats inattendus pour ce qui est considéré comme étant à l'intérieur ou à l'extérieur de la boucle.\n",
    "\n",
    "Il existe deux types de loop en Python :\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntax</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>les boucles <code>for</code> passent en boucle dans une liste. Il y a également une nouvelle syntaxe à utiliser dans les boucles <code>for</code>:</li>\n",
    "        <ul>\n",
    "            <li>Pour les <a href=\"#Lists\">listes</a> vous avez vu <code>enumerate</code>, ce qui vous permet de compter le nombre de boucles</li>.\n",
    "            <li>Range crée une liste d'entiers sur laquelle on peut faire une boucle, <code>range(start, stop)</code> crée une liste d'entiers entre start et stop, ou <code>range(num)</code> crée une liste de zéros jusqu'à num, ou <code>range(start, stop, step)</code> parcourt une liste par incréments de step</li>\n",
    "        </ul>\n",
    "        <li>Les boucles <code>while</code>, qui s'exécutent alors qu'une condition particulière est <code>True</code>. Et une nouvelle syntaxe pour <code>while</code>:</li>\n",
    "        <ul>\n",
    "            <li><code>while</code> est une déclaration conditionnelle (elle nécessite un test pour retourner <code>True</code>), cela signifie que nous pouvons utiliser <code>else</code> dans une boucle <code>while</code> (mais pas <code>for</code>)</li>\n",
    "        </ul>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. Range 2\n",
      "2. Range 4\n",
      "3. Range 6\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "Fin de la boucle\n"
     ]
    }
   ],
   "source": [
    "# For loops\n",
    "\n",
    "for i, x in enumerate(range(2, 8, 2)):\n",
    "    print(F\"{i+1}. Range {x}\")\n",
    "    \n",
    "# While loops\n",
    "count = 0\n",
    "while count < 5:\n",
    "    print(count)\n",
    "    count += 1 # Une sténographie pour count = count + 1\n",
    "else:\n",
    "    print(\"Fin de la boucle\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Faites bien attention à l'indentation de cette boucle `while`. Que se passerait-il si le `count += 1` était en dehors de la boucle ?\n",
    "\n",
    "Que se passe-t-il si vous devez quitter les boucles plus tôt ou si vous manquez une étape ?\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntaxe</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li><code>break</code> sort d'une boucle <code>while</code> ou <code>for</code> immédiatement</li>\n",
    "        <li><code>continue</code> saute la boucle de courante et revient à la boucle conditionnelle</li>\n",
    "    </ul>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Break et while conditionnelle\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "Continue\n",
      "0\n",
      "2\n",
      "4\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# Break and while conditional\n",
    "print(\"Break et while conditionnelle\")\n",
    "count = 0\n",
    "while True:\n",
    "    # Vous pensez peut-être que ça va durer éternellement, mais...\n",
    "    print(count)\n",
    "    count += 1\n",
    "    if count >= 5:\n",
    "        break\n",
    "\n",
    "# Continue\n",
    "print(\"Continue\")\n",
    "for x in range(8):\n",
    "    # Vérifier si x est irrégulier\n",
    "    if (x+1) % 2 == 0:\n",
    "        continue\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List comprehensions\n",
    "\n",
    "L'une des tâches courantes du codage consiste à parcourir une liste d'éléments, à modifier ou à appliquer une forme d'algorithme et à renvoyer une nouvelle liste.\n",
    "\n",
    "L'écriture de longues portions de code pour accomplir cette tâche est fastidieuse et prend du temps. Les 'list comprehensions' est un moyen efficace et concis d'y parvenir.\n",
    "\n",
    "Par exemple, imaginez une phrase dans laquelle nous voulons compter la longueur de chaque mot, mais sans les \"les\" :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 7, 2, 6, 4, 3, 6, 2, 9, 6, 1, 2, 8, 4, 2, 4, 7, 6, 2, 5, 6, 9, 2, 2, 4, 7, 10]\n",
      "[3, 7, 2, 6, 4, 3, 6, 2, 9, 6, 1, 2, 8, 4, 2, 4, 7, 6, 2, 5, 6, 9, 2, 2, 4, 7, 10]\n"
     ]
    }
   ],
   "source": [
    "sentence = \"car la chanson et l'épée sont des droits de naissance vendus à un usurier, mais je suis le dernier bandit de grand chemin solitaire et je suis le dernier aventurier\"\n",
    "words = sentence.split()\n",
    "word_lengths = []\n",
    "for word in words:\n",
    "      if word not in [\"la\", \"le\"]:\n",
    "            word_lengths.append(len(word))\n",
    "print(word_lengths)\n",
    "\n",
    "# La même chose peut être réalisée avec une liste de compréhension\n",
    "word_lengths = [len(word) for word in sentence.split(\" \") if word not in [\"la\", \"le\"]]\n",
    "print(word_lengths)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Traitement des exceptions\n",
    "\n",
    "Pour le reste de cette section du tutoriel, nous allons nous concentrer sur une syntaxe et une méthodologie plus avancées.\n",
    "\n",
    "Dans [Strings](#Strings), nous vous avons présenté comment l'instruction de concaténer une chaîne avec un entier en utilisant l'opérateur `+` a entraîné une erreur :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-32-c2d1fcd3159a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;34m\"bonjour\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "print(1 + \"bonjour\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, cela est connu comme une `exception`. L'exception particulière ici est une `TypeError`. L'obtention d'exceptions est essentielle au codage, car elle vous permet de corriger les erreurs de syntaxe, de detecter et éviter les petits problèmes lorsque vous passez les mauvaises variables, ou que votre code se comporte de manière inattendue.\n",
    "\n",
    "Cependant, une fois que votre code est mis en production, les erreurs qui arrêtent complètement votre programme sont frustrantes pour l'utilisateur. Le plus souvent, il n'y a aucun moyen d'exclure les erreurs et parfois la seule façon de le savoir est d'essayer et de voir si la fonction provoque une erreur. \n",
    "\n",
    "Beaucoup de ces erreurs sont entièrement attendues. Par exemple, si vous voulez qu'un utilisateur saisisse un nombre entier, vous voulez l'empêcher de taper du texte. Ou - à l'ère du piratage de masse - vous voulez empêcher un utilisateur d'essayer d'inclure son propre code dans un champ de texte.\n",
    "\n",
    "Lorsque cela se produit, vous voulez pouvoir essayer d'exécuter votre code et ensuite détecter les exceptions prévues en toute sécurité.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntaxe</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Tester et récupérer les exceptions avec <code>try</code> et <code>except</code></li>\n",
    "        <li>Capturez des erreurs spécifiques, plutôt que toutes les erreurs, car vous devez toujours être au courant de tout ce qui est inattendu ... sinon vous pouvez passer des heures à essayer de trouver une erreur qui est délibérément ignorée par votre programme.</li>\n",
    "        <li>Chaîne d'exceptions avec, par exemple, <code>exception (IndexError, TypeError):</code>. Voici un lien vers toutes les <a href=\"https://docs.python.org/3/library/exceptions.html\">exceptions courantes</a>.</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "0\n",
      "0\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "# Une \"Erreur d'index\" est lancée lorsque vous essayez d'adresser un index dans une liste qui n'existe pas\n",
    "# Dans cet exemple, nous allons attraper cette erreur et faire autre chose\n",
    "\n",
    "def print_list(l):\n",
    "    \"\"\"\n",
    "    Pour une liste `l` donnée, de longueur inconnue, essayez d'imprimer la première\n",
    "    10 éléments de la liste.\n",
    "    \n",
    "    Si la liste est inférieure à 10, complétez les éléments restants par `0`.\n",
    "    \"\"\"\n",
    "    for i in range(10):\n",
    "        try:\n",
    "            print(l[i])\n",
    "        except IndexError: \n",
    "            print(0)\n",
    "\n",
    "print_list([1,2,3,4,5,6,7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous pouvez également déclencher délibérément une exception avec `raise`. Pour aller plus loin et rédiger vos propres types d'exceptions, consultez [cette explication](https://stackoverflow.com/a/26938914)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Not Zero!",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-34-a5b85de8b30c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mzero\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mprint_zero\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-34-a5b85de8b30c>\u001b[0m in \u001b[0;36mprint_zero\u001b[1;34m(zero)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mprint_zero\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mzero\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mzero\u001b[0m \u001b[1;33m!=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m         \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Not Zero!\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mzero\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: Not Zero!"
     ]
    }
   ],
   "source": [
    "def print_zero(zero):\n",
    "    if zero != 0:\n",
    "        raise ValueError(\"Not Zero!\")\n",
    "    print(zero)\n",
    "\n",
    "print_zero(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sets\n",
    "\n",
    "Les `set` sont des listes sans doublons. Vous pourriez probablement écrire un algorithme de tri, ou un dictionnaire, pour arriver au même résultat, mais les ensembles sont plus rapides et plus souples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'pluie', 'humide', 'et', 'la', 'est'}\n"
     ]
    }
   ],
   "source": [
    "# Extraire tous les termes uniques dans cette phrase\n",
    "\n",
    "print(set(\"la pluie est humide et humide est la pluie\".split()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntaxe</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Créer un ensemble unique de termes avec <code>set</code></li>\n",
    "        <li>Pour obtenir les membres d'un ensemble commun aux deux ensembles, utilisez <code>set1.intersection(set2)</code></li>\n",
    "        <li>Obtenez les membres uniques de chacun des ensembles et des autres, utilisez <code>set1.symmetric_difference(set2)</code></li>\n",
    "        <li>Pour obtenir les membres uniques d'une liste (celle surlaquelle s'applique la fonction .) par rapport à une autre (le paramètre de la fonction), utilisez <code>set1.difference(set2)</code></li>\n",
    "        <li>Pour obtenir tous les membres de chacune des deux listes, utilisez <code>set1.union(set2)</code></li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set One intersection: {'Eve', 'Dan', 'Heidi'}\n",
      "Set Two intersection: {'Eve', 'Dan', 'Heidi'}\n",
      "Set One symmetric difference: {'Alice', 'Carol', 'Grace', 'Bob'}\n",
      "Set Two symmetric difference: {'Alice', 'Carol', 'Grace', 'Bob'}\n",
      "Set One difference: {'Alice', 'Carol'}\n",
      "Set Two difference: {'Grace', 'Bob'}\n",
      "Set One union: {'Alice', 'Dan', 'Heidi', 'Bob', 'Eve', 'Carol', 'Grace'}\n",
      "Set Two union: {'Alice', 'Dan', 'Heidi', 'Bob', 'Eve', 'Carol', 'Grace'}\n"
     ]
    }
   ],
   "source": [
    "set_one = set([\"Alice\", \"Carol\", \"Dan\", \"Eve\", \"Heidi\"])\n",
    "set_two = set([\"Bob\", \"Dan\", \"Eve\", \"Grace\", \"Heidi\"])\n",
    "\n",
    "# Intersection\n",
    "print(F\"Set One intersection: {set_one.intersection(set_two)}\")\n",
    "print(F\"Set Two intersection: {set_two.intersection(set_one)}\")\n",
    "\n",
    "# Symmetric difference\n",
    "print(F\"Set One symmetric difference: {set_one.symmetric_difference(set_two)}\")\n",
    "print(F\"Set Two symmetric difference: {set_two.symmetric_difference(set_one)}\")\n",
    "\n",
    "# Difference\n",
    "print(F\"Set One difference: {set_one.difference(set_two)}\")\n",
    "print(F\"Set Two difference: {set_two.difference(set_one)}\")\n",
    "\n",
    "# Union\n",
    "print(F\"Set One union: {set_one.union(set_two)}\")\n",
    "print(F\"Set Two union: {set_two.union(set_one)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et cela marque la fin de cette section du tutoriel."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 Python intermédiaire\n",
    "\n",
    "Le code de la section <a href=\"#2.1.3 Les bases du python\">2.1.3 Les bases du python</a> a été limité à de courts extraits. La résolution de problèmes plus complexes implique un code plus complexe s'étendant sur des centaines, voire des milliers, de lignes, et - si vous voulez réutiliser ce code - il n'est pas pratique de le copier-coller plusieurs fois. Pire encore, toute erreur est amplifiée, et toute modification devient fastidieuse à gérer.\n",
    "\n",
    "Il serait de loin préférable d'écrire un module pour resoudre cette tâche, l'obtenir de manière absolument parfaite, et l'appeler chaque fois que vous voulez que le même problème soit résolu ou que la même tâche soit exécutée.\n",
    "\n",
    "Dans les logiciels, ce processus de regroupement de fonctions individuelles dans leur propre code modulaire est appelé \"abstraction\". Un système logiciel complet est constitué d'un certain nombre de modules qui interagissent ensemble pour produire une application intégrée.\n",
    "\n",
    "En Python, ces modules sont appelés fonctions (`functions`) et une suite complète de fonctions regroupées autour d'un ensemble de tâches connexes est appelée librairie (`library`) ou `module`. Les bibliothèques vous permettent d'hériter d'une grande variété de solutions logicielles puissantes développées et maintenues par d'autres personnes.\n",
    "\n",
    "Python est [open source](https://en.wikipedia.org/wiki/Open-source_software), ce qui signifie que son code source est publié sous une licence qui permet à quiconque d'étudier, de modifier et de distribuer le logiciel à n'importe qui et dans n'importe quel but. De nombreuses bibliothèques Python parmi les plus populaires sont également à code source ouvert. Il existe des milliers de bibliothèques partagées que vous pouvez utiliser et, peut-être, lorsque vous vous sentez suffisamment confiant, auxquelles vous pouvez contribuer avec votre propre code.\n",
    "\n",
    "### Fonctions\n",
    "\n",
    "Les fonctions sont des modules de code appelables, certains avec des paramètres ou des arguments (variables que vous pouvez passer à la fonction), qui effectuent une tâche et peuvent renvoyer une valeur. Elles constituent un moyen pratique d'empaqueter du code en blocs indépendants, ce qui rend l'ensemble de votre programme plus lisible, réutilisable et permet de gagner du temps.\n",
    "\n",
    "Vous pouvez aussi facilement partager vos fonctions avec d'autres personnes, ce qui leur fait également gagner du temps. J'en ai glissé un dans la section sur la __gestion des exceptions__ tout à l'heure.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntaxe</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Vous structurez une fonction en utilisant <code>def</code>, comme suit:</li>\n",
    "        <code>def nom_de_la_fonction(paramètres) :\n",
    "         code\n",
    "         return response</code>\n",
    "        <li><code>return</code> est optionnel, mais vous permet de renvoyer les résultats de toute tâche effectuée par la fonction au point où la fonction a été appelée</li>\n",
    "        <li>Pour vérifier si un objet est une fonction (c'est-à-dire s'il peut être appelé), utilisez <code>callable</code>, par exemple <code>callable(nom_de_la_fonction)</code> renverra <code>True</code></li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Une fonction simple et sans arguments\n",
    "def say_hello():\n",
    "    print(\"Hello, World!\")\n",
    "\n",
    "# L'appeler est aussi simple que cela\n",
    "say_hello()\n",
    "\n",
    "# Et vous pouvez tester que c'est un appel\n",
    "print(callable(say_hello))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un argument peut être n'importe quelle variable, telle que des entiers, des chaînes de caractères, des listes, des dictionnaires ou même d'autres fonctions. C'est là que vous commencez à réaliser l'importance de laisser des commentaires et des explications dans votre code, car vous devez vous assurer que toute personne utilisant une fonction sait quelles variables la fonction attend, et dans quel ordre.\n",
    "\n",
    "Les fonctions peuvent également effectuer des calculs et les renvoyer à ce qu'on appelle les fonctions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Salut, Jill! J'espère que vous aurez un grand jour.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Une fonction avec deux arguments de string\n",
    "def say_hello_to_user(username, greeting):\n",
    "    # Renvoie un message de salutation à un nom d'utilisateur\n",
    "    print(F\"Salut, {username}! J'espère que vous aurez un grand {greeting}.\")\n",
    "\n",
    "# Appelez-le\n",
    "say_hello_to_user(\"Jill\", \"jour\")\n",
    "\n",
    "# Effectuer un calcul et le renvoyer\n",
    "def sum_two_numbers(x, y):\n",
    "    # Retourne la somme de x + y\n",
    "    return x + y\n",
    "\n",
    "sum_two_numbers(5, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous pouvez voir que l'échange `username` et `greeting` dans la fonction `say_hello_to_user` serait déroutant, mais l'échange des chiffres dans `sum_two_numbers` ne poserait pas de problème.\n",
    "\n",
    "Non seulement vous pouvez appeler des fonctions à partir de fonctions, mais vous pouvez aussi créer des variables qui sont des fonctions, ou le résultat de fonctions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "625\n"
     ]
    }
   ],
   "source": [
    "def number_powered(number, exponent):\n",
    "    # Renvoie le nombre à la puissance de l'exposant\n",
    "    return number ** exponent\n",
    "\n",
    "# Jupyter garde à disposition des fonctions qui ont été appelées dans d'autres cellules\n",
    "# Cela signifie que `sum_two_numbers` est toujours disponible\n",
    "def sum_and_power(number1, number2, exponent):\n",
    "    # Renvoie deux nombres additionnés, puis à un exposant\n",
    "    summed = sum_two_numbers(number1, number2)\n",
    "    return number_powered(summed, exponent)\n",
    "\n",
    "# Appelez-le `sum_and_power`\n",
    "print(sum_and_power(2, 3, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Grâce à une dénomination soignée et à de nombreux commentaires, vous pouvez voir comment vous pouvez rendre votre code extrêmement lisible et explicite.\n",
    "\n",
    "Une meilleure façon d'écrire les commentaires dans les fonctions est appelée `docstrings`. \n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntaxe</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Docstrings s'écrit comme un texte structuré entre trois séries de guillemets, par exemple <code>\"\"\" Il s'agit d'une chaîne documentaire \"\"\"</code></li>\n",
    "        <li>Vous pouvez accéder à la chaîne de documents d'une fonction en appelant <code>function.__doc__</code></li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    Un exemple de fonction qui renvoie `True`.\n",
      "    \n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def docstring_example():\n",
    "    \"\"\"\n",
    "    Un exemple de fonction qui renvoie `True`.\n",
    "    \"\"\"\n",
    "    return True\n",
    "\n",
    "# Impression de la docstring\n",
    "print(docstring_example.__doc__)\n",
    "\n",
    "# Appelez-la\n",
    "print(docstring_example())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes et objets\n",
    "\n",
    "Un objet Python complet est une encapsulation de variables et de fonctions en une seule entité. Les objets obtiennent leurs variables et leurs fonctions à partir de `classes`.\n",
    "\n",
    "Les classes sont l'endroit où la plupart des actions se déroulent en Python et le codage consiste, en grande partie, à produire et à utiliser des classes pour effectuer des tâches. \n",
    "\n",
    "Une classe très basique ressemblerait à ceci :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Regardez, une variable !\n",
      "Je suis une fonction de la classe !\n",
      "\n",
      "    Une classe de démonstration.\n",
      "    \n",
      "\n",
      "        Une fonction de classe de démonstration.\n",
      "        \n"
     ]
    }
   ],
   "source": [
    "class myClass:\n",
    "    \"\"\"\n",
    "    Une classe de démonstration.\n",
    "    \"\"\"\n",
    "    my_variable = \"Regardez, une variable !\"\n",
    "    \n",
    "    def my_function(self):\n",
    "        \"\"\"\n",
    "        Une fonction de classe de démonstration.\n",
    "        \"\"\"\n",
    "        return \"Je suis une fonction de la classe !\"\n",
    "\n",
    "# Vous appelez une classe en créant un nouvel objet de classe\n",
    "new_class = myClass()\n",
    "\n",
    "# Vous pouvez accéder aux variables de classe ou aux fonctions avec un appel pointillé, comme suit\n",
    "print(new_class.my_variable)\n",
    "print(new_class.my_function())\n",
    "\n",
    "# Accéder à la classe docstrings\n",
    "print(myClass.__doc__)\n",
    "print(myClass.my_function.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Résumons la nouvelle syntaxe.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntaxe</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Vous instanciez une classe en l'appelant <code>class()</code>. Si vous n'appelez que <code>class</code>, sans les parenthèses, vous accédez à l'objet lui-même. C'est également utile, et cela signifie que vous pouvez faire circuler les classes comme vous le feriez avec des variables.\n",
    "        <li>Toutes les variables et fonctions d'une classe sont accessibles par l'appel, <code>.function()</code> ou <code>.variable</code>. Vous pouvez même ajouter de nouvelles fonctions et variables à une classe que vous avez créée. N'oubliez pas, cependant, qu'elles n'existeront pas dans les nouvelles classes que vous créez puisque vous n'avez pas modifié le code sous-jacent.</li>\n",
    "        <li>Les fonctions au sein d'une classe nécessitent un argument de base qui, par convention, est appelé <code>self</code>. Il y a une explication complexe à la nécessité de <code>self</code>, mais - brièvement - considérez que c'est l'instance de l'objet lui-même. Ainsi, à l'intérieur de la classe, <code>self.function</code> est la façon dont la classe appelle ses composants fonctions.</li>\n",
    "        <li>Vous pouvez également accéder aux docstrings comme vous le feriez auparavant. </li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Salut, Bob! Regardez, une variable !\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'myClass' object has no attribute 'my_variable2'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-41-e834e768c0bc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;31m# Mais, essayer d'accéder à ma_variable2 dans new_class provoque une erreur\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnew_class\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmy_variable2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'myClass' object has no attribute 'my_variable2'"
     ]
    }
   ],
   "source": [
    "# Ajouter une nouvelle variable à une instance de classe\n",
    "new_class1 = myClass()\n",
    "new_class1.my_variable2 = \"Salut, Bob!\"\n",
    "print(new_class1.my_variable2, new_class1.my_variable)\n",
    "\n",
    "# Mais, essayer d'accéder à ma_variable2 dans new_class provoque une erreur\n",
    "print(new_class.my_variable2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les classes peuvent s'initialiser avec un ensemble de variables disponibles. Cela rend le référencement `self` plus explicite, et vous permet également de transmettre des arguments à votre classe pour fixer les valeurs initiales.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntaxe</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Initialiser une classe avec la fonction spéciale <code>def __init__(self)</code></li>\n",
    "        <li>Passez les arguments à vos fonctions avec <code>__init__(self, arguments)</code></li>\n",
    "        <li>Nous pouvons également différencier les arguments, et les arguments par mots clés:</li>\n",
    "        <ul>\n",
    "            <li><b>arguments</b> : ils sont transmis de la manière habituelle, sous la forme d'un seul terme, par exemple <code>ma_fonction(argument)</code>.</li>\n",
    "            <li><b>argument_mot_clé</b> : ils sont transmis de la manière dont on pense à un dictionnaire, par exemple <code>ma_fonction(argument_mot_clé = valeur)</code>. C'est aussi une façon d'initialiser un argument avec une valeur par défaut. Si vous laissez de côté l'argument lorsqu'il a une valeur par défaut, il s'appliquera sans que la fonction ne soit défaillante.</li>\n",
    "            <li>Les fonctions ont souvent besoin qu'on leur transmette de nombreux arguments et mots-clés, et cela peut devenir compliqué. Vous pouvez aussi penser à une liste d'arguments comme une liste, et une liste d'arguments de mots-clés comme un dictionnaire. Une façon plus simple de traiter ce problème est de référencer vos arguments et mots-clés comme ceci : <code>ma_fonction(*args, **kwargs)</code> où <code>*args</code> sera disponible pour la fonction sous forme de liste ordonnée, et <code>**kwargs</code> sous forme de dictionnaire.</li>\n",
    "        </ul>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World! None\n",
      "Hello, World! Bob\n",
      "Arg 1: Alice\n",
      "Arg 2: Bob\n",
      "Arg 3: Carol\n",
      "Arg 4: Dave\n",
      "Alice - Engineer\n",
      "Bob - Consultant\n",
      "Carol - Lawyer\n",
      "Dave - Doctor\n",
      "Hello, World!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Une démonstration de tous ces nouveaux concepts\n",
    "\n",
    "class demoClass:\n",
    "    \"\"\"\n",
    "    Une classe de démonstration avec une fonction __init__, et une fonction qui prend les args et les kwargs.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, argument = None):\n",
    "        \"\"\"\n",
    "        Une fonction qui est appelée automatiquement lorsque la démoClass est initialisée.\n",
    "        \"\"\"\n",
    "        self.demo_variable = \"Hello, World!\"\n",
    "        self.initial_variable = argument\n",
    "        \n",
    "    def demo_class(self, *args, **kwargs):\n",
    "        \"\"\"\n",
    "        Une classe de démo qui passe en boucle tous les args et kwargs fournis et les imprime.\n",
    "        \"\"\"\n",
    "        for i, a in enumerate(args):\n",
    "            print(\"Arg {}: {}\".format(i+1, a))\n",
    "        for k, v in kwargs.items():\n",
    "            print(\"{} - {}\".format(k, v))\n",
    "        if kwargs.get(self.initial_variable):\n",
    "            print(self.demo_variable)\n",
    "        return True\n",
    "\n",
    "demo1 = demoClass()\n",
    "demo2 = demoClass(\"Bob\")\n",
    "\n",
    "# Qu'est-ce qui a été initialisé dans chaque objet de démonstration ?\n",
    "print(demo1.demo_variable, demo1.initial_variable)\n",
    "print(demo2.demo_variable, demo2.initial_variable)\n",
    "\n",
    "# Une démo d'arguments de passage et d'arguments de mots-clés\n",
    "args = [\"Alice\", \"Bob\", \"Carol\", \"Dave\"]\n",
    "kwargs = {\"Alice\": \"Engineer\",\n",
    "          \"Bob\": \"Consultant\",\n",
    "          \"Carol\": \"Lawyer\",\n",
    "          \"Dave\": \"Doctor\"\n",
    "         }\n",
    "demo2.demo_class(*args, **kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'utilisation de `*args` et `**kwargs` dans vos appels de fonction pendant le développement facilite la modification de votre code sans avoir à revenir sur chaque ligne de code qui appelle votre fonction et la correction des bugs lorsque vous changez l'ordre ou le nombre d'arguments que vous appelez. \n",
    "\n",
    "Cela réduit les erreurs, améliore la lisibilité et rend l'expérience de codage plus agréable et plus efficace."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.5 Leçon terminée\n",
    "\n",
    "Ceci marque la fin de cette introduction à Python. Dans la prochaine partie de cette leçon, nous préparerons nos données par programme au lieu de le faire manuellement dans Excel."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}