03b_classes_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# La programmation orientée objet en Python\n",
    "\n",
    "Nous avons déjà vu les notions de base liées aux classes.\n",
    "\n",
    "La programmation orientée objet (POO) amène certains avantages par rapport à la programmation procédurale.\n",
    "\n",
    "- Elle permet d’obtenir un code plus réutilisable. En effet, les types d’objets créés peuvent servir de base pour d’autres objets en ne développant que les évolutions nécessaires.\n",
    "\n",
    "- Elle offre un code plus compréhensible. En effet, chaque objet va contenir ses propriétés et ses méthodes. Il est donc aisé de voir ce qu’une fonction manipule et à quoi correspondent les variables disponibles.\n",
    "\n",
    "- Elle amène un code modulaire. En effet, chaque type d’objet ne communique avec les autres types que par des interfaces connues et définies. Cet isolement permet donc de développer facilement d’autres modules pour interagir avec les interfaces déjà utilisées."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Généralement, on a procédural pour le data scientist et oo pour le développeur\n",
    "\n",
    "- La POO a pour principal attrait de permettre de proposer une belle API, c’est à dire de créer du code réutilisable et facile à manipuler. \n",
    "\n",
    "- Il n’y a rien qu’on puisse faire en POO qu’on ne puisse faire autrement. On va surtout l’utiliser pour donner un style au code.\n",
    "\n",
    "- En fait, on fait de la POO pour celui qui va utiliser votre code plus tard."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Procédural != Objet\n",
    "\n",
    "Paradigme procédural :\n",
    "- Chaque espace de nom va stocker des variables et des fonctions\n",
    "- Les données sont stockées dans les variables\n",
    "- On privilégie les actions par rapport aux données\n",
    "    - Code = Ensemble de fonctions qui s'échangent des variables et des constantes\n",
    "    \n",
    "Paradigme objet :\n",
    "- Deux catégories d'identificateurs : les instances et les classes\n",
    "- Les données sont stockées dans des instances\n",
    "- On privilégie les données par rapport aux actions\n",
    "\n",
    "Avantage du paradigme objet :\n",
    "- Regroupement en un seul endroit de l'ensemble des traitements possibles pour une donnée\n",
    "- Possibilité de réutiliser un objet dans pluseurs applications sans réécriture du code associé\n",
    "- Construction d'une API plus simple pour l'utilisateur\n",
    "\n",
    "Inconvénient :\n",
    "- Une certaine lourdeur de code dans la mise en oeuvre avec une phase de conception plus longue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Utilisation de l'orienté objet\n",
    "\n",
    "## Quelques cas classiques\n",
    "\n",
    "- Construction d'un connecteur pour une base de données\n",
    "- Construction d'une nouvelle structure de données\n",
    "- Développement d'une API d'application de nouveaux algorithmes\n",
    "- Construction d'un outil de scraping web automatisé\n",
    "\n",
    "## Vous utilisez déjà de la POO lorsque vous utilisez :\n",
    "\n",
    "- Pandas et Numpy pour la gestion des données\n",
    "- Scikit-Learn pour l'application de Machine Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Bonnes pratiques\n",
    "\n",
    "Lorsque votre code doit \"passer en production\" et être industrialisé, l'utilisation d'une POO est plus efficace (même si elle est plus compliqué à mettre en oeuvre).\n",
    "\n",
    "## Faut-il toujours coder en orienté objet ?\n",
    "\n",
    "- Si vous êtes développeur pour de l'industrialisation de gros projet, il faut privilégier cette approche\n",
    "- Si vous êtes data scientist, elle arrive souvent dans un second temps dans une phase de reflexion lors de la pré-industrialisation\n",
    "\n",
    "Lorsque le projet d'application est clair, l'approche OO s'impose souvent."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Pourquoi du code développé en OO est-il plus facile à maintenir ?\n",
    "\n",
    "- La mise en place de tests unitaires est plus simples car les méthodes sont toujours adaptées à un objet spécifique\n",
    "- On travaille généralement avec des structures similaires dans un projet, on pourra donc utiliser simplement les notions d'héritage et donc factoriser son code (éviter les répétitions inutiles dans différentes parties du code)\n",
    "- Globalement, une classe est plus facile à documenter qu'une fonction qui est plus souple\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Pourquoi faire de l'orienté objet pour l'industrialisation ?\n",
    "\n",
    "- C'est l'approche C++ / Java et c'est souvent l'approche privilégié par les développeurs\n",
    "- Pour des raisons de qualité évoqué plus haut\n",
    "- Pour simplement créer des API standardisées"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Quelques points supplémentaires\n",
    "\n",
    "## Attributs de classe, méthodes de classe et méthodes statiques\n",
    "\n",
    "- attributs de classe : attributs définis en début de classe\n",
    "- méthodes de classe : méthodes ne travaillent pas sur l'instance `self`. Elle prend comme paramètre `cls`\n",
    "\n",
    "Pour définir une méthode de classe, on peut utiliser un décorateur spécifique `@classmethod`\n",
    "\n",
    "- méthodes statiques : méthodes assez proches des méthodes de classe sauf qu'elles ne prennent aucun premier paramètre, ni `self` ni `cls`.\n",
    "\n",
    "Pour définir une méthode statique, on peut utiliser un décorateur spécifique `@staticmethod`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quelques points supplémentaires\n",
    "## Utilisation de l'héritage de classe avec pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pandas import DataFrame\n",
    "\n",
    "class SubclassedDataFrame(DataFrame):\n",
    "\n",
    "    @property\n",
    "    def _constructor(self):\n",
    "        return SubclassedDataFrame\n",
    "    \n",
    "    def methode(self):\n",
    "        return self.mean()\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"Mon DF\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_classic = DataFrame([4,6,8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   0\n",
      "0  4\n",
      "1  6\n",
      "2  8\n"
     ]
    }
   ],
   "source": [
    "print(data_classic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data=SubclassedDataFrame([4,6,8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    6.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    6.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.methode()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mon DF\n"
     ]
    }
   ],
   "source": [
    "# on passe par la méthode __str__\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    6.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.methode()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Une classe de connexion vers des bases de données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Connector(object):\n",
    "    \"\"\" Classe de connexion à une base MySQL\"\"\"\n",
    "    \n",
    "    def __init__(self, host=\"localhost\",\n",
    "                 user=\"MyUser\",passwd=\"MyPassword\", **autres_arguments):\n",
    "        self.host = host\n",
    "        self.user = user\n",
    "        self.passwd = passwd\n",
    "        \n",
    "    def create_connection( self ):\n",
    "        self.cursor = MySQLdb.connect(self.host, self.user,self.passwd)\n",
    "    \n",
    "    def close_connection( self ):\n",
    "        self.cursor.close()\n",
    "    \n",
    "    def execute( self, sql_statement ):\n",
    "        self.cursor.Execute( sql_statement )\n",
    "        return self.cursor.FetchAll()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Une classe pour faire du crawling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "from lxml import html\n",
    "\n",
    "class YellowPage:\n",
    "    \"\"\" Classe pour explorer les pages jaunes \"\"\"\n",
    "    URL_TEMPLATE = \"https://www.yellowpages.com/search?search_terms={name}&geo_location_terms={state}\"\n",
    "\n",
    "    @classmethod\n",
    "    def crawl(cls, name, state):\n",
    "        \"\"\" Méthode de classe permettant de renvoyer tous les résultat d'une page de résultat de recherche\"\"\"\n",
    "        page = requests.get(cls.URL_TEMPLATE.format(name=name, state=state)).text\n",
    "        tree = html.fromstring(page)\n",
    "        for items in tree.xpath('//div[@class=\"info\"]'):\n",
    "            name = items.findtext('.//span')\n",
    "            address = items.findtext('.//span[@class=\"street-address\"]')\n",
    "            phone = items.findtext('.//div[@class=\"phones phone primary\"]')\n",
    "            yield (name, address, phone)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('ORIGAMI JAPANESE RESTAURA', None, '(305) 294-0092')\n",
      "('Saigon Tokyo', None, '(561) 855-1533')\n",
      "('Nippon Thai INC', None, '(321) 773-0700')\n",
      "('VKI Japanese Steak House & Sushi Bar', None, '(850) 213-8123')\n",
      "('Shibui Japanese Restaurant', None, '(786) 369-4121')\n",
      "('SASAYA DREAM ISLAND INC', None, '(954) 761-8010')\n",
      "('Tokyo Chinese and Japanese Restaurant', None, '(813) 435-1357')\n",
      "('Sushi Yama', None, '(561) 362-2779')\n",
      "('Pink Buddha Chinese Restaurant', None, '(954) 900-6109')\n",
      "('Koume Japanese Restaurant', None, '(954) 577-9254')\n",
      "('Mikato Japanese Steak House & Sushi Bar', None, '(904) 824-7064')\n",
      "('Yashi Sushi', None, '(904) 997-9887')\n",
      "('Kan-Ki Japanese Steakhouse And Sushi Bar', None, '(904) 292-2400')\n",
      "('Yamato Oriental Cuisine', None, '(850) 453-3461')\n",
      "('tsukuro', None, '(954) 523-1407')\n",
      "('Thai Pattaya', None, '(727) 797-1069')\n",
      "('Panda Chinese Restaurant', None, '(904) 573-0087')\n",
      "('Ichiban Japanese Restaurant', None, '(941) 924-1611')\n",
      "('Sushi Rock Cafe', None, '(954) 462-5541')\n",
      "('Sushi House', None, '(904) 548-0688')\n",
      "(\"Wan's Sushi House\", None, '(954) 987-1388')\n",
      "('Mori Japanese Steakhouse', None, '(850) 386-8449')\n",
      "('Kobe Japanese Steak House', None, '(407) 248-1978')\n",
      "('Sushi-Haru', None, '(813) 962-4005')\n",
      "('Thep Thai Restaurant', None, '(772) 220-4998')\n",
      "('Siam Kitchen Sushi Thai', None, '(954) 565-0855')\n",
      "('Sushi Maki', None, '(305) 232-6636')\n",
      "('Tsunami Sushi & Hibachi Grill', None, '(813) 657-8988')\n",
      "('Tempura House', None, '(561) 883-6088')\n",
      "('Tokai Sushi Japanese Restaurant', None, '(813) 621-3332')\n"
     ]
    }
   ],
   "source": [
    "for result in YellowPage.crawl(\"sushi\", \"florida\"):\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quelques méthodes particulières (méthodes spéciales)\n",
    "\n",
    "- `__init__(self, ...)` : le constructeur : méthode d’initialisation nécessairement appelée quand on crée un objet. \n",
    "- `__del__(self)` : le destructeur, appelé quand une instance est sur le point d’être détruite.\n",
    "- `__repr__(self)` : chaîne représentant cet objet et qui devrait correspondre (quand c’est possible) à une expression Python valide pour créer l’objet.\n",
    "- `__str__(self)` : utilisée par `str()` pour obtenir la représentation sous forme d’une chaîne de caractères lisible de l’objet. Si non définie, retourne le résultat de `__repr__`.\n",
    "- `__new__(cls, ...)` : méthode implicitement statique qui crée l’objet (et appelle `__init__`).\n",
    "- `__bool__(self)` : utilisée quand l’objet est considéré comme booléen et avec la fonction prédéfinie `bool()`.\n",
    "- ..."
   ]
  }
 ],
 "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.8.2+"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}