tpIntroductionPython.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "indonesian-shade",
   "metadata": {},
   "source": [
    "\n",
    "<a id='chap-tpintroductionpython'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "moving-family",
   "metadata": {},
   "source": [
    "# Travaux pratiques - Introduction à Python\n",
    "\n",
    "(correspond à 1 séance de TP)\n",
    "\n",
    "Références externes utiles :\n",
    "\n",
    "> - [Site scikit-learn](http://scikit-learn.org/stable/index.html)  \n",
    "- [Site du langage Python](https://www.python.org)  \n",
    "- [Documentation de Python en français](https://docs.python.org/fr/3/)  \n",
    "\n",
    "\n",
    "\n",
    "Les travaux pratiques emploient le langage Python et cette première séance a pour premier objectif de vous le faire découvrir. Vous pouvez, par ailleurs, trouver de (très) nombreux tutoriels Python sur Internet, en français ou en anglais (ou d’autres langues).\n",
    "\n",
    "Parmi les caractéristiques notables du langage Python nous pouvons mentionner :\n",
    "\n",
    "> - langage de programmation objet où tout (ou presque) est objet ;  \n",
    "- typage fort : la conformité aux types est vérifiée, les conversions implicites de type ne sont pas autorisées ;  \n",
    "- typage dynamique : le type est déterminé à l’exécution, une déclaration explicite du type d’une variable n’est pas nécessaire ;  \n",
    "- gestion automatique de la mémoire par un mécanisme de « ramasse-miettes » ;  \n",
    "- **sensible à l’indentation** : les structures de contrôle n’emploient pas de délimiteurs (comme `begin` et `end`, ou `{` et `}`), tout est basé sur l’indentation (par ex. multiple de 4 espaces)  \n",
    "- sensible à la casse : différence entre majuscules et minuscules.  \n",
    "\n",
    "\n",
    "\n",
    "Si vous maîtrisez déjà les bases de Python, vous pouvez aller directement à la séance [d’introduction à Scikit-learn](tpIntroductionScikitLearn).\n",
    "\n",
    "En complément de cette introduction, vous pouvez suivre le [tutoriel Python officiel en français](https://docs.python.org/fr/3/tutorial/)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "satisfied-apparatus",
   "metadata": {},
   "source": [
    "## Python 2 ou Python 3 ?\n",
    "\n",
    "Depuis janvier 2020, la version 2 du langage Python n’est [plus maintenue](https://www.python.org/doc/sunset-python-2/). scikit-learn ayant décidé d’abandonner le support de Python 2 depuis sa version 0.20, nous emploierons et vous recommendons Python 3 dans les TP."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "progressive-housing",
   "metadata": {},
   "source": [
    "## Interpréteur Python\n",
    "\n",
    "Python est un langage interprété pouvant s’exécuter sur diverses plateformes.\n",
    "\n",
    "Si vous travaillez sur les machines des salles informatiques du CNAM, vous n’avez rien à faire, tout est déjà installé.\n",
    "\n",
    "Si vous réalisez ces TP sur votre machine personnelle, vous pouvez consulter [les instructions d’installation de scikit-learn](installationScikitLearn) pour installer les bons logiciels.\n",
    "\n",
    "Il faut a minima un interpréteur Python (accessible via la commande `python3` dans un terminal Linux/MacOS ou une console Windows). Pour plus de confort, nous recommandons également un environnement de programmation tel que Spyder ou Jupyter."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "elementary-federation",
   "metadata": {},
   "source": [
    "## Note\n",
    "\n",
    "Si vous êtes auditeur du CNAM, vous pouvez accéder à un serveur Jupyter en ligne en passant par [Moodle](https://lecnam.net) (Mes enseignements > RCP 208 > Accès au notebook).\n",
    "\n",
    "Vous pouvez alors y importer n’importe quel TP du cours. Pour ce faire, téléchargez le cahier (*notebook*) Jupyter du TP (clic droit > Enregistrer sous) à partir du bandeau en haut de l’énoncé. Dans JupyterHub, cliquez sur MonDossier/ puis sur le bouton de téléversement des fichiers pour importer le *notebook* Jupyter."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "serious-sacrifice",
   "metadata": {},
   "source": [
    "## Documentation, aide en ligne de commande\n",
    "\n",
    "L’interpréteur Python peut vous renvoyer de la documentation et de l’aide de différentes façons.\n",
    "\n",
    "Par exemple, définissons un couple et examinons-le. La fonction native `print` permet d’afficher le contenu d’une variable :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "loved-tomorrow",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "t = (8,9)\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "flush-concert",
   "metadata": {},
   "source": [
    "Si l’on veut savoir quelles sont les méthodes de l’objet `t`, on peut utiliser la fonction `dir` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "collaborative-relaxation",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "dir(t)\n",
    "# Affiche ['__add__', '__class__', ... 'count', 'index']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "apparent-healthcare",
   "metadata": {},
   "source": [
    "Pour avoir plus d’explications sur ces méthodes, il est possible d’appeler la fonction `help` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "institutional-uruguay",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "help(t)\n",
    "# Affiche :\n",
    "# Help on tuple object:\n",
    "#\n",
    "# class tuple(object)\n",
    "#  |  tuple() -> empty tuple\n",
    "#  |  tuple(iterable) -> tuple initialized from iterable's items\n",
    "#  |\n",
    "#  |  If the argument is a tuple, the return value is the same object.\n",
    "#  |\n",
    "#  |  Methods defined here:\n",
    "#  |\n",
    "#  |  __add__(self, value, /)\n",
    "#  |      Return self+value.\n",
    "#  |\n",
    "#  | ...\n",
    "#  |\n",
    "#  |  __getattribute__(self, name, /)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "political-entry",
   "metadata": {},
   "source": [
    "En ligne de commande, vous pouvez appuyer sur la touche `Espace` pour passer à la page suivante et sur la touche `q` pour quitter l’aide (comme pour la commande `man` de linux).\n",
    "\n",
    "Une fois entré dans l’aide avec `help()`, il est possible de demander une aide spécifique, par exemple d’avoir la liste des modules Python présents :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "subsequent-natural",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "help()\n",
    "# help> modules\n",
    "# ...\n",
    "# help> quit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "amazing-rendering",
   "metadata": {},
   "source": [
    "La fonction `id()` permet d’obtenir l’identifiant de l’objet dans l’interpréteur Python. Deux objets différents ont un identifiant différent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "historical-netherlands",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "print(id(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "announced-insured",
   "metadata": {},
   "source": [
    "Entrez"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "hazardous-communist",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "t = (\"3\",\"4\")\n",
    "print(id(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "liable-fusion",
   "metadata": {},
   "source": [
    "## Question :\n",
    "\n",
    "Est-ce le même `id` que plus haut ? Que s’est-il passé ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "direct-ethnic",
   "metadata": {},
   "source": [
    "## Correction :\n",
    "\n",
    "Non, ce n’est pas le même `id` car ce n’est pas le même objet. Par `t = (\"3\",\"4\")` nous avons donné le (même) nom `t` à un nouvel objet, le tuple `(\"3\",\"4\")`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fallen-relationship",
   "metadata": {},
   "source": [
    "## Note\n",
    "\n",
    "Les lignes commençant par `#` sont des **commentaires**. Elles ne sont pas interprétées par Python mais servent à expliquer ou documenter le code.\n",
    "Il est possible d’écrire des commentaires multilignes en les encadrant par `\"\"\"`.\n",
    "\n",
    "La fonction `print` permet d’afficher le contenu d’une variable dans le terminal. Par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecological-movie",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "x = 1276.99\n",
    "print(\"Voici mon message\")\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "opening-wallet",
   "metadata": {},
   "source": [
    "Il est possible d’injecter le contenu d’une variable dans une chaîne de caractères en utilisant la fonction `format` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "tight-residence",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# .format() va remplacer le contenu des accolades\n",
    "message = \"x vaut {}\".format(x)\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "noble-hormone",
   "metadata": {},
   "source": [
    "On peut également utiliser le format court (*f-strings*, Python 3.6 et ultérieur) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aboriginal-butler",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "message = f\"La variable x vaut {x}\"\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "worse-mobility",
   "metadata": {},
   "source": [
    "## Syntaxe\n",
    "\n",
    "L’affectation de valeurs à une variable (ou l’association d’objets à des noms) est faite en utilisant le signe `=`. Pour la vérification de l’égalité on employe deux signes `=` collés, `==`. Les commentaires sur une seule ligne commencent par `#`, les commentaires multi-lignes commencent et se terminent par `\"\"\"`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "light-nature",
   "metadata": {},
   "source": [
    "### Types de base\n",
    "\n",
    "Différents types de base sont disponibles dans Python. Pour la plupart de ces types de base, dont `bool` (booléen), `int` (entier), `float` (réel), `str` (chaîne de caractères), `tuple` (vecteur), les « variables » qui les possèdent sont **immuables** (*immutable*) : il n’est pas possible de changer leur valeur ! En revanche, il est possible de donner le même *nom* de variable à une nouvelle donnée, comme dans l’exemple ci-dessus que nous reprenons :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "rolled-python",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "t = (8,9)\n",
    "print(id(t))\n",
    "\n",
    "t = (\"3\",\"4\")\n",
    "print(id(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "electric-evidence",
   "metadata": {},
   "source": [
    "Lors de ce qui ressemble à l’affectation d’une nouvelle valeur à une variable, `t = (\"3\",\"4\")`, nous avons en fait donné le même nom `t` à un nouvel objet `(\"3\",\"4\")`, les identifiants de l’ancien `t` et du nouveau `t` sont donc naturellement différents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "supreme-token",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "entier = 1\n",
    "reel = 3.14\n",
    "chaine = \"pi\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "peripheral-title",
   "metadata": {},
   "source": [
    "Un *tuple* peut être composé de données de types différents :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "distant-checklist",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "v = (entier, reel, chaine)\n",
    "print(v)\n",
    "# (1, 3.14, 'pi')\n",
    "print(type(v))\n",
    "# <class 'tuple'>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "regional-alliance",
   "metadata": {},
   "source": [
    "La fonction `type()` permet d’examiner le type d’un objet."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "floating-pressing",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Affichez le type des variables `entier`, `reel` et `chaine`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "timely-procurement",
   "metadata": {},
   "source": [
    "### Correction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "special-superintendent",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "print(type(entier))\n",
    "print(type(reel))\n",
    "print(type(chaine))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fifteen-finland",
   "metadata": {},
   "source": [
    "Nous remarquerons enfin que les délimiteurs d’une chaîne de caractères peuvent être soit les `\"`, soit les `'` ; ce qui compte c’est la cohérence entre le début et la fin de la chaîne :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "imperial-pixel",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "s = \"toto\"\n",
    "print(s)\n",
    "# 'toto'\n",
    "s = 'toto'\n",
    "print(s)\n",
    "# 'toto'\n",
    "s = \"toto' # Erreur, il faut utiliser les mêmes guillemets pour ouvrir et fermer la chaîne !!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "thorough-prefix",
   "metadata": {},
   "source": [
    "Il est possible de forcer la conversion d’un type à un autre en appelant la fonction du même :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "phantom-breakfast",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "nombre = 1764\n",
    "chaine = str(1764)\n",
    "print(nombre, type(nombre))\n",
    "print(chaine, type(chaine))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "worldwide-complaint",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "chaine = \"42.3\"\n",
    "nombre = float(chaine)\n",
    "print(chaine, type(chaine))\n",
    "print(nombre, type(nombre))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "competitive-conviction",
   "metadata": {},
   "source": [
    "### Listes\n",
    "\n",
    "Les types de base modifiables (*mutable*) sont les **listes** et les **dictionnaires**. Une liste est un tableau unidimensionnel, dont les éléments peuvent avoir des types différents (et peuvent être des listes à leur tour) ; le premier élément est identifié par l’indice `0`, le dernier par l’indice `-1`. Les exemples ci-dessous illustrent également l’utilisation des `:` pour indiquer des intervalles d’indices. Ces mêmes règles concernant les indices sont valables pour les tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "amateur-button",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "liste = [entier, reel, chaine]\n",
    "print(liste)\n",
    "# [1, 3.14, 'pi']\n",
    "print(type(liste))\n",
    "# <class 'list'>\n",
    "print(liste[0])\n",
    "# 1\n",
    "print(liste[2])\n",
    "# 'pi'\n",
    "print(liste[3]) # Erreur !"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "narrative-technology",
   "metadata": {},
   "source": [
    "Les indices négatifs permettent d’accéder aux éléments en commençant par la fin de la liste :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "otherwise-sarah",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "print(liste[-1])\n",
    "# 'pi'\n",
    "print(liste[-2])\n",
    "# 3.14"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dirty-german",
   "metadata": {},
   "source": [
    "Le symbole `:` permet d’effectuer du *slicing*, c’est-à-dire de découper des sous-listes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "engaged-wright",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "print(liste[:1]) # Extrait la sous-liste de tous les éléments jusqu'à 1 (exclu)\n",
    "# [1]\n",
    "print(liste[:2]) # Extrait la sous-liste de tous les éléments jusqu'à 2 (exclu)\n",
    "# [1, 3.14]\n",
    "\n",
    "print(liste[:-1]) # Extrait la sous-liste jusqu'au dernier élément (exclu)\n",
    "# [1, 3.14]\n",
    "print(liste[:3])\n",
    "# [1, 3.14, 'pi']\n",
    "print(liste[0:]) # Extrait la sous-liste à partir du premier élément (inclus)\n",
    "# [1, 3.14, 'pi']\n",
    "print(liste[1:]) # Extrait la sous-liste à partir du deuxième élément (inclus)\n",
    "# [3.14, 'pi']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adult-scanner",
   "metadata": {},
   "source": [
    "Les listes disposent de plusieurs méthodes utiles (regardez-les avec `help(liste)`), parmi lesquelles :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "humanitarian-combination",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Concaténation de listes\n",
    "print(liste + liste)\n",
    "# [1, 3.14, 'pi', 1, 3.14, 'pi']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "endangered-engine",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Longueur d'une liste\n",
    "len(liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "weekly-imagination",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Minimum et maximum d'une liste\n",
    "print(min([3, 10, 1, 5, 24]))\n",
    "print(max([1.24, -12.0, 5.99]))\n",
    "\n",
    "# Attention, erreur si les éléments ne sont pas comparables :\n",
    "print(min(['pi', '12', 3, 1]))\n",
    "# Traceback (most recent call last):\n",
    "#   File \"<stdin>\", line 1, in <module>\n",
    "# TypeError: '<' not supported between instances of 'int' and 'str'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "unauthorized-viking",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Nombre d'occurrences d'un élément dans une liste\n",
    "liste = [3.14, 12, 0, 3.14, 9, 3.14, 7]\n",
    "liste.count(3.14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "adjacent-battery",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Tri d'une liste en ordre croissant\n",
    "liste.sort()\n",
    "print(liste)\n",
    "# Avec copie\n",
    "liste2 = sorted(liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "pleased-marriage",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Suppression d'un élément de la liste\n",
    "del liste[1]\n",
    "print(liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "compatible-ability",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Cherche la position de l'élément dans la liste\n",
    "print(liste.index(3.14))\n",
    "# 1\n",
    "print(liste.index(9))\n",
    "# 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "coastal-rubber",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Renverse une liste\n",
    "liste.reverse()\n",
    "print(liste)\n",
    "# [12, 9, 7, 3.14, 3.14, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "polished-ranch",
   "metadata": {},
   "source": [
    "Considérons une nouvelle liste :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "welsh-repeat",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "liste = [0, 2, 1, 9, 4, 5, 6, 8, 7, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "daily-festival",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "En utilisant les fonctions vues ci-dessus, transformez `liste` pour obtenir les chiffres de **1 à 9 dans l’ordre décroissant**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "massive-genesis",
   "metadata": {},
   "source": [
    "### Correction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "manual-divide",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "liste.sort()\n",
    "liste.reverse()\n",
    "print(liste[1:])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "plastic-holiday",
   "metadata": {},
   "source": [
    "### Dictionnaires\n",
    "\n",
    "Les dictionnaires sont des tableaux associatifs, autrement dit des ensembles de paires `{clé : valeur}`, par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "referenced-chess",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "cours = { 'RCP208' : 2016, 'RCP209' : 2017, 'RCP216' : 2017 }\n",
    "print(cours)\n",
    "# {'RCP216': 2017, 'RCP208': 2016, 'RCP209': 2017}\n",
    "print(cours['RCP209'])\n",
    "# 2017\n",
    "cours['RCP210']  # Erreur ! La clé n'existe pas\n",
    "# Traceback (most recent call last):\n",
    "#  File \"<stdin>\", line 1, in <module>\n",
    "# KeyError: 'RCP210'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bored-publisher",
   "metadata": {},
   "source": [
    "Il est possible de mélanger les types dans un dictionnaire (dans les clés et dans les valeurs), ainsi que d’avoir des valeurs qui sont des tuples ou des listes (ou des listes de listes, etc.) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dirty-cowboy",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "dico = { 1 : 'toto', 'titi' : 10, 1000 : (1,2,3) }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "detailed-rehabilitation",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "dico = { 1 : 'toto', 'titi' : 10, 1000 : [(1,2,3),['A','b']]}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "specified-beast",
   "metadata": {},
   "source": [
    "Plusieurs méthodes spécifiques aux dictionnaires peuvent être utiles, par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bright-hormone",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Obtenir les clés du dictionnaire\n",
    "print(dico.keys())\n",
    "# dict_keys(['titi', 1, 1000])\n",
    "# Obtenir les valeurs du dictionnaire\n",
    "print(dico.values())\n",
    "# dict_values([10, 'toto', [(1, 2, 3), ['A', 'b']]])\n",
    "# Obtenir les paires (clé, valeur)\n",
    "print(dico.items())\n",
    "# dict_items([('titi', 10), (1, 'toto'), (1000, [(1, 2, 3), ['A', 'b']])])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "white-school",
   "metadata": {},
   "source": [
    "### Question :\n",
    "\n",
    "Que retourne chacune de ces méthodes ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "beautiful-diana",
   "metadata": {},
   "source": [
    "### Correction\n",
    "\n",
    "`.keys()` renvoie les clés du dictionnaires tandis que `.values()` renvoie ses valeurs.\n",
    "`.items()` renvoie une liste de paires (clé, valeur).\n",
    "\n",
    "Pour tenter de clarifier la différence entre ce qui est immuable et ce qui est modifiable, prenons l’exemple suivant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "surrounded-nudist",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "valeur = 1\n",
    "liste = []\n",
    "print(liste)\n",
    "# []\n",
    "liste.append(valeur)\n",
    "print(liste)\n",
    "# [1]\n",
    "meme_liste = liste\n",
    "print(meme_liste)\n",
    "# [1]\n",
    "meme_liste.append(3)\n",
    "valeur = 2\n",
    "print(valeur)\n",
    "# 2\n",
    "print(liste)\n",
    "# [1, 3]\n",
    "print(meme_liste)\n",
    "# [1, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "smart-tamil",
   "metadata": {},
   "source": [
    "Comment expliquer les résultats ? Rappelons d’abord que les « variables » de type `int` sont immuables, alors que celles de type `list` sont modifiables.\n",
    "\n",
    "Dans la première ligne (`valeur = 1`), une association est faite entre le *nom* `valeur` et un objet qui est l’entier `1`. La seconde ligne (`liste = []`) fait une association entre le nom `liste` et un objet qui est une liste vide. L’appel de la méthode `append` dans `liste.append(valeur)` modifie cet objet liste vide en lui ajoutant l’objet désigné par le nom `valeur`. Dans `meme_liste = liste` on ajoute un nouveau nom pour l’objet désigné par `liste`.\n",
    "\n",
    "L’appel `meme_liste.append(3)` modifie l’objet désigné par `meme_liste` (et aussi par `liste`) en lui ajoutant l’objet `3` (un entier). Avec `valeur = 2`, le nom `valeur` n’est plus associé à l’objet auquel il était associé avant (un entier `1`) mais à un nouvel objet (un entier `2`) ; cela ne peut avoir d’impact sur l’objet désigné par `liste` ou `meme_liste`, qui est une liste (vide au départ, ensuite un objet `1` lui a été ajouté, et enfin un objet `3`).\n",
    "\n",
    "Ceci devrait permettre de comprendre aussi le passage de paramètres aux [Fonctions, fonctions anonymes](#fonctions)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sensitive-affairs",
   "metadata": {},
   "source": [
    "## Structures de contrôle\n",
    "\n",
    "Pour le contrôle de l’exécution d’un programme il est possible d’utiliser les tests de conditions avec `if` / `elif` / `else` et les boucles `for` ou `while`. Remarquer l’utilisation de `:` avant les lignes qui exigent un niveau d’indentation supérieur (et **obligatoire** !).\n",
    "\n",
    "Les boucles `for` permettent de parcourir n’importe quel itérable, typiquement des listes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "split-coverage",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "liste = range(6)\n",
    "\n",
    "for valeur in liste:\n",
    "    if valeur in [0, 2, 4]:\n",
    "        # \"break\" quitte la boucle sans considérer \"else\"\n",
    "        # \"continue\" démarre l'itération suivante\n",
    "        continue\n",
    "    else:\n",
    "        print(valeur,' : impaire')\n",
    "\n",
    "#1  : impaire\n",
    "#3  : impaire\n",
    "#5  : impaire"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bigger-highway",
   "metadata": {},
   "source": [
    "Les boucles `while` s’exécutent tant qu’une condition est vérifiée :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cellular-fabric",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "i = 5\n",
    "while i > 0:\n",
    "        print(i)\n",
    "        i = i-1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "neutral-click",
   "metadata": {},
   "source": [
    "## Question\n",
    "\n",
    "À l’aide d’une boucle, écrire un code qui affiche les carrés des nombres entiers **impairs** de 1 à 13."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "needed-guinea",
   "metadata": {},
   "source": [
    "## Correction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "american-imagination",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# un exemple\n",
    "for i in range(14):\n",
    "    if i % 2 == 0:\n",
    "        continue\n",
    "    else:\n",
    "        print(i*i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "thermal-graduation",
   "metadata": {},
   "source": [
    "Il n’y a pas d’équivalent de `switch` en Python, il faut employer `if` / `elif` / `else` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "plain-paint",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "if liste[1] == 0:\n",
    "    print('liste[1] est 0')\n",
    "elif liste[1] == 1:\n",
    "    print('liste[1] est 1')\n",
    "else:\n",
    "    print('?')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "comic-definition",
   "metadata": {},
   "source": [
    "Création et manipulation de listes avec la [compréhension de liste](https://docs.python.org/fr/3/tutorial/datastructures.html#list-comprehensions) (*list comprehension*) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "treated-complexity",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "l1 = [1, 2]\n",
    "l2 = [1, 2, 3]\n",
    "[x * y for x in l1 for y in l2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cheap-communication",
   "metadata": {},
   "source": [
    "Forme équivalente :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "persistent-month",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "print([x * y for x in l1 for y in l2])\n",
    "# [1, 2, 3, 2, 4, 6]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "suspended-chemical",
   "metadata": {},
   "source": [
    "Autres exemples :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "electric-battery",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "print([x * y for x in l1 if x > 1 for y in l2])\n",
    "# [2, 4, 6]\n",
    "print(any([i % 3 for i in [x * y for x in l1 for y in l2]]))\n",
    "# True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "technical-monday",
   "metadata": {},
   "source": [
    "## Question :\n",
    "\n",
    "Expliquez ce que fait chacun de ces exemples."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "alone-terrorist",
   "metadata": {},
   "source": [
    "## Correction :\n",
    "\n",
    "Pour `[x * y for x in l1 for y in l2]` : produit une liste composée des produits des valeurs de la liste `l1` avec les valeurs de la liste `l2`, la liste parcurue en premier étant `l2` (résultat `[1, 2, 3, 2, 4, 6]`).\n",
    "\n",
    "Pour `[x * y for x in l1 if x > 1 for y in l2]` : seules sont considérées les valeurs supérieures à 1 dans `l1`.\n",
    "\n",
    "Pour `any([i % 3 for i in [x * y for x in l1 for y in l2]])` : y a-t-il au moins un élément de la liste résultat de `[x * y ... ]` qui ne soit pas divisible par 3 (reste de la division par 3, c’est à dire `i % 3`, non nul) ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "optional-algeria",
   "metadata": {},
   "source": [
    "## Question :\n",
    "\n",
    "À partir des listes suivantes de mois et respectivement de nombres de jours correspondants, construisez un dictionnaire qui associe à chaque mois son nombre de jours (années non bisextiles)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "complete-steps",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "mois = ['janvier','février','mars','avril','mai','juin','juillet','août','septembre','octobre','novembre','décembre']\n",
    "nbJours = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "specific-gardening",
   "metadata": {},
   "source": [
    "## Correction :\n",
    "\n",
    "De la même façon que dans les exemples avec listes, on crée un dictionnaire (`{}` au lieu de `[]`) composé de paires `mois[i] : nbJours[i]` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "celtic-harrison",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "dico = {mois[i] : nbJours[i] for i in range(0,11)}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "raising-mouse",
   "metadata": {},
   "source": [
    "\n",
    "<a id='fonctions'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acoustic-owner",
   "metadata": {},
   "source": [
    "## Fonctions, fonctions anonymes\n",
    "\n",
    "La définition d’une fonction commence par `def`. Une fonction peut avoir zéro, un ou plusieurs arguments. Les arguments optionnels possèdent des valeurs par défaut. Une fonction peut retourner une valeur (ou un tuple, donc plusieurs valeurs) avec `return` ou non.\n",
    "\n",
    "Le premier exemple ci-dessous devrait aider à comprendre la transmission des paramètres :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "laden-sheffield",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def fonction(immuable, modifiable, optionnel='valeur par défaut'):\n",
    "    immuable = 'new'\n",
    "    modifiable.append(4)\n",
    "    print(immuable, modifiable, optionnel)\n",
    "\n",
    "chaine1 = 'old'\n",
    "liste = [1, 2]\n",
    "chaine2 = 'nouvelle valeur'\n",
    "fonction(chaine1, liste, chaine2)\n",
    "# new [1, 2, 4] nouvelle valeur"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "statutory-lewis",
   "metadata": {},
   "source": [
    "Notre variable `liste` a été modifiée à l’intérieur de la fonction mais pas la variable `chaine1` car les chaînes de caractère sont immuables :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "demonstrated-anchor",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "print(liste)\n",
    "# [1, 2, 4]\n",
    "print(chaine1)\n",
    "# 'old'\n",
    "fonction(chaine1, liste)\n",
    "# new [1, 2, 4, 4] valeur par défaut"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "plastic-account",
   "metadata": {},
   "source": [
    "L’utilisation de `print` plutôt que l’appel direct permet de voir que la fonction ne retourne rien (`None`) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "needed-possession",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "print(fonction(chaine1, liste, chaine2))\n",
    "# new [1, 2, 4, 4, 4] nouvelle valeur\n",
    "# None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "german-twenty",
   "metadata": {},
   "source": [
    "Ici, `liste` est un nom associé à un objet liste, donc modifiable ; à chaque appel, la fonction ajoute un élément à cet objet. Le nom `chaine1` est associé à un objet de type chaîne de caractères, donc immuable ; dans la fonction, le nom `chaine1` est **localement** associé à un nouvel objet, la chaîne `'new'`, mais cela n’a pas d’impact sur l’association de `chaine1` à l’objet `'old'` à l’extérieur de la fonction.\n",
    "\n",
    "L’exemple suivant montre une fonction qui retourne un tuple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "chubby-marker",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def fonction2(immuable, modifiable, optionnel='valeur par défaut'):\n",
    "    immuable = 'new'\n",
    "    modifiable.append(4)\n",
    "    return immuable, modifiable, optionnel\n",
    "\n",
    "chaine1 = 'old'\n",
    "liste = [1, 2]\n",
    "chaine2 = 'nouvelle valeur'\n",
    "print(fonction2(chaine1, liste, chaine2))\n",
    "# ('new', [1, 2, 4], 'nouvelle valeur')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "alpine-provincial",
   "metadata": {},
   "source": [
    "## Question\n",
    "\n",
    "Écrire une fonction `dernier_chiffre(x)` qui prend en entier un nombre à virgule `x` et renvoie son dernier chiffre. Par exemple, `dernier_chiffre(0.98)` renvoie 8 et `dernier_chiffre(100002)` renvoie 2."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "color-avatar",
   "metadata": {},
   "source": [
    "## Correction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "abroad-movie",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# un exemple\n",
    "def dernier_chiffre(x):\n",
    "    return str(x)[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cheap-tracy",
   "metadata": {},
   "source": [
    "Les fonctions lambda ou [fonctions anonymes](https://docs.python.org/fr/3/tutorial/controlflow.html#lambda-expressions) comportent une seule instruction, par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "handed-somewhere",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "fAdHoc = lambda x, y: x + y\n",
    "print(fAdHoc(2,3))\n",
    "# 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ongoing-enough",
   "metadata": {},
   "source": [
    "Cette définition est une forme abrégée de"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "effective-shopper",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def fAdHoc(x, y): return(x + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "irish-visitor",
   "metadata": {},
   "source": [
    "Il n’est pas indispensable de donner un nom à une fonction lambda :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "civilian-albany",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "(lambda x, y: x + y)(4,6)\n",
    "# 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "closing-hybrid",
   "metadata": {},
   "source": [
    "Une fonction lambda sans nom est qualifiée d’anonyme."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "racial-nitrogen",
   "metadata": {},
   "source": [
    "## Question\n",
    "\n",
    "Écrire une fonction lambda qui renvoie la plus grande des deux valeurs numériques passées en entrée."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hungarian-tuition",
   "metadata": {},
   "source": [
    "## Correction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "crazy-compound",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "lambda x, y: x if x > y else y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "rising-theta",
   "metadata": {},
   "source": [
    "## Exceptions\n",
    "\n",
    "Python propose un traitement standard des exceptions. L’exemple suivant indique la syntaxe à employer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "occupational-screening",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def autreFonction(n):\n",
    "        try:  # instruction susceptible de lever une exception\n",
    "            print(1 / n)\n",
    "        except ZeroDivisionError:  # si l'exception est levée\n",
    "            print('Division par 0 !')\n",
    "        else:  # sinon\n",
    "            pass\n",
    "        finally:\n",
    "            # exécuté après le bloc \"try\" et le\n",
    "            #  traitement des éventuelles erreurs\n",
    "            print('    fini...')\n",
    "\n",
    "autreFonction(1)\n",
    "autreFonction(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "thermal-intermediate",
   "metadata": {},
   "source": [
    "## Question\n",
    "\n",
    "Ajouter une exception au code suivant de sorte à ce qu’il affiche *« Ce mot est absent »* si la clé n’existe pas dans le dictionnaire."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "modular-interval",
   "metadata": {},
   "source": [
    "## Correction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "amino-stadium",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "d = {\"titi\" : \"i\", \"tata\": \"a\", \"tutu\": \"u\"}\n",
    "\n",
    "mots = [\"tata\", \"tete\", \"titi\", \"toto\", \"tutu\"]\n",
    "\n",
    "for mot in mots:\n",
    "    try:\n",
    "        print(d[mot])\n",
    "    except KeyError:\n",
    "        print(\"Ce mot est absent.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "prospective-logan",
   "metadata": {},
   "source": [
    "## Classes et héritage\n",
    "\n",
    "Il est utile mais pas indispensable de bien connaître la programmation objet pour bien suivre les travaux pratiques, ou pour faire le projet de l’UE RCP209.\n",
    "\n",
    "En Python, on peut définir des variables partagées par toutes les instances d’une classe. Aussi, l’héritage multiple est possible. La définition d’une classe a la forme suivante (n’entrez pas ceci dans l’interpréteur Python, ce n’est pas une définition complète) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "variable-surgery",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "class NouvelleClasse():\n",
    "    attribut_de_classe = ...\n",
    "\n",
    "    def __init__(self):  # constructeur\n",
    "        # ...\n",
    "        pass\n",
    "\n",
    "    def methode(self, arg1, arg2, arg3):  # methode de l'objet\n",
    "        # ...\n",
    "        pass\n",
    "\n",
    "    # ...\n",
    "\n",
    "class NouvelleClasseHeritage(NouvelleClasse):\n",
    "\n",
    "    # ...\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "executed-planet",
   "metadata": {},
   "source": [
    "Création d’une nouvelle instance de la classe :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "severe-accused",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "instanceNouvelleClasse = NouvelleClasse()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "prompt-mississippi",
   "metadata": {},
   "source": [
    "## Entrées et sorties\n",
    "\n",
    "La fonction native `open` permet d’ouvrir un flux de données depuis un fichier.\n",
    "\n",
    "Cette fonction prend deux arguments : un chemin vers le fichier et le mode de lecture (lecture, écriture, binaire, etc.).\n",
    "\n",
    "Exemple d’accès à un fichier texte :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "better-quality",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Ouverture du fichier en mode écriture ('w' pour 'write')\n",
    "fichierTexte = open('texte.txt', 'w')\n",
    "fichierTexte.write('Mon texte à moi\\n')\n",
    "fichierTexte.close()\n",
    "\n",
    "# Ouverture du fichier en mode lecture\n",
    "fichierTexte = open('texte.txt')\n",
    "print(fichierTexte.read())\n",
    "# Mon texte à moi\n",
    "fichierTexte.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "demanding-weight",
   "metadata": {},
   "source": [
    "L’instruction `with` permet de ne pas avoir à fermer manuellement le fichier en utilisant un [gestionnaire de contexte](https://docs.python.org/fr/3/reference/compound_stmts.html?highlight=with#the-with-statement)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "close-diameter",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# le mode 'a' permet d'ajouter des lignes sans écraser le fichier ('append')\n",
    "with open('texte.txt', 'a') as fichierTexte:\n",
    "    fichierTexte.write('Et une ligne de plus\\n')\n",
    "\n",
    "\n",
    "with open('texte.txt') as fichierTexte:\n",
    "    print(fichierTexte.read())\n",
    "    # Mon texte à moi\n",
    "    # Et une ligne de plus"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "champion-kernel",
   "metadata": {},
   "source": [
    "Dans ces exemples, les fichiers sont ouverts dans le répertoire dans lequel Python a été lancé. Il est possible de spécifier le chemin avant le nom du fichier."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "armed-canyon",
   "metadata": {},
   "source": [
    "## Question :\n",
    "\n",
    "Quelle conséquence a la suppression du second argument de la fonction `open` ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "circular-harvard",
   "metadata": {},
   "source": [
    "## Correction :\n",
    "\n",
    "C’est la valeur `'r'` qui est utilisée par défaut.\n",
    "\n",
    "Enfin, le module `pickle` permet de stocker des objets Python dans des fichiers binaires et de les lire.\n",
    "\n",
    "Utilisation d’un fichier binaire pour enregistrer ou lire des données/objets quelconques :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "alternative-premises",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "liste = [1, 3.14, 'pi']\n",
    "fichierBinaire = open('bin.dat', 'wb')\n",
    "pickle.dump(liste, fichierBinaire)\n",
    "fichierBinaire.close()\n",
    "\n",
    "fichierBinaire = open('bin.dat', 'rb')\n",
    "listeIdentique = pickle.load(fichierBinaire)\n",
    "print(listeIdentique)\n",
    "# [1, 3.14, 'pi']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "convertible-weight",
   "metadata": {},
   "source": [
    "Nous allons ensuite approfondir cette introduction en explorant les bibliothèques [Numpy, Scipy, MatPlotLib et Scikit-learn](tpIntroductionScikitLearn.html)."
   ]
  }
 ],
 "metadata": {
  "date": 1614358413.4940443,
  "filename": "tpIntroductionPython.rst",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python"
  },
  "title": "Travaux pratiques - Introduction à Python"
 },
 "nbformat": 4,
 "nbformat_minor": 5
}