python-2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# langages de script – Python\n",
    "\n",
    "## Cours 2 – précisions, fichiers et chaînes\n",
    "\n",
    "### M1 Ingénierie Multilingue – INaLCO\n",
    "\n",
    "clement.plancq@ens.fr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Type `bool` et valeurs booléennes\n",
    "\n",
    "* Nous avons vu qu'il existe un type `bool`\n",
    "\n",
    "  `True` et `False` sont les deux valeurs possibles de ce type.\n",
    "\n",
    "* Les comparaisons et les opérations booléennes renvoient des valeurs de type `bool`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"Hilary Clinton\" == \"Donald Trump\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2.0 < 2.1 and 2.0 > 1.9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Les valeurs ci-dessous sont toutes évaluées par l'interpréteur comme ayant la valeur booléenne *false*\n",
    "\n",
    "  `False` `None` `0` `\"\"` `()` `[]` `{}`\n",
    "\n",
    "* Tout le reste<sup>1</sup> sera évalué comme _true_\n",
    "\n",
    "  Vous pouvez écrire :\n",
    "```python\n",
    ">>> if var: ou while list:  \n",
    "```\n",
    "  plutôt que :  \n",
    "  (C'est même jugé plus pythonique (pythonien ?))\n",
    "\n",
    "```python\n",
    ">>> if var != \"\": ou while list != []:\n",
    "```\n",
    "\t\n",
    "<sup>1</sup> <small>Sauf les objets dont vous avez construit les classes. Voir les diapos à venir sur Classes et objets.</small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Assertions\n",
    "\t\n",
    "* Les assertions (`assert condition`) permettent de vérifier qu'une condition est remplie avant de poursuivre le programme\n",
    "\n",
    "* `assert` est utilisé à des fins de débogage.\n",
    "* Les assertions ne sont pas prises en compte si l'interpréteur est appelé avec l'option -O (optimisation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "var = 2\n",
    "assert 1 <= var <= 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "est équivalent à :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "if not 1 <= var <= 10:\n",
    "    raise AssertionError\n",
    "# plus exactement               \n",
    "if __debug__:\n",
    "    if not 1 <= var <= 10: raise AssertionError\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Précisions sur boucle `for`\n",
    "\n",
    "* `for` permet d'appliquer à chaque élément d'une liste les instructions du bloc qui suit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "words = ['tout', 'ici', 'chante', 'la', 'vie', 'de', 'naguère']\n",
    "for word in words:\n",
    "    up_word = word.upper()\n",
    "    print(up_word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* Plus précisément `for` s'applique sur les *séquences* (`list`, `str`, `tuple`) et plus généralement sur les *iterables* [voir doc](https://docs.python.org/3/glossary.html#term-iterable)\n",
    "\t      \n",
    "* Les *iterables* sont des objets issus de classes qui implémentent la méthode `__iter__()` et/ou `__getitem__()`\n",
    "\n",
    "  Essayer `help(str)` ou `help(dict)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Boucles encore\n",
    "\n",
    "* L'instruction `continue` permet de passer à l'itération suivante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "for word in words:\n",
    "    if word == 'la':\n",
    "        continue\n",
    "    print(word, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* L'instruction `break` permet de quitter la boucle en cours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "for word in words:\n",
    "    if word == 'la':\n",
    "        break\n",
    "    print(word, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Boucles enfin\n",
    "\n",
    "* `zip` permet de boucler sur plusieurs séquences\n",
    "* Si les séquences sont de tailles différentes `zip` s'arrête à la longueur la plus petite\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "noms = ['einstein', 'planck', 'turing', 'curie', 'bohr', 'shannon']\n",
    "facs = ['inalco', 'p3', 'p10', 'inalco', 'p3', 'inalco']\n",
    "parcours = ['pro', 'r&d', 'r&d', 'pro', 'pro', 'r&d']\n",
    "for nom, fac, parcours in zip(noms, facs, parcours):\n",
    "    print(\"{} est inscrit en {} à {}\".format(nom, parcours, fac))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Les fichiers\n",
    "\n",
    "* Pour travailler avec les fichiers on doit procéder à trois opérations :\n",
    "   1. Ouverture avec la fonction `open` (renvoie `IOError` en cas d'échec)\n",
    "   2. Lecture (`read` ou `readline` ou `readlines`) et/ou écriture (`write`)\n",
    "   3. Fermeture du fichier avec la fonction `close`\n",
    "\t      \n",
    "* Ouverture\n",
    "  * `open` est une fonction qui accepte de nombreux arguments : RTFM\n",
    "  * `open` renvoie un objet de type `file`\t      \n",
    "  * Le plus souvent elle s'emploie de la manière suivante:\n",
    "  ```python\n",
    ">>> #f = open(filename, mode)\t   \n",
    ">>> f = open('nom_fichier', 'w')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Les modes sont : \n",
    "\n",
    "* r : lecture (défaut)\n",
    "* w : écriture\n",
    "* x : création et écriture (échec si le fichier existe déjà)\n",
    "* a : concaténation (append)\n",
    "\t      \n",
    "* b : mode binaire\n",
    "* t : mode texte (défaut)\n",
    "* \\+ : read/write (ex: r+b)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Les fichiers : ouverture\n",
    "\n",
    "La documentation de Python conseille cette façon de faire \n",
    "```python\n",
    ">>> with open('mon_fichier', 'r') as f:\n",
    "...     read_data = f.read()\n",
    "```\n",
    "L'utilisation du mot clé `with` garantit la fermeture du fichier même si une exception est soulevée"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Les fichiers : lecture\n",
    "\n",
    "Plusieurs options pour la lecture\n",
    "\n",
    "* la fonction `read()` sans argument retourne le contenu du fichier\n",
    "* elle peut recevoir en argument la taille des donnéees à retourner \n",
    "\n",
    "```python\n",
    "# Les n premiers octets\n",
    "3_chars = f.read(3) \n",
    "# Le reste du fichier\n",
    "content = f.read()\t      \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* fonction `readline` et `readlines`\n",
    "\n",
    "```python\n",
    "for line in f.readline():\n",
    "    process(line)\n",
    "    \n",
    "lines = f.readlines()     \n",
    "```\n",
    "\n",
    "* un objet `file` est un itérable ! (_the pythonic way_)\n",
    "\n",
    "```python\n",
    "for line in f:\n",
    "    process(line)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Les fichiers : écriture et fermeture\n",
    "\n",
    "* fonction `write`\n",
    "```python\n",
    "for item in list:\n",
    "    f.write(item)\n",
    "```\n",
    "* fonction `close`\n",
    "\n",
    "  `f.close()`\n",
    "\n",
    "  En règle générale veillez à toujours fermer les objets fichiers\n",
    "\n",
    "  En mode écriture oublier de fermer un fichier peut réserver des mauvaises surprises\n",
    "\n",
    "* fonction `print`\n",
    "```python\n",
    "with open('mon_fichier', 'w') as output_f:\n",
    "    for item in list:\n",
    "        print(item, file=output_f)\n",
    "```\n",
    "* `sys.stdin`, `sys.stdout` et `sys.stderr` sont des objets de type `file`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Les chaînes\n",
    "\n",
    "Comme les listes et les tuples, les chaînes sont des *sequences*, on peut leur appliquer les opérations suivantes propres à la catégorie d'objets *sequence* :\n",
    "\n",
    "* longueur, minimum, maximum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "var = \"bonjour\"\n",
    "len(var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "max(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* _indexing_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "var[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "var[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* _slicing_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "var[0:3] # 3 premiers éléments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "var[-3:] # 3 derniers éléments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* _membership_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "if 'u' in var:\n",
    "    print(\"Il y a un u dans {}\".format(var))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Les chaînes ont aussi des fonctions qui leur sont propres\n",
    "\n",
    "Voir la liste complète dans la [doc python](https://docs.python.org/3/library/stdtypes.html#textseq)\n",
    "\n",
    "* lower"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "var = \"Le Grand Quotidien National\"\n",
    "var.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* replace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "var = \"Le Grand Quotidien National\"\n",
    "var = var.lower()\n",
    "var.replace('na', 'bo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* strip, rstrip\n",
    "\n",
    "  `strip` appelé sans arguments supprimme le ou les espaces en tête et en fin de chaîne  \n",
    "  `rstrip` fait la même chose en fin de chaîne uniquement  \n",
    "  `lstrip` idem en début de chaîne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "var = \"Lover you should've come over \"\n",
    "var.rstrip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* split\n",
    "\n",
    "  `split` découpe une chaîne en fonction du séparateur passé en argument et renvoie une liste\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var = \"The concept of global warming was created by and for the Chinese in order to make U.S. manufacturing non-competitive.\"\n",
    "words = var.split(' ')\n",
    "words[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "* join\n",
    "\n",
    "  `join` est l'inverse de `split`, il permet de joindre les éléments d'une liste de chaînes pour former une seule chaîne de caractères"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list = ['Quand', 'le', 'ciel', 'bas', 'et', 'lourd']\n",
    "\" \".join(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('\\N{ZWJ}'.join(['👩','👩','👧']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Formatage de chaînes\n",
    "\n",
    "« There should be one-- and preferably only one --obvious way to do it. » _Zen of Python_  \n",
    "Sauf que : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "name = \"\"\n",
    "coffee_price = 0.6\n",
    "\n",
    "print(\"Tiens salut \" + name + \". Tu aurais pas \" + str(coffee_price*2) + \" euros pour 2 cafés ?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* [`format()`](https://docs.python.org/3.5/library/string.html#formatstrings) depuis python3 (et python2.7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "print(\"Tiens salut {}. T'aurais pas {} euros pour 2 cafés ?\".format(name, coffee_price*2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* [f-string](https://docs.python.org/3.6/reference/lexical_analysis.html#f-strings) depuis python3.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "print(f\"Tiens salut {name}. T'aurais pas {coffee_price*2} pour 2 cafés ?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Exos\n",
    "\n",
    "Vous rendrez des scripts Python3. Avec des commentaires c'est mieux.      \n",
    "      \n",
    "1. Finir dictionnaire de rimes\n",
    "2. Résoudre [températures](https://www.codingame.com/training/easy/temperatures) sur CodinGame"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  },
  "livereveal": {
   "autolaunch": true,
   "scroll": true,
   "transition": "none"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}