isn/Parser_des_pages_internet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "IPython.Cell.options_default.cm_config.lineNumbers = true;"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%javascript\n",
    "IPython.Cell.options_default.cm_config.lineNumbers = true;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       "/* Pour le titre comme cela il n'y a pas de numérotation au */\n",
       "#titre{\n",
       "font-size: 24pt; \n",
       "color:#ff0000;\n",
       "text-decoration: underline;\n",
       "text-align: center;\n",
       "font-weight: bold;\n",
       "}\n",
       "\n",
       "div.text_cell_render { font-size: 12pt;   line-height: 145%; }\n",
       "div.text_cell_render h1{font-size: 24pt; color:#0000ff;  text-decoration: underline;}\n",
       "div.text_cell_render h2{font-size: 18pt;color:#0000ff;  text-decoration: underline;}\n",
       "div.text_cell_render h3{font-size: 14pt;color:#0000ff;  text-decoration: underline;}\n",
       "div.text_cell_render h4{font-size: 12pt;color:#0000ff;  text-decoration: underline; }\n",
       "div.text_cell_render h5 {font-weight: 300;}\n",
       "\n",
       "\n",
       "div.cell.code_cell { /* area that contains code + output */\n",
       "    background: #ffffff;\n",
       "    border: none;\n",
       "    border-radius: 10px;\n",
       "    padding-top: 1ex;\n",
       "}\n",
       "\n",
       "div.input_area { /* box around box with code */\n",
       "    border: none;\n",
       "    background: #f5f5f5;\n",
       "    border: 1px solid #ccc;\n",
       "    border-radius: 10px;\n",
       "    padding-top: 0.5ex;\n",
       "    padding-bottom: 0.5ex;\n",
       "    padding-left: 0.5em;\n",
       "}\n",
       "\n",
       "div.input { /* box with code */\n",
       "}\n",
       "\n",
       "div.CodeMirror { /* code font */\n",
       "    font-family: \"Inconsolata-dz\", monospace;\n",
       "    font-size: 10pt;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "/*div.text_cell_render  code { font-size: medium; border: 3px #ababab solid; background-color: #f5f5f5;}*/\n",
       "/*.rendered_html code { border: 3px #ababab solid; background-color:  #f5f5f5;}*/\n",
       ".rendered_html blockquote { margin: 1em 2em; background: red; }\n",
       ".rendered_html ol { list-style:decimal; margin: 1em 2em; }\n",
       "\n",
       "\n",
       "/* classe pour inverse video */\n",
       ".reverse{\n",
       "    background-color: black;\n",
       "    color: white;\n",
       "}\n",
       "/*  strick   <s>texte/<s>*/\n",
       ".barre{\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Charge ma feuille de style pour nbviewer\n",
    "from IPython.core.display import HTML\n",
    "from  urllib.request import urlopen\n",
    "# import urllib.request, urllib.parse, urllib.error\n",
    "\n",
    "url='https://github.com/debimax/cours-debimax/raw/master/static/custom.css'\n",
    "with urlopen(url) as response:\n",
    "    styles = response.read().decode(\"utf8\")\n",
    "styles=\"<style>\\n{}\\n</style>\".format(styles)\n",
    "HTML(styles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous aurons besoin pour cette leçon du module ***bs4***  \n",
    "Dans la console de pyzo taper:\n",
    "\n",
    "```bash\n",
    "pip install  bs4\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"titre\">Parser des pages internet</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La majorité des programmes de smartphone utlise des sites internet pour donner un resultat.  \n",
    "\n",
    "C'est ce que j'utilise dans ma deuxième cellule. On utilise le module ***urllib***. Nous utiliserons pour les recherche le module ***bs4.BeautifulSoup***\n",
    "\n",
    "Ouvrez pyzo puis dans la console écrire:\n",
    "\n",
    "```bash\n",
    "pip install bs4\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "# Exemple 1 avec le site du lycée.\n",
    "\n",
    "Ouvrez un navigateur puis dans un onglet aller sur [le site du lycée](http://www.ac-grenoble.fr/lycee/pabloneruda.smh/)\n",
    "\n",
    "\n",
    "## Récupérer le code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from urllib.request import urlopen\n",
    "from bs4 import BeautifulSoup\n",
    "url=\"http://www.ac-grenoble.fr/lycee/pabloneruda.smh/\"\n",
    "f = urlopen(url)\n",
    "html = f.read()\n",
    "soup = BeautifulSoup(html, \"html.parser\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## voir le code\n",
    "\n",
    "###  Méthode 1: avec python\n",
    "\n",
    "Si on veut voir le code html recu avec \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(soup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "attention celui du lycée est assez long.  \n",
    "Je préfère plustôt une autre méthode. Ouvrez ***firefox***  ou ***chrome*** et selectionner une partie du texte qui nous intéresse, par exemple le texte du premier évènements puis  \n",
    "\n",
    "### Méthode2:  Avec un inspecteur de code.\n",
    "\n",
    "- ***firefox***: clic droit -> Éxaminer l'élément\n",
    "- ***chrome***: clic droit -> Inspect\n",
    "\n",
    "<!-- ![title](./images/archi_10.jpg  \"ShowMyImage\") -->\n",
    "\n",
    " <img src=\"http://megamaths.hd.free.fr/~pi/statics/site-pablo.png\" alt=\"site-pablo\"  width=800/>\n",
    "\n",
    "Voici le texte qui nous interesse:\n",
    "\n",
    "```html\n",
    "<div class=\"descshort ic-decshort\">\n",
    "<i>Qu’est ce que Grenoble Energie Campus (GEC)? </i>\t\t\t\n",
    "<:div>\n",
    "```\n",
    "\n",
    "### Méthode3:  code source de la selection\n",
    "\n",
    "\n",
    "- Avec ***firefox*** On sélectionne la partie de la page internet qui nous intéresse puis clic droit -> code source de la selection et on obtient directement dans un onglet le code html qui nous intéresse.\n",
    "- Avec ***chrome*** cela necessite des extensions cependant avec le raccourci CTRL+U on obtient le code source de toute la page. \n",
    "\n",
    "\n",
    "\n",
    "```html\n",
    "<div class=\"title-header ic-title-header ic-float-left\">\n",
    "<h2>\n",
    "<a href=\"/lycee/pabloneruda.smh/index.php/110-qu-est-ce-que-grenoble-energie-campus-gec\" title=\"Qu’est ce que Grenoble Energie Campus (GEC)?\">Qu’est ce que Grenoble Energie Campus (GEC)?</a>\n",
    "</h2>\n",
    "</div>\n",
    "```\n",
    "\n",
    "Nous allons utiliser la classe de la balise \t&lt;div&gt; pour récupérer le texte."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analyser le code\n",
    "\n",
    "- ***find***(name=None, attrs={}, recursive=True, text=None, \\*\\*kwargs):  \n",
    "Retourne seulement le premier enfant de la balise correspondant pour le critère donné\n",
    "- ***find_all***(name=None, attrs={}, recursive=True, text=None, limit=None, \\*\\*kwargs):  \n",
    "Retourne une liste d'objet balise correspondant à la demande.\n",
    "\n",
    "\n",
    "On recherche la balse ***div*** ayant pour classe ***title-header ic-title-header ic-float-left\"***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "soup.find('div',attrs={\"class\":\"title-header ic-title-header ic-float-left\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pour obtenir le contenue de la balise &lt;a&gt; &lt;/a&gt;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "soup.find('div',attrs={\"class\":\"title-header ic-title-header ic-float-left\"}).a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-  Pour obtenir le texte contenue dans la balise &lt;a&gt; &lt;/a&gt;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "soup.find('div',attrs={\"class\":\"title-header ic-title-header ic-float-left\"}).a.text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Pour obtenir dans la balise &lt;a&gt; &lt;/a&gt;  le contenu de l'attribut ***href*** on utilise la méthode ***.get('href')***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "soup.find('div',attrs={\"class\":\"title-header ic-title-header ic-float-left\"}).a.get('href')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Pour obtenir dans la balise &lt;a&gt; &lt;/a&gt;  le contenu de l'attribut ***title***  on utilise la méthode ***.get('title')***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "soup.find('div',attrs={\"class\":\"title-header ic-title-header ic-float-left\"}).a.get('title')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pour obtenir le contenue de toutes les balises &lt;a&gt; &lt;/a&gt;\n",
    "\n",
    "On remplace ***soup.find*** par ***soup.find_all**, le résultat sera une liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in soup.find_all('div',attrs={\"class\":\"title-header ic-title-header ic-float-left\"}):\n",
    "    print(i.a.text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On aurais pu aussi utiliser une ***compréhension de  liste***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste= [i.a.text  for i in soup.find_all('div',attrs={\"class\":\"title-header ic-title-header ic-float-left\"})]\n",
    "print(liste)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exemple 2:  obtenir la liste des film de Charly chaplin\n",
    "\n",
    "Depuis le site [wikipedia](https://fr.wikipedia.org/wiki/Charlie_Chaplin) on essaye d'obtenir toute la liste des longs métrages de *Charlie Chaplin*.\n",
    "\n",
    "On utilise la même méthode que précédemment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from urllib.request import urlopen\n",
    "from bs4 import BeautifulSoup\n",
    "url=\"https://fr.wikipedia.org/wiki/Charlie_Chaplin\"\n",
    "\n",
    "f = urlopen(url)\n",
    "html = f.read()\n",
    "soup = BeautifulSoup(html, \"html.parser\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le problème ici est que la liste qui nous intéresse n'a pas d'***id***, c'est donc plus difficile.\n",
    "\n",
    "```html\n",
    "<h3><span class=\"mw-headline\" id=\"Longs_m.C3.A9trages\">Longs métrages</span></h3>\n",
    "<ul>\n",
    "<li><i><a href=\"/wiki/Le_Kid\" title=\"Le Kid\">Le Kid</a></i> (1921)</li>\n",
    "<li><i><a href=\"/wiki/L%27Opinion_publique\" title=\"L'Opinion publique\">L'Opinion publique</a></i> (1923)</li>\n",
    "<li><i><a href=\"/wiki/La_Ru%C3%A9e_vers_l%27or\" title=\"La Ruée vers l'or\">La Ruée vers l'or</a></i> (1925)</li>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "soup.find_all('h3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La balise &lt;h3&gt; n'a pas d'attribut mais la balise span si. Nous allons donc utiliser l'id de cette balise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "soup.find(id=\"Longs_m.C3.A9trages\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On utilise *find* à la place de *find_all*  car il y a unicité de l'*id*  dans une page internet.\n",
    "\n",
    "Nous utilisons ensuite la méthode ***parent*** pour remonter à la balise &lt;h3&gt; qui nous intéresse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "soup.find(id=\"Longs_m.C3.A9trages\").parent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et enfin nous utiliserons  la méthode  ***find_next_sibling()***  qui permet d'obtenir la balise suivante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "soup.find(id=\"Longs_m.C3.A9trages\").parent.find_next_sibling()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut ainsi ne récupérer que le texte."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "text=soup.find(id=\"Longs_m.C3.A9trages\").parent.find_next_sibling().text\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On doit obtenir:\n",
    "```python\n",
    "print(text)\n",
    "```\n",
    "\n",
    "Le Kid (1921)  \n",
    "L'Opinion publique (1923)  \n",
    "La Ruée vers l'or (1925)  \n",
    "Le Cirque (1928)  \n",
    "Les Lumières de la ville (1931)  \n",
    "Les Temps modernes (1936)  \n",
    "Le Dictateur (1940)  \n",
    "Monsieur Verdoux (1947)  \n",
    "Les Feux de la rampe (1952)  \n",
    "Un roi à New York (1957)  \n",
    "La Comtesse de Hong-Kong (1967)  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# 3 Exercice\n",
    "\n",
    "- Exercice 1: Obtenir la liste des équipes du classement de la [lidl starligue](http://mobile.ff-handball.org/championnats-nationaux/d1m/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from urllib.request import urlopen\n",
    "from bs4 import BeautifulSoup\n",
    "url=\"http://mobile.ff-handball.org/championnats-nationaux/d1m/\"\n",
    "f = urlopen(url)\n",
    "html = f.read()\n",
    "soup = BeautifulSoup(html, \"html.parser\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(soup)\n",
    "#  à finir\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Exercice 2: Choisir  [données](http://argonautica.jason.oceanobs.com/html/argonautica/affiche_donnees_fr.html)\n",
    "\n",
    "Afficher seulement la date, la longitude et la latitude de l'ours sakari."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from urllib.request import urlopen\n",
    "url=\"http://argonautica.jason.oceanobs.com/documents/argonautica/localisations/sakari/sakari.txt\"\n",
    "f = urlopen(url)\n",
    "html = f.read()\n",
    "donnees=html.decode('utf8')   # C'est du texte donc inutile de parser le code html\n",
    "donnees=donnees.splitlines()    # On coupe le texte pour obtenir une liste de chaque lignes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(soup)\n",
    "# à finir\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Exercice 3:  Déterminer la liste du numero et du nom de toutes les chaînes de votre box.\n",
    " -  freebox: [http://free.fr/freebox/television.html#basique](http://free.fr/freebox/television.html#basique)\n",
    " -  orange [https://chaines-tv.orange.fr/#live/home](https://chaines-tv.orange.fr/#live/home)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from urllib.request import urlopen\n",
    "from bs4 import BeautifulSoup\n",
    "url=\"http://free.fr/freebox/television.html#basique\"\n",
    "f = urlopen(url)\n",
    "html = f.read()\n",
    "soup = BeautifulSoup(html, \"html.parser\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(soup)\n",
    "#  à finir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Exercice 4:   Déterminer les valeurs en € des entreprises du cac 40 sur le site  [http://www.boursier.com/actions/paris](http://www.boursier.com/actions/paris)  \n",
    "*aide: J'ai à nouveau utiliser .parent.find_next_sibling()*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from urllib.request import urlopen\n",
    "from bs4 import BeautifulSoup\n",
    "url=\"http://www.boursier.com/actions/paris\"\n",
    "f = urlopen(url)\n",
    "html = f.read()\n",
    "soup = BeautifulSoup(html, \"html.parser\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(soup)\n",
    "#  à finir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les méthodes de la classe BeautifulSoup\n",
    "\n",
    "[Ref: http://apprendre-python.com/page-beautifulsoup-html-parser-python-library-xml](http://apprendre-python.com/page-beautifulsoup-html-parser-python-library-xml)\n",
    "\n",
    "- ***clear***(decompose=False):  \n",
    "Extrait tous les enfants\n",
    "-  ***decode_contents***(indent_level=None, eventual_encoding='utf-8', formatter='minimal'):  \n",
    "Créer un rendu en chaine unicode\n",
    "- ***decompose()***:  \n",
    "Detruit récursivement les contenus de l'arbre\n",
    "- ***encode***(encoding='utf-8', indent_level=None, formatter='minimal', errors='xmlcharrefreplace'):  \n",
    "encode\n",
    "- ***encode_contents***(indent_level=None, encoding='utf-8', formatter='minimal'):  \n",
    "Créer des rendus du tag en bytestring\n",
    "- ***find***(name=None, attrs={}, recursive=True, text=None, \\*\\*kwargs):  \n",
    "Retourne seulement le premier enfant de la balise correspondant pour le critère donné\n",
    "- ***find_all***(name=None, attrs={}, recursive=True, text=None, limit=None, \\*\\*kwargs):  \n",
    "Retourne une liste d'objet balise correspondant à la demande.\n",
    "- ***find***(name=None, attrs={}, recursive=True, text=None, \\*\\*kwargs): \n",
    "Retourne seulement le premier enfant de la balise cherchée\n",
    "- ***findChildren***(name=None, attrs={}, recursive=True, text=None, limit=None, \\*\\*kwargs):  \n",
    "Retourne une liste d'objet balise correspondant à la demande\n",
    "- ***get***(key, default=None):  \n",
    "Retourne la valeur de l'attribut \"key\" de la balise ou retourne la valeur default\n",
    "- ***get_text***(self, separator='', strip=False, types=(<class 'bs4.element.NavigableString'>, <class 'bs4.element.CData'>)):  \n",
    "Retourne toutes les chaines de caractères des enfants concaténé utilisant le séparateur indiqué\n",
    "- ***has_attr(key)***:  \n",
    "True si l'attribut demandé est présent\n",
    "- ***has_key***(key):  \n",
    "Vérifie la présence de la clé\n",
    "-  ***index***(element):  \n",
    "Retourne l'index de l'élément\n",
    "-  ***prettify***(self, encoding=None, formatter='minimal'):  \n",
    "Améliore la lecture du code \n",
    "-  ***append***(self, tag):  \n",
    "Ajoute la balise donnée à l'objet en cours\n",
    "-  ***extract()***:  \n",
    "Extrait l'élément de l'arbre\n",
    "-  ***find_next_siblings***(self, name=None, attrs={}, text=None, limit=None, \\*\\*kwargs):   \n",
    "Renvoi les objects frères de l'objet en cours\n",
    "-  ***find_parents***(self, name=None, attrs={}, limit=None, \\*\\*kwargs):  \n",
    "Renvoi les parents\n",
    "- ***find_all_previous***(self, name=None, attrs={}, text=None, limit=None, \\*\\*kwargs):  \n",
    "Retourne tous les items qui match avec le critère donné avant l'objet en cours\n",
    "- ***find_previous_siblings***(self, name=None, attrs={}, text=None, limit=None, \\*\\*kwargs):  \n",
    "Retourne les objets frères de l'objet en cours qui sont avant celui-ci\n",
    "-  ***find_all_next***(self, name=None, attrs={}, text=None, limit=None, \\*\\*kwargs):  \n",
    "Retourne les objets qui correpondent à la recherche mais qui se situent après l'objet en cours\n",
    "-  ***find_all_previous***(self, name=None, attrs={}, text=None, limit=None, \\*\\*kwargs):  \n",
    "Retourne les objets qui correspondent à la recherche mais qui se situent avant l'objet en cours\n",
    "-  ***find_next***(self, name=None, attrs={}, text=None, \\*\\*kwargs):  \n",
    "Retourne le premier objet frère après l'objet en cours\n",
    "-  ***find_next_sibling***(self, name=None, attrs={}, text=None, \\*\\*kwargs):  \n",
    "Retourne l'objet frère le plus proche après lui\n",
    "-  **find_next_siblings***(self, name=None, attrs={}, text=None, limit=None, \\*\\*kwargs):  \n",
    "Retourne les objets frères suivants\n",
    "-  ***find_parent***(self, name=None, attrs={}, \\*\\*kwargs):  \n",
    "Retourne le parent le plus proche\n",
    "-  ***find_parents***(self, name=None, attrs={}, limit=None, \\*\\*kwargs):  \n",
    "Retourne les parents\n",
    "-  ***find_previous***(self, name=None, attrs={}, text=None, \\*\\*kwargs):  \n",
    "Retourne le premier item avant l'objet en cours\n",
    "-  ***find_previous_sibling***(self, name=None, attrs={}, text=None, \\*\\*kwargs):  \n",
    "Retourne l'item frère le plus proche précédent l'objet en cours\n",
    "-  ***find_previous_siblings***(self, name=None, attrs={}, text=None, limit=None, \\*\\*kwargs):  \n",
    "Retourne les items frères les plus proches précédents l'objet en cours\n",
    "-  ***find_all_next***(self, name=None, attrs={}, text=None, limit=None, \\*\\*kwargs):  \n",
    "Retourne tous les items qui suivent l'objet en cours\n",
    "-  ***find_all_previous***(self, name=None, attrs={}, text=None, limit=None, \\*\\*kwargs):  \n",
    "Retourne tous les items qui précédent l'objet en cours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pour aller plus loin  utilisation du module  re\n",
    "\n",
    "Ce module est bien plus difficile à bien utiliser mais c'est bien lui que je préfère  car c'est le plus efficace.  \n",
    "On peut tout faire avec des expressions régulières (***regex***  ou ***motif***  en français)\n",
    "\n",
    "Lisez bien la partie *expressions régulières*   sur [mon memento](https://github.com/debimax/cours-debimax/raw/master/documents/memento_python.pdf)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import re\n",
    "from urllib.request import urlopen\n",
    "url=\"https://fr.wikipedia.org/wiki/Charlie_Chaplin\"\n",
    "\n",
    "f = urlopen(url)\n",
    "html = f.read()\n",
    "code=html.decode('utf8')\n",
    "\n",
    "liste=re.findall(r\"<h3><span class=\\\"mw-headline\\\" id=\\\"Longs_m.C3.A9trages\\\">.*?(<ul>.*?</ul>)\", code,re.DOTALL)\n",
    "print(liste)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voici ce que fait ma regex.\n",
    "\n",
    "- ```html \n",
    "<h3><span class=\\\"mw-headline\\\" id=\\\"Longs_m.C3.A9trages\\\">    Le code doit commencer par <h3><span class=\"mw-headline\" id=\"Longs_m.C3.A9trages\">\n",
    "```\n",
    "- ```html\n",
    ".*?(<ul>         n'import quel caractère (.) au moins (*)  jusqu'à la première (?) balise <ul>.\n",
    "```     \n",
    "- ```html\n",
    ".*?</ul>)        n'importe quel caractère (.)  au moins (*)  jusqu'à la première (?) balise </ul>.  \n",
    "```  \n",
    "- ```html\n",
    "On ne récupère que le texte qu'il y a entre les parenthèses (<ul>.*?</ul>), c'est à dire ici entre les balises <ul> et  </ul>. \n",
    "```\n",
    "- ```html\n",
    "L'option re.DOTALL est utilisé parceque la recherche se fait sur plusieurs lignes.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il ne reste plus qu'à enlever les balises html.  \n",
    "Étant donné que nous avons utilisé le module ***re***, nous utiliserons encore ce même module.\n",
    "\n",
    "```python\n",
    "liste=re.sub(r'<[^>]+>', '', liste[0])\n",
    "print(liste)\n",
    "```\n",
    "\n",
    "Un peu d'explication:\n",
    "\n",
    "- ```html\n",
    "<            Un caractère <\n",
    "```\n",
    "- ```html\n",
    "[^>]+        Un caractère qui n'est pas >  au moins une fois (+).\n",
    "```\n",
    "- ```html\n",
    ">            Le caractère >\n",
    "```  \n",
    "\n",
    "\n",
    "On remplace toutes les balises par \"\", donc on enlève tout."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "```python\n",
    "liste=re.sub(r'<[^>]+>', '', liste[0])\n",
    "print(liste)\n",
    "``` \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "liste=re.sub(r'<[^>]+>', '', liste[0])\n",
    "print(liste)"
   ]
  }
 ],
 "metadata": {
  "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.3rc1"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "navigate_num": "#000000",
    "navigate_text": "#333333",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700",
    "sidebar_border": "#EEEEEE",
    "wrapper_background": "#FFFFFF"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "228px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": false,
   "widenNotebook": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}