python-6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Langages de script - Python\n",
    "## Cours 6 - classes, objets, bidules\n",
    "### M2 Ingénierie Multilingue - INaLCO\n",
    "#### Clément Plancq - clement.plancq@ens.fr\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Au commencement\n",
    "Au commencement étaient les variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "x = 27"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Elles représentaient parfois des concepts sophistiqués"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "point_1 = (27, 13)\n",
    "point_2 = (19, 84)\n",
    "\n",
    "def distance(p1, p2):\n",
    "    return math.sqrt((p2[0]-p1[0])**2+(p2[1]-p1[1])**2)\n",
    "\n",
    "distance(point_1, point_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Et c'était pénible à écrire et à comprendre"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Pour simplifier, on peut nommer les données contenues dans variables, par exemple avec un `dict`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "point_1 = {'x': 27, 'y': 13}\n",
    "point_2 = {'x': 19, 'y': 84}\n",
    "\n",
    "def distance(p1, p2):\n",
    "    return math.sqrt((p2['x']-p1['x'])**2+(p2['y']-p1['y'])**2)\n",
    "\n",
    "distance(point_1, point_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Et c'est toujours aussi pénible à écrire mais un peu moins à lire"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "On peut avoir une syntaxe plus agréable en utilisant des tuples nommés"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from collections import namedtuple\n",
    "Point = namedtuple('Point', ('x', 'y'))\n",
    "\n",
    "point_1 = Point(27, 13)\n",
    "point_2 = Point(19, 84)\n",
    "\n",
    "def distance(p1, p2):\n",
    "    return math.sqrt((p2.x-p1.x)**2+(p2.y-p1.y)**2)\n",
    "\n",
    "distance(point_1, point_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Voilà, le cours est fini, bonnes vacances."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Peut mieux faire\n",
    "  - Les trucs créés via `namedtuple` sont ce qu'on appelle des *enregistrements* (en C des *struct*s)\n",
    "  - Ils permettent de regrouper de façon lisibles des données qui vont ensemble\n",
    "    - Abscisse et ordonnée d'un point\n",
    "    - Année, mois et jour d'une date\n",
    "    - ~~Signifiant et signifié~~ Prénom et nom d'une personne\n",
    "  - Leur utilisation (comme tout le reste d'ailleurs) est **facultative** : on vit très bien en assembleur\n",
    "  - Mais ils permettent de rendre le code bien plus lisible (et écrivable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "Vecteur = namedtuple('Vecteur', ('x', 'y'))\n",
    "\n",
    "v1 = Vecteur(27, 13)\n",
    "v2 = Vecteur(1, 0)\n",
    "\n",
    "def norm(v):\n",
    "    return math.sqrt(v.x**2 + v.y**2)\n",
    "\n",
    "def is_unit(v):\n",
    "    return norm(v) == 1\n",
    "\n",
    "print(is_unit(v1))\n",
    "print(is_unit(v2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "C'est plutôt lisible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Mais si je veux pouvoir faire aussi de la 3d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "Vecteur3D = namedtuple('Vecteur3D', ('x', 'y', 'z'))\n",
    "\n",
    "u1 = Vecteur3D(27, 13, 6)\n",
    "u2 = Vecteur3D(1, 0, 0)\n",
    "\n",
    "def norm3d(v):\n",
    "    return math.sqrt(v.x**2 + v.y**2 + v.z**2)\n",
    "\n",
    "def is_unit3d(v):\n",
    "    return norm3d(v) == 1\n",
    "\n",
    "print(is_unit3d(u1))\n",
    "print(is_unit3d(u2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C'est affreusement pénible de réécrire comme ça le même code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Une autre solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def norm(v):\n",
    "    if isinstance(v, Vecteur3D):\n",
    "        return math.sqrt(v.x**2 + v.y**2 + v.z**2)\n",
    "    elif isinstance(v, Vecteur):\n",
    "        return math.sqrt(v.x**2 + v.y**2)\n",
    "    else:\n",
    "        raise ValueError('Type non supporté')\n",
    "\n",
    "def is_unit(v):\n",
    "    return norm(v) == 1\n",
    "\n",
    "print(is_unit(v1))\n",
    "print(is_unit(u2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "C'est un peu mieux mais pas top. (Même si on aurait pu trouver une solution plus intelligente)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Ces fameux objets\n",
    "Une des solutions pour faire mieux c'est de passer à la vitesse supérieure : les objets.\n",
    "\n",
    "Ça va d'abord être un peu plus désagréable, pour ensuite être beaucoup plus agréable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Vecteur:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def norm(self):\n",
    "        return math.sqrt(self.x**2 + self.y**2)\n",
    "\n",
    "v1 = Vecteur(27, 13)\n",
    "v2 = Vecteur(1, 0)\n",
    "\n",
    "print(v1.norm())\n",
    "print(v2.norm())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Vecteur3D:\n",
    "    def __init__(self, x, y, z):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        self.z = z\n",
    "        \n",
    "    def norm(self):\n",
    "        return math.sqrt(self.x**2 + self.y**2 + self.z**2)\n",
    "\n",
    "u1 = Vecteur3D(27, 13, 6)\n",
    "u2 = Vecteur3D(1, 0, 0)\n",
    "\n",
    "print(u1.norm())\n",
    "print(u2.norm())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def is_unit(v):\n",
    "    return v.norm() == 1\n",
    "\n",
    "print(is_unit(v1))\n",
    "print(is_unit(u2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Le choix de la bonne fonction `norme` se fait automagiquement (on appelle ça du *polymorphisme*)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Résumons\n",
    "  - Un objet, c'est un bidule qui regroupe\n",
    "    - Des données (on dit *attributs* ou *propriétés*)\n",
    "    - Des fonctions (on dit des *méthodes*)\n",
    "  - Ça permet d'organiser son code de façon plus lisible et plus facilement réutilisable (croyez moi sur parole)\n",
    "  \n",
    "Et vous en avez déjà rencontré plein"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type('abc'))\n",
    "print('abc'.islower())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Car en Python, tout est objet. Ce qui ne veut pas dire qu'on est obligé d'y faire attention…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## POO\n",
    "\n",
    "La programmation orientée objet (POO) est une manière de programmer différente de la programmation procédurale vue jusqu'ici.\n",
    "\n",
    "  - Les outils de base sont les objets et les classes\n",
    "  - Un concept → une classe, une réalisation concrète → un objet\n",
    "\n",
    "C'est une façon particulière de résoudre les problèmes, on parle de *paradigme*, et il y en a d'autres\n",
    "  \n",
    "  - Fonctionnel : les outils de base sont les fonctions\n",
    "  - Impérative : les outils de base sont les structures de contrôle (boucles, tests…)\n",
    "\n",
    "Python fait partie des langages multi-paradigmes : on utilise le plus pratique, ce qui n'est pas sans déplaire aux puristes mais\n",
    "\n",
    "« *We are all consenting adults here* »"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Classes\n",
    "* On définit une classe en utilisant le mot-clé `class`\n",
    "* Par conventions, les noms de classe s'écrivent avec des  majuscules (CapWords convention)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Word:\n",
    "    \"\"\" Classe Word : définit un mot de la langue \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Pour créer un objet, on appelle simplement sa classe comme une fonction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "word1 = Word()\n",
    "print(type(word1)) # renvoie la classe qu'instancie l'objet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "On dit que `word1` est une *instance* de la classe `Word`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Et il a déjà des attributs et des méthodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word1.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(dir(word1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et aussi un identifiant unique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(word1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word2 = Word()\n",
    "id(word2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\n",
    "## Constructeur et attributs\n",
    "\n",
    "* Il existe une méthode spéciale `__init__()` qui automatiquement appelée lors de la création d'un objet. C'est le constructeur\n",
    "\n",
    "* Le constructeur permet de définir un état initial à l'objet, lui donner des attributs par exemple\n",
    "\n",
    "* Les attributs dans l'exemple ci-dessous sont des variables propres à un objet, une instance\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Word:\n",
    "    \"\"\" Classe Word : définit un mot de la langue \"\"\"\n",
    "    \n",
    "    def __init__(self, form, lemma, pos):\n",
    "        self.form = form\n",
    "        self.lemma = lemma\n",
    "        self.pos = pos\n",
    "\n",
    "word = Word('été', 'être', 'V')\n",
    "word.lemma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word2 = Word('été', 'été', 'NOM')\n",
    "word2.lemma"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Méthodes\n",
    "\n",
    "* Les méthodes d'une classe sont des fonctions. Elles indiquent quelles actions peut mener un objet, elles peuvent donner des informations sur l'objet ou encore le modifier.\n",
    "* Par convention, on nomme `self` leur premier paramètre, qui fera référence à l'objet lui-même.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Word:\n",
    "    \"\"\" Classe Word : définit un mot simple de la langue \"\"\"\n",
    "    def __init__(self, form, lemma, pos):\n",
    "        self.form = form\n",
    "        self.lemma = lemma\n",
    "        self.pos = pos\n",
    "\n",
    "    def is_inflected(self):\n",
    "        if self.form != self.lemma:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "w = Word('orientales', 'oriental', 'adj')\n",
    "w.is_inflected()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Pourquoi `self` ? Parce que écrire `w.is_inflected()` c'est du sucre pour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Word.is_inflected(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Héritage\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Cake:\n",
    "    \"\"\" un beau gâteau \"\"\"\n",
    "\n",
    "    def __init__(self, farine, oeuf, beurre):\n",
    "        self.farine = farine\n",
    "        self.oeuf = oeuf\n",
    "        self.beurre = beurre\n",
    "\n",
    "    def is_trop_gras(self):\n",
    "        if self.farine + self.beurre > 500:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def cuire(self):\n",
    "        return self.beurre / self.oeuf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Cake est la classe mère.\n",
    "\n",
    "Les classes enfants vont hériter de ses méthodes et de ses attributs.\n",
    "\n",
    "Cela permet de factoriser le code, d'éviter les répétitions et les erreurs qui en découlent.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class CarrotCake(Cake):\n",
    "    \"\"\" pas seulement pour les lapins\n",
    "        hérite de Cake \"\"\"\n",
    "\n",
    "    carotte = 3\n",
    "    \n",
    "    def cuire(self):\n",
    "        return self.carotte * self.oeuf\n",
    "    \n",
    "class ChocolateCake(Cake):\n",
    "    \"\"\" LE gâteau \n",
    "        hérite de Cake \"\"\"\n",
    "        \n",
    "    def is_trop_gras(self):\n",
    "        return False\n",
    "\n",
    "gato_1 = CarrotCake(200, 3, 150)\n",
    "gato_1.is_trop_gras()\n",
    ">>> False\n",
    "gato_1.cuire()\n",
    ">>> 9\n",
    "gato_2 = ChocolateCake(200, 6, 300)\n",
    "gato_2.is_trop_gras()\n",
    ">>> False"
   ]
  }
 ],
 "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
}