Python pour la data science

Lino Galiana

doi:10.5281/zenodo.8229676

Le web scraping désigne les techniques d’extraction du contenu des sites internet. C’est une pratique très utile pour toute personne souhaitant travailler sur des informations disponibles en ligne, mais n’existant pas forcément sous la forme d’un tableau Excel.

Ce TP vous présente comment créer et exécuter des robots afin de recupérer rapidement des informations utiles à vos projets actuels ou futurs. Il part de quelques cas d’usages concret. Ce chapitre est très fortement inspiré et réadapté à partir de celui de Xavier Dupré, l’ancien professeur de la matière.

Enjeux

Un certain nombre d’enjeux du web scraping ne seront évoqués que superficiellement dans le cadre de ce chapitre.

La zone grise de la légalité du web scraping

En premier lieu, en ce qui concerne la question de la légalité de la récupération d’information par scraping, il existe une zone grise. Ce n’est pas parce qu’une information est disponible sur internet, directement ou avec un peu de recherche, qu’elle peut être récupérée et réutilisée.

L’excellent cours d’Antoine Palazzolo évoque un certain nombre de cas médiatiques et judiciaires sur cette question. Dans le champ français, la CNIL a publié en 2020 de nouvelles directives sur le web scraping reprécisant que toute donnée ne peut être réutilisée à l’insu de la personne à laquelle ces données appartiennent. Autrement dit, en principe, les données collectées par web scraping sont soumises au RGPD, c’est-à-dire nécessitent le consentement des personnes à partir desquelles la réutilisation des données est faite.

Il est donc recommandé d’être vigilant avec les données récupérées par web scraping pour ne pas se mettre en faute légalement.

Stabilité et fiabilité des informations reçues

La récupération de données par web scraping est certes pratique mais elle ne correspond pas nécessairement à un usage pensé, ou désiré, par un fournisseur de données. Les données étant coûteuses à collecter et à mettre à disposition, certains sites ne désirent pas nécessairement que celles-ci soient extraites gratuitement et facilement. A fortiori lorsque la donnée peut permettre à un concurrent de disposer d’une information utile d’un point de vue commercial (prix d’un produit concurrent, etc.).

Les acteurs mettent donc souvent en oeuvre des stratégies pour bloquer ou limiter la quantité de données scrapées. La méthode la plus classique est la détection et le blocage des requêtes faites par des robots plutôt que par des humains. Pour des acteurs spécialisés, cette détection est très facile car de nombreuses preuves permettent d’identifier si une visite du site web provient d’un utilisateur humain derrière un navigateur ou d’un robot. Pour ne citer que quelques indices : vitesse de la navigation entre pages, rapidité à extraire la donnée, empreinte digitale du navigateur utilisé, capacité à répondre à des questions aléatoires (captcha)… Les bonnes pratiques, évoquées par la suite, ont pour objectif de faire en sorte qu’un robot se comporte de manière civile en adoptant un comportement proche de celui de l’humain mais sans contrefaire le fait qu’il ne s’agit pas d’un humain.

Il convient d’ailleurs d’être prudent quant aux informations reçues par web scraping. La donnée étant au coeur du modèle économique de certains acteurs, certains n’hésitent pas à renvoyer des données fausses aux robots plutôt que les bloquer. C’est de bonne guerre ! Une autre technique piège s’appelle le honey pot. Il s’agit de pages qu’un humain n’irait jamais visiter - par exemple parce qu’elles n’apparaissent pas dans l’interface graphique - mais sur lesquelles un robot, en recherche automatique de contenu, va rester bloquer.

Sans aller jusqu’à la stratégie de blocage du web scraping, d’autres raisons peuvent expliquer qu’une récupération de données ait fonctionné par le passé mais ne fonctionne plus. La plus fréquente est un changement dans la structure d’un site web. Le web scraping présente en effet l’inconvénient d’aller chercher de l’information dans une structure très hiérarchisée. Un changement dans cette structure peut suffire à rendre un robot incapable de récupérer du contenu. Or, pour rester attractifs, les sites web changent fréquemment ce qui peut facilement rendre inopérant un robot.

De manière générale, l’un des principaux messages de ce chapitre, à retenir, est que le web scraping est une solution de dernier ressort, pour des récupérations ponctuelles de données sans garantie de fonctionnement ultérieur. Il est préférable de privilégier les API lorsque celles-ci sont disponibles. Ces dernières ressemblent à un contrat (formel ou non) entre un fournisseur de données et un utilisateur où sont définis des besoins (les données) mais aussi des conditions d’accès (nombre de requêtes, volumétrie, authentification…) là où le web scraping est plus proche du comportement dans le Far West.

Les bonnes pratiques

La possibilité de récupérer des données par l’intermédiaire d’un robot ne signifie pas qu’on peut se permettre de ne pas être civilisé. En effet, lorsqu’il est non-maîtrisé, le web scraping peut ressembler à une attaque informatique classique pour faire sauter un site web : le déni de service. Le cours d’Antoine Palazzolo revient sur certaines bonnes pratiques qui ont émergé dans la communauté des scrapeurs. Il est recommandé de lire cette ressource pour en apprendre plus sur ce sujet. Y sont évoquées plusieurs conventions, parmi lesquelles :

Se rendre, depuis la racine du site, sur le fichier robots.txt pour vérifier les consignes proposées par les développeurs du site web pour cadrer le comportement des robots ;
Espacer chaque requêtes de plusieurs secondes, comme le ferait un humain, afin d’éviter de surcharger le site web et de le faire sauter par déni de service ;
Faire les requêtes dans les heures creuses de fréquentation du site web s’il ne s’agit pas d’un site consulté internationalement. Par exemple, pour un site en français, lancer le robot pendant la nuit en France métropolitaine, est une bonne pratique. Pour lancer un robot depuis Python à une heure programmée à l’avance, il existe les cronjobs.

Un détour par le Web : comment fonctionne un site ?

Même si ce TP ne vise pas à faire un cours de web, il vous faut néanmoins certaines bases sur la manière dont un site internet fonctionne afin de comprendre comment sont structurées les informations sur une page.

Un site Web est un ensemble de pages codées en HTML qui permet de décrire à la fois le contenu et la forme d’une page Web.

Pour voir cela, ouvrez n’importe quelle page web et faites un clic-droit dessus. - Sous Chrome : Cliquez ensuite sur “Affichez le code source de la page” (CTRL+U) ; - Sous Firefox : “Code source de la page” (CTRL+MAJ+K) ; - Sous Edge : “Affichez la page source” (CTRL+U) ; - Sous Safari : voir comment faire ici

Si vous savez quel élément vous intéresse, vous pouvez également ouvrir l’inspecteur du navigateur (clic droit sur l’élément + “Inspecter”), pour afficher les balises encadrant votre élément de façon plus ergonomique, un peu comme un zoom.

Les balises

Sur une page web, vous trouverez toujours à coup sûr des éléments comme <head>, <title>, etc. Il s’agit des codes qui vous permettent de structurer le contenu d’une page HTML et qui s’appellent des balises. Citons, par exemple, les balises <p>, <h1>, <h2>, <h3>, <strong> ou <em>. Le symbole < > est une balise : il sert à indiquer le début d’une partie. Le symbole </ > indique la fin de cette partie. La plupart des balises vont par paires, avec une balise ouvrante et une balise fermante (par exemple <p> et </p>).

Par exemple, les principales balises définissant la structure d’un tableau sont les suivantes :

Balise	Description
`<table>`	Tableau
`<caption>`	Titre du tableau
`<tr>`	Ligne de tableau
`<th>`	Cellule d’en-tête
`<td>`	Cellule
`<thead>`	Section de l’en-tête du tableau
`<tbody>`	Section du corps du tableau
`<tfoot>`	Section du pied du tableau

Application : un tableau en HTML

Le code HTML du tableau suivant :

<table>
<caption> Le Titre de mon tableau </caption>

   <tr>
      <th>Prénom</th>
      <th>Nom</th>
      <th>Profession</th>
   </tr>
   <tr>
      <td>Mike </td>
      <td>Stuntman</td>
      <td>Cascadeur</td>
   </tr>
   <tr>
      <td>Mister</td>
      <td>Pink</td>
      <td>Gangster</td>
   </tr>
</table>

Donnera dans le navigateur :

Le Titre de mon tableau
Prénom	Nom	Profession
Mike	Stuntman	Cascadeur
Mister	Pink	Gangster

Parent et enfant

Dans le cadre du langage HTML, les termes de parent (parent) et enfant (child) servent à désigner des élements emboîtés les uns dans les autres. Dans la construction suivante, par exemple :

<div> 
    <p>
       bla,bla
    </p>
</div>

Sur la page web, cela apparaitra de la manière suivante :

bla,bla

On dira que l’élément <div> est le parent de l’élément <p> tandis que l’élément <p> est l’enfant de l’élément <div>.

Mais pourquoi apprendre ça pour “scraper” ?

Parce que, pour bien récupérer les informations d’un site internet, il faut pouvoir comprendre sa structure et donc son code HTML. Les fonctions Python qui servent au scraping sont principalement construites pour vous permettre de naviguer entre les balises. Avec Python, vous allez en fait reproduire votre comportement manuel de recherche de manière à l’automatiser.

Scraper avec `Python`: le package `BeautifulSoup`

Les packages disponibles

Dans la première partie de ce chapitre, nous allons essentiellement utiliser le package BeautifulSoup4, en conjonction avec urllib ou requests. Ces deux derniers packages permettent de récupérer le texte brut d’une page qui sera ensuite inspecté via BeautifulSoup4.

BeautifulSoup sera suffisant quand vous voudrez travailler sur des pages HTML statiques. Dès que les informations que vous recherchez sont générées via l’exécution de scripts Javascript, il vous faudra passer par des outils comme Selenium.

De même, si vous ne connaissez pas l’URL, il faudra passer par un framework comme Scrapy, qui passe facilement d’une page à une autre. On appelle cette technique le “web crawling”. Scrapy est plus complexe à manipuler que BeautifulSoup : si vous voulez plus de détails, rendez-vous sur la page du tutoriel Scrapy.

Le web scraping est un domaine où la reproductibilité est compliquée à mettre en oeuvre. Une page web évolue potentiellement régulièrement et d’une page web à l’autre, la structure peut être très différente ce qui rend certains codes difficilement exportables. Par conséquent, la meilleure manière d’avoir un programme fonctionnel est de comprendre la structure d’une page web et dissocier les éléments exportables à d’autres cas d’usages des requêtes ad hoc.

!pip install -q lxml

import bs4
import lxml
import pandas
import urllib

from urllib import request

WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv

Note

Pour être en mesure d’utiliser Selenium, il est nécessaire de faire communiquer Python avec un navigateur web (Firefox ou Chromium). Le package webdriver-manager permet de faire savoir à Python où se trouve ce navigateur s’il est déjà installé dans un chemin standard. Pour l’installer, le code de la cellule ci-dessous peut être utilisé.

Pour faire fonctionner Selenium, il faut utiliser un package nommé webdriver-manager:

!pip install webdriver-manager

Collecting webdriver-manager
  Obtaining dependency information for webdriver-manager from https://files.pythonhosted.org/packages/b1/51/b5c11cf739ac4eecde611794a0ec9df420d0239d51e73bc19eb44f02b48b/webdriver_manager-4.0.1-py2.py3-none-any.whl.metadata
  Downloading webdriver_manager-4.0.1-py2.py3-none-any.whl.metadata (12 kB)
Requirement already satisfied: requests in /opt/mamba/lib/python3.9/site-packages (from webdriver-manager) (2.31.0)
Collecting python-dotenv (from webdriver-manager)
  Downloading python_dotenv-1.0.0-py3-none-any.whl (19 kB)
Requirement already satisfied: packaging in /opt/mamba/lib/python3.9/site-packages (from webdriver-manager) (21.3)
Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/mamba/lib/python3.9/site-packages (from packaging->webdriver-manager) (3.0.9)
Requirement already satisfied: charset-normalizer<4,>=2 in /opt/mamba/lib/python3.9/site-packages (from requests->webdriver-manager) (2.1.1)
Requirement already satisfied: idna<4,>=2.5 in /opt/mamba/lib/python3.9/site-packages (from requests->webdriver-manager) (3.3)
Requirement already satisfied: urllib3<3,>=1.21.1 in /opt/mamba/lib/python3.9/site-packages (from requests->webdriver-manager) (1.26.11)
Requirement already satisfied: certifi>=2017.4.17 in /opt/mamba/lib/python3.9/site-packages (from requests->webdriver-manager) (2022.9.24)
Downloading webdriver_manager-4.0.1-py2.py3-none-any.whl (27 kB)
Installing collected packages: python-dotenv, webdriver-manager
Successfully installed python-dotenv-1.0.0 webdriver-manager-4.0.1
WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv

Récupérer le contenu d’une page HTML

On va commencer doucement. Prenons une page wikipedia, par exemple celle de la Ligue 1 de football, millésime 2019-2020 : Championnat de France de football 2019-2020. On va souhaiter récupérer la liste des équipes, ainsi que les url des pages Wikipedia de ces équipes.

Etape 1️⃣ : se connecter à la page wikipedia et obtenir le code source. Pour cela, le plus simple est d’utiliser le package urllib ou, mieux, requests. Nous allons ici utiliser la fonction request du package urllib:

url_ligue_1 = "https://fr.wikipedia.org/wiki/Championnat_de_France_de_football_2019-2020"
    
request_text = request.urlopen(url_ligue_1).read()
# print(request_text[:1000])

type(request_text)

bytes

Etape 2️⃣ : utiliser le package BeautifulSoup qui permet de rechercher efficacement les balises contenues dans la chaine de caractères renvoyée par la fonction request:

page = bs4.BeautifulSoup(request_text, "lxml")

Si on print l’objet page créée avec BeautifulSoup, on voit que ce n’est plus une chaine de caractères mais bien une page HTML avec des balises. On peut à présent chercher des élements à l’intérieur de ces balises.

La méthode `find`

Par exemple, si on veut connaître le titre de la page, on utilise la méthode .find et on lui demande “title”

print(page.find("title"))

<title>Championnat de France de football 2019-2020 — Wikipédia</title>

La methode .find ne renvoie que la première occurence de l’élément.

Pour vous en assurer vous pouvez :

copier le bout de code source obtenu lorsque vous chercher une table,
le coller dans une cellule de votre notebook
et passer la cellule en “Markdown”

La cellule avec le copier-coller du code source donne :

print(page.find("table"))

<table><caption style="background-color:#99cc99;color:#000000;">Généralités</caption><tbody><tr>
<th scope="row" style="width:10.5em;">Sport</th>
<td>
<a href="/wiki/Football" title="Football">Football</a></td>
</tr>
<tr>
<th scope="row" style="width:10.5em;">Organisateur(s)</th>
<td>
<a href="/wiki/Ligue_de_football_professionnel_(France)" title="Ligue de football professionnel (France)">LFP</a></td>
</tr>
<tr>
<th scope="row" style="width:10.5em;">Édition</th>
<td>
<abbr class="abbr" title="Quatre-vingt-deuxième (huitante-deuxième / octante-deuxième)">82<sup>e</sup></abbr></td>
</tr>
<tr>
<th scope="row" style="width:10.5em;">Lieu(x)</th>
<td>
<span class="datasortkey" data-sort-value="France"><span class="flagicon"><span class="mw-image-border noviewer" typeof="mw:File"><a class="mw-file-description" href="/wiki/Fichier:Flag_of_France.svg" title="Drapeau de la France"><img alt="Drapeau de la France" class="mw-file-element" data-file-height="600" data-file-width="900" decoding="async" height="13" src="//upload.wikimedia.org/wikipedia/commons/thumb/c/c3/Flag_of_France.svg/20px-Flag_of_France.svg.png" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/c/c3/Flag_of_France.svg/30px-Flag_of_France.svg.png 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/c/c3/Flag_of_France.svg/40px-Flag_of_France.svg.png 2x" width="20"/></a></span> </span><a href="/wiki/France" title="France">France</a></span> et <br/><span class="datasortkey" data-sort-value="Monaco"><span class="flagicon"><span class="mw-image-border noviewer" typeof="mw:File"><a class="mw-file-description" href="/wiki/Fichier:Flag_of_Monaco.svg" title="Drapeau de Monaco"><img alt="Drapeau de Monaco" class="mw-file-element" data-file-height="800" data-file-width="1000" decoding="async" height="16" src="//upload.wikimedia.org/wikipedia/commons/thumb/e/ea/Flag_of_Monaco.svg/20px-Flag_of_Monaco.svg.png" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/e/ea/Flag_of_Monaco.svg/30px-Flag_of_Monaco.svg.png 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/e/ea/Flag_of_Monaco.svg/40px-Flag_of_Monaco.svg.png 2x" width="20"/></a></span> </span><a href="/wiki/Monaco" title="Monaco">Monaco</a></span></td>
</tr>
<tr>
<th scope="row" style="width:10.5em;">Date</th>
<td>
Du <time class="nowrap date-lien" data-sort-value="2019-08-09" datetime="2019-08-09"><a href="/wiki/9_ao%C3%BBt_en_sport" title="9 août en sport">9</a> <a class="mw-redirect" href="/wiki/Ao%C3%BBt_2019_en_sport" title="Août 2019 en sport">août</a> <a href="/wiki/2019_en_football" title="2019 en football">2019</a></time><br/>au <time class="nowrap date-lien" data-sort-value="2020-03-08" datetime="2020-03-08"><a href="/wiki/8_mars_en_sport" title="8 mars en sport">8 mars</a> <a href="/wiki/2020_en_football" title="2020 en football">2020</a></time> <small>(arrêt définitif)</small></td>
</tr>
<tr>
<th scope="row" style="width:10.5em;">Participants</th>
<td>
20 équipes</td>
</tr>
<tr>
<th scope="row" style="width:10.5em;">Matchs joués</th>
<td>
279 (sur 380 prévus)</td>
</tr>
<tr>
<th scope="row" style="width:10.5em;">Site web officiel</th>
<td>
<a class="external text" href="https://www.ligue1.fr/" rel="nofollow">Site officiel</a></td>
</tr></tbody></table>

ce qui est le texte source permettant de générer le tableau suivant :

Généralités
Sport	Football
Organisateur(s)	LFP
Édition	82^e
Lieu(x)	France et Monaco
Date	Du 9 août 2019 au 8 mars 2020 (arrêt définitif)
Participants	20 équipes
Matchs joués	279 (sur 380 prévus)
Site web officiel	Site officiel

La méthode `findAll`

Pour trouver toutes les occurences, on utilise .findAll().

print("Il y a", len(page.findAll("table")), "éléments dans la page qui sont des <table>")

Il y a 34 éléments dans la page qui sont des <table>

Exercice guidé : obtenir la liste des équipes de Ligue 1

Dans le premier paragraphe de la page “Participants”, on a le tableau avec les résultats de l’année.

Exercice 1 : Récupérer les participants de la Ligue 1

Pour cela, nous allons procéder en 6 étapes:

Trouver le tableau
Récupérer chaque ligne du table
Nettoyer les sorties en ne gardant que le texte sur une ligne
Généraliser sur toutes les lignes
Récupérer les entêtes du tableau
Finalisation du tableau

1️⃣ Trouver le tableau

# on identifie le tableau en question : c'est le premier qui a cette classe "wikitable sortable"
tableau_participants = page.find('table', {'class' : 'wikitable sortable'})

print(tableau_participants)

Club	Dernière montée	Budget^[3] en M€	Classement 2018-2019	Entraîneur	Depuis	Stade	Capacité en L1^[4]	Nombre de saisons en L1
Paris Saint-Germain	1974	637	1^er	Thomas Tuchel	2018	Parc des Princes	47 929	46
LOSC Lille	2000	120	2^e	Christophe Galtier	2017	Stade Pierre-Mauroy	49 712	59
Olympique lyonnais	1989	310	3^e	Rudi Garcia	2019	Groupama Stadium	57 206	60
AS Saint-Étienne	2004	100	4^e	Claude Puel	2019	Stade Geoffroy-Guichard	41 965	66
Olympique de Marseille	1996	110	5^e	André Villas-Boas	2019	Orange Vélodrome	66 226	69
Montpellier HSC	2009	40	6^e	Michel Der Zakarian	2017	Stade de la Mosson	22 000	27
OGC Nice	2002	50	7^e	Patrick Vieira	2018	Allianz Riviera	35 596	60
Stade de Reims	2018	45	8^e	David Guion	2017	Stade Auguste-Delaune	20 546	35
Nîmes Olympique	2018	27	9^e	Bernard Blaquart	2015	Stade des Costières	15 788	35
Stade rennais FC	1994	65	10^e	Julien Stéphan	2018	Roazhon Park	29 194	62
RC Strasbourg Alsace	2017	43	11^e	Thierry Laurey	2016	Stade de la Meinau	26 109	58
FC Nantes	2013	70	12^e	Christian Gourcuff	2019	Stade de la Beaujoire - Louis Fonteneau	35 322	51
SCO d’Angers	2015	32	13^e	Stéphane Moulin	2011	Stade Raymond-Kopa	14 582	27
Girondins de Bordeaux	1992	70	14^e	Paulo Sousa	2019	Matmut Atlantique	42 115	66
Amiens SC	2017	30	15^e	Luka Elsner	2019	Stade Crédit Agricole la Licorne	12 999	2
Toulouse FC	2003	35	16^e	Denis Zanko	2020	Stadium de Toulouse	33 033	32
AS Monaco	2013	220	17^e	Robert Moreno	2019	Stade Louis-II	16 500	60
Dijon FCO	2016	38	18^e	Stéphane Jobard	2019	Parc des Sports Gaston-Gérard	15 459	4
FC Metz	2019	40	1^er (Ligue 2)	Vincent Hognon	2019	Stade Saint-Symphorien	25 865	61
Stade brestois 29	2019	30	2^e (Ligue 2)	Olivier Dall’Oglio	2019	Stade Francis-Le Blé	14 920	13

2️⃣ Récupérer chaque ligne du tableau

On recherche d’abord toutes les lignes du tableau avec la balise tr

table_body = tableau_participants.find('tbody')
rows = table_body.find_all('tr')

On obtient une liste où chaque élément est une des lignes du tableau Pour illustrer cela, on va d’abord afficher la première ligne. Celle-ci correspont aux entêtes de colonne:

print(rows[0])

<tr>
<th scope="col">Club
</th>
<th scope="col">Dernière<br/>montée
</th>
<th scope="col">Budget<sup class="reference" id="cite_ref-3"><a href="#cite_note-3"><span class="cite_crochet">[</span>3<span class="cite_crochet">]</span></a></sup><br/>en M<a href="/wiki/Euro" title="Euro">€</a>
</th>
<th scope="col">Classement<br/><a href="/wiki/Championnat_de_France_de_football_2018-2019" title="Championnat de France de football 2018-2019">2018-2019</a>
</th>
<th scope="col">Entraîneur
</th>
<th scope="col">Depuis
</th>
<th scope="col">Stade
</th>
<th scope="col">Capacité<br/>en L1<sup class="reference" id="cite_ref-4"><a href="#cite_note-4"><span class="cite_crochet">[</span>4<span class="cite_crochet">]</span></a></sup>
</th>
<th scope="col">Nombre<br/>de saisons<br/>en L1
</th></tr>

La seconde ligne va correspondre à la ligne du premier club présent dans le tableau :

print(rows[1])

<tr bgcolor="#97DEFF">
<td><a href="/wiki/Paris_Saint-Germain_Football_Club" title="Paris Saint-Germain Football Club">Paris Saint-Germain</a>
</td>
<td>1974
</td>
<td>637
</td>
<td><span data-sort-value="101 !"></span><abbr class="abbr" title="Premier">1<sup>er</sup></abbr>
</td>
<td align="left"><span class="flagicon"><span class="mw-image-border noviewer" typeof="mw:File"><a class="mw-file-description" href="/wiki/Fichier:Flag_of_Germany.svg" title="Drapeau : Allemagne"><img alt="" class="mw-file-element" data-file-height="600" data-file-width="1000" decoding="async" height="12" src="//upload.wikimedia.org/wikipedia/commons/thumb/b/ba/Flag_of_Germany.svg/20px-Flag_of_Germany.svg.png" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/b/ba/Flag_of_Germany.svg/30px-Flag_of_Germany.svg.png 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/b/ba/Flag_of_Germany.svg/40px-Flag_of_Germany.svg.png 2x" width="20"/></a></span></span> <a href="/wiki/Thomas_Tuchel" title="Thomas Tuchel">Thomas Tuchel</a>
</td>
<td>2018
</td>
<td><a href="/wiki/Parc_des_Princes" title="Parc des Princes">Parc des Princes</a>
</td>
<td>47 929
</td>
<td>46
</td></tr>

3️⃣ Nettoyer les sorties en ne gardant que le texte sur une ligne

On va utiliser l’attribut text afin de se débarasser de toute la couche de HTML qu’on obtient à l’étape 2.

Un exemple sur la ligne du premier club : - on commence par prendre toutes les cellules de cette ligne, avec la balise td. - on fait ensuite une boucle sur chacune des cellules et on ne garde que le texte de la cellule avec l’attribut text. - enfin, on applique la méthode strip() pour que le texte soit bien mis en forme (sans espace inutile etc).

cols = rows[1].find_all('td')
print(cols[0])
print(cols[0].text.strip())

<td><a href="/wiki/Paris_Saint-Germain_Football_Club" title="Paris Saint-Germain Football Club">Paris Saint-Germain</a>
</td>
Paris Saint-Germain

for ele in cols : 
    print(ele.text.strip())

Paris Saint-Germain
1974
637
1er
Thomas Tuchel
2018
Parc des Princes
47 929
46

4️⃣ Généraliser sur toutes les lignes :

for row in rows:
    cols = row.find_all('td')
    cols = [ele.text.strip() for ele in cols]
    print(cols)

[]
['Paris Saint-Germain', '1974', '637', '1er', 'Thomas Tuchel', '2018', 'Parc des Princes', '47\xa0929', '46']
['LOSC Lille', '2000', '120', '2e', 'Christophe Galtier', '2017', 'Stade Pierre-Mauroy', '49\xa0712', '59']
['Olympique lyonnais', '1989', '310', '3e', 'Rudi Garcia', '2019', 'Groupama Stadium', '57\xa0206', '60']
['AS Saint-Étienne', '2004', '100', '4e', 'Claude Puel', '2019', 'Stade Geoffroy-Guichard', '41\xa0965', '66']
['Olympique de Marseille', '1996', '110', '5e', 'André Villas-Boas', '2019', 'Orange Vélodrome', '66\xa0226', '69']
['Montpellier HSC', '2009', '40', '6e', 'Michel Der Zakarian', '2017', 'Stade de la Mosson', '22\xa0000', '27']
['OGC Nice', '2002', '50', '7e', 'Patrick Vieira', '2018', 'Allianz Riviera', '35\xa0596', '60']
['Stade de Reims', '2018', '45', '8e', 'David Guion', '2017', 'Stade Auguste-Delaune', '20\xa0546', '35']
['Nîmes Olympique', '2018', '27', '9e', 'Bernard Blaquart', '2015', 'Stade des Costières', '15\xa0788', '35']
['Stade rennais FC', '1994', '65', '10e', 'Julien Stéphan', '2018', 'Roazhon Park', '29\xa0194', '62']
['RC Strasbourg Alsace', '2017', '43', '11e', 'Thierry Laurey', '2016', 'Stade de la Meinau', '26\xa0109', '58']
['FC Nantes', '2013', '70', '12e', 'Christian Gourcuff', '2019', 'Stade de la Beaujoire - Louis Fonteneau', '35\xa0322', '51']
['SCO d’Angers', '2015', '32', '13e', 'Stéphane Moulin', '2011', 'Stade Raymond-Kopa', '14\xa0582', '27']
['Girondins de Bordeaux', '1992', '70', '14e', 'Paulo Sousa', '2019', 'Matmut Atlantique', '42\xa0115', '66']
['Amiens SC', '2017', '30', '15e', 'Luka Elsner', '2019', 'Stade Crédit Agricole la Licorne', '12\xa0999', '2']
['Toulouse FC', '2003', '35', '16e', 'Denis Zanko', '2020', 'Stadium de Toulouse', '33\xa0033', '32']
['AS Monaco', '2013', '220', '17e', 'Robert Moreno', '2019', 'Stade Louis-II', '16\xa0500', '60']
['Dijon FCO', '2016', '38', '18e', 'Stéphane Jobard', '2019', 'Parc des Sports Gaston-Gérard', '15\xa0459', '4']
['FC Metz', '2019', '40', '1er (Ligue 2)', 'Vincent Hognon', '2019', 'Stade Saint-Symphorien', '25\xa0865', '61']
['Stade brestois 29', '2019', '30', '2e (Ligue 2)', "Olivier Dall'Oglio", '2019', 'Stade Francis-Le Blé', '14\xa0920', '13']

On a bien réussi à avoir les informations contenues dans le tableau des participants du championnat. Mais la première ligne est étrange : c’est une liste vide …

Il s’agit des en-têtes : elles sont reconnues par la balise th et non td.

On va mettre tout le contenu dans un dictionnaire, pour le transformer ensuite en DataFrame pandas :

dico_participants = dict()
for row in rows:
    cols = row.find_all('td')
    cols = [ele.text.strip() for ele in cols]
    if len(cols) > 0 : 
        dico_participants[cols[0]] = cols[1:]
dico_participants

{'Paris Saint-Germain': ['1974',
  '637',
  '1er',
  'Thomas Tuchel',
  '2018',
  'Parc des Princes',
  '47\xa0929',
  '46'],
 'LOSC Lille': ['2000',
  '120',
  '2e',
  'Christophe Galtier',
  '2017',
  'Stade Pierre-Mauroy',
  '49\xa0712',
  '59'],
 'Olympique lyonnais': ['1989',
  '310',
  '3e',
  'Rudi Garcia',
  '2019',
  'Groupama Stadium',
  '57\xa0206',
  '60'],
 'AS Saint-Étienne': ['2004',
  '100',
  '4e',
  'Claude Puel',
  '2019',
  'Stade Geoffroy-Guichard',
  '41\xa0965',
  '66'],
 'Olympique de Marseille': ['1996',
  '110',
  '5e',
  'André Villas-Boas',
  '2019',
  'Orange Vélodrome',
  '66\xa0226',
  '69'],
 'Montpellier HSC': ['2009',
  '40',
  '6e',
  'Michel Der Zakarian',
  '2017',
  'Stade de la Mosson',
  '22\xa0000',
  '27'],
 'OGC Nice': ['2002',
  '50',
  '7e',
  'Patrick Vieira',
  '2018',
  'Allianz Riviera',
  '35\xa0596',
  '60'],
 'Stade de Reims': ['2018',
  '45',
  '8e',
  'David Guion',
  '2017',
  'Stade Auguste-Delaune',
  '20\xa0546',
  '35'],
 'Nîmes Olympique': ['2018',
  '27',
  '9e',
  'Bernard Blaquart',
  '2015',
  'Stade des Costières',
  '15\xa0788',
  '35'],
 'Stade rennais FC': ['1994',
  '65',
  '10e',
  'Julien Stéphan',
  '2018',
  'Roazhon Park',
  '29\xa0194',
  '62'],
 'RC Strasbourg Alsace': ['2017',
  '43',
  '11e',
  'Thierry Laurey',
  '2016',
  'Stade de la Meinau',
  '26\xa0109',
  '58'],
 'FC Nantes': ['2013',
  '70',
  '12e',
  'Christian Gourcuff',
  '2019',
  'Stade de la Beaujoire - Louis Fonteneau',
  '35\xa0322',
  '51'],
 'SCO d’Angers': ['2015',
  '32',
  '13e',
  'Stéphane Moulin',
  '2011',
  'Stade Raymond-Kopa',
  '14\xa0582',
  '27'],
 'Girondins de Bordeaux': ['1992',
  '70',
  '14e',
  'Paulo Sousa',
  '2019',
  'Matmut Atlantique',
  '42\xa0115',
  '66'],
 'Amiens SC': ['2017',
  '30',
  '15e',
  'Luka Elsner',
  '2019',
  'Stade Crédit Agricole la Licorne',
  '12\xa0999',
  '2'],
 'Toulouse FC': ['2003',
  '35',
  '16e',
  'Denis Zanko',
  '2020',
  'Stadium de Toulouse',
  '33\xa0033',
  '32'],
 'AS Monaco': ['2013',
  '220',
  '17e',
  'Robert Moreno',
  '2019',
  'Stade Louis-II',
  '16\xa0500',
  '60'],
 'Dijon FCO': ['2016',
  '38',
  '18e',
  'Stéphane Jobard',
  '2019',
  'Parc des Sports Gaston-Gérard',
  '15\xa0459',
  '4'],
 'FC Metz': ['2019',
  '40',
  '1er (Ligue 2)',
  'Vincent Hognon',
  '2019',
  'Stade Saint-Symphorien',
  '25\xa0865',
  '61'],
 'Stade brestois 29': ['2019',
  '30',
  '2e (Ligue 2)',
  "Olivier Dall'Oglio",
  '2019',
  'Stade Francis-Le Blé',
  '14\xa0920',
  '13']}

data_participants = pandas.DataFrame.from_dict(dico_participants,orient='index')
data_participants.head()

	0	1	2	3	4	5	6	7
Paris Saint-Germain	1974	637	1er	Thomas Tuchel	2018	Parc des Princes	47 929	46
LOSC Lille	2000	120	2e	Christophe Galtier	2017	Stade Pierre-Mauroy	49 712	59
Olympique lyonnais	1989	310	3e	Rudi Garcia	2019	Groupama Stadium	57 206	60
AS Saint-Étienne	2004	100	4e	Claude Puel	2019	Stade Geoffroy-Guichard	41 965	66
Olympique de Marseille	1996	110	5e	André Villas-Boas	2019	Orange Vélodrome	66 226	69

5️⃣ Récupérer les en-têtes du tableau :

for row in rows:
    cols = row.find_all('th')
    print(cols)
    if len(cols) > 0 : 
        cols = [ele.get_text(separator=' ').strip().title() for ele in cols]
        columns_participants = cols

[<th scope="col">Club
</th>, <th scope="col">Dernière<br/>montée
</th>, <th scope="col">Budget<sup class="reference" id="cite_ref-3"><a href="#cite_note-3"><span class="cite_crochet">[</span>3<span class="cite_crochet">]</span></a></sup><br/>en M<a href="/wiki/Euro" title="Euro">€</a>
</th>, <th scope="col">Classement<br/><a href="/wiki/Championnat_de_France_de_football_2018-2019" title="Championnat de France de football 2018-2019">2018-2019</a>
</th>, <th scope="col">Entraîneur
</th>, <th scope="col">Depuis
</th>, <th scope="col">Stade
</th>, <th scope="col">Capacité<br/>en L1<sup class="reference" id="cite_ref-4"><a href="#cite_note-4"><span class="cite_crochet">[</span>4<span class="cite_crochet">]</span></a></sup>
</th>, <th scope="col">Nombre<br/>de saisons<br/>en L1
</th>]
[]
[]
[]
[]
[]
[]
[]
[]
[]
[]
[]
[]
[]
[]
[]
[]
[]
[]
[]
[]

columns_participants

['Club',
 'Dernière Montée',
 'Budget [ 3 ] En M €',
 'Classement 2018-2019',
 'Entraîneur',
 'Depuis',
 'Stade',
 'Capacité En L1 [ 4 ]',
 'Nombre De Saisons En L1']

6️⃣ Finalisation du tableau

data_participants.columns = columns_participants[1:]

data_participants.head()

	Dernière Montée	Budget [ 3 ] En M €	Classement 2018-2019	Entraîneur	Depuis	Stade	Capacité En L1 [ 4 ]	Nombre De Saisons En L1
Paris Saint-Germain	1974	637	1er	Thomas Tuchel	2018	Parc des Princes	47 929	46
LOSC Lille	2000	120	2e	Christophe Galtier	2017	Stade Pierre-Mauroy	49 712	59
Olympique lyonnais	1989	310	3e	Rudi Garcia	2019	Groupama Stadium	57 206	60
AS Saint-Étienne	2004	100	4e	Claude Puel	2019	Stade Geoffroy-Guichard	41 965	66
Olympique de Marseille	1996	110	5e	André Villas-Boas	2019	Orange Vélodrome	66 226	69

Pour aller plus loin

Récupération des localisations des stades

Essayez de comprendre pas à pas ce qui est fait dans les étapes qui suivent (la récupération d’informations supplémentaires en naviguant dans les pages des différents clubs).

import urllib
import pandas as pd
import bs4 

division=[]
equipe=[]
stade=[]
latitude_stade=[]        
longitude_stade=[]     

url_list=["http://fr.wikipedia.org/wiki/Championnat_de_France_de_football_2019-2020", "http://fr.wikipedia.org/wiki/Championnat_de_France_de_football_de_Ligue_2_2019-2020"]

for url_ligue in url_list :
       
    print(url_ligue)
    sock = urllib.request.urlopen(url_ligue).read() 
    page=bs4.BeautifulSoup(sock)

# Rechercher les liens des équipes dans la liste disponible sur wikipedia 

    for team in page.findAll('span' , {'class' : 'toponyme'}) :  
        
        # Indiquer si c'est de la ligue 1 ou de la ligue 2
        
        if url_ligue==url_list[0] :
            division.append("L1")
        else :
            division.append("L2")

       # Trouver le nom et le lien de l'équipe
            
        if team.find('a')!=None :
            team_url=team.find('a').get('href')
            name_team=team.find('a').get('title')
            equipe.append(name_team)
            url_get_info = "http://fr.wikipedia.org"+team_url
            print(url_get_info)
 
       # aller sur la page de l'équipe
           
            search = urllib.request.urlopen(url_get_info).read()
            search_team=bs4.BeautifulSoup(search)

       # trouver le stade             
            compteur = 0
            for stadium in search_team.findAll('tr'):
                for x in stadium.findAll('th' , {'scope' : 'row'} ) :
                    if x.contents[0].string=="Stade" and compteur == 0:
                        compteur = 1
                        # trouver le lien du stade et son nom
                        url_stade=stadium.findAll('a')[1].get('href')
                        name_stadium=stadium.findAll('a')[1].get('title')
                        stade.append(name_stadium)
                        url_get_stade = "http://fr.wikipedia.org"+url_stade
                        print(url_get_stade)
                        
                        # Aller sur la page du stade et trouver ses coodronnées géographiques
                        
                        search_stade = urllib.request.urlopen(url_get_stade).read()
                        soup_stade=bs4.BeautifulSoup(search_stade) 
                        kartographer = soup_stade.find('a',{'class': "mw-kartographer-maplink"})
                        if kartographer == None :
                          latitude_stade.append(None)
                          longitude_stade.append(None) 
                        else :
                            for coordinates in kartographer :
                                print(coordinates)
                                liste =   coordinates.split(",")          
                                latitude_stade.append(str(liste[0]).replace(" ", "") + "'")
                                longitude_stade.append(str(liste[1]).replace(" ", "") + "'")
                            

dict = {'division' : division , 'equipe': equipe, 'stade': stade, 'latitude': latitude_stade, 'longitude' : longitude_stade}
data = pd.DataFrame(dict)
data = data.dropna()

data.head(5)

	division	equipe	stade	latitude	longitude
0	L1	Paris Saint-Germain Football Club	Parc des Princes	48° 50′ 29″ N'	2° 15′ 11″ E'
1	L1	LOSC Lille	Stade Pierre-Mauroy	50° 36′ 43″ N'	3° 07′ 50″ E'
2	L1	Olympique lyonnais	Parc Olympique lyonnais	45° 45′ 55″ N'	4° 58′ 55″ E'
3	L1	Association sportive de Saint-Étienne	Stade Geoffroy-Guichard	45° 27′ 39″ N'	4° 23′ 25″ E'
4	L1	Olympique de Marseille	Stade Vélodrome	43° 16′ 11″ N'	5° 23′ 45″ E'

On va transformer les coordonnées en degrés en coordonnées numériques afin d’être en mesure de faire une carte.

import re

def dms2dd(degrees, minutes, seconds, direction):
    dd = float(degrees) + float(minutes)/60 + float(seconds)/(60*60);
    if direction in ('S', 'O'):
        dd *= -1
    return dd

def parse_dms(dms):
    parts = re.split('[^\d\w]+', dms)
    lat = dms2dd(parts[0], parts[1], parts[2], parts[3])
    #lng = dms2dd(parts[4], parts[5], parts[6], parts[7])
    return lat

data['latitude'] = data['latitude'].apply(parse_dms)
data['longitude'] = data['longitude'].apply(parse_dms)

Tous les éléments sont en place pour faire une belle carte à ce stade. On va utiliser folium pour celle-ci, qui est présenté dans la partie visualisation.

Carte des stades avec `folium`

import geopandas as gpd
from pathlib import Path
import folium

gdf = gpd.GeoDataFrame(
    data, geometry=gpd.points_from_xy(data.longitude, data.latitude))

Path("leaflet").mkdir(parents=True, exist_ok=True)

center = gdf[['latitude', 'longitude']].mean().values.tolist()
sw = gdf[['latitude', 'longitude']].min().values.tolist()
ne = gdf[['latitude', 'longitude']].max().values.tolist()

m = folium.Map(location = center, tiles='openstreetmap')

# I can add marker one by one on the map
for i in range(0,len(gdf)):
    folium.Marker([gdf.iloc[i]['latitude'], gdf.iloc[i]['longitude']], popup=gdf.iloc[i]['stade']).add_to(m) 

m.fit_bounds([sw, ne])

La carte obtenue doit ressembler à la suivante :

Make this Notebook Trusted to load map: File -> Trust Notebook

Récupérer des informations sur les pokemons

Le prochain exercice pour mettre en pratique le web scraping consiste à récupérer des informations sur les pokemons à partir du site internet pokemondb.net.

Version non guidée

Exercice 2 : Les pokemon (version non guidée)

Pour cet exercice, nous vous demandons d’obtenir différentes informations sur les pokémons :

les informations personnelles des 893 pokemons sur le site internet pokemondb.net. Les informations que nous aimerions obtenir au final dans un DataFrame sont celles contenues dans 4 tableaux :

Pokédex data
Training
Breeding
Base stats

Nous aimerions que vous récupériez également les images de chacun des pokémons et que vous les enregistriez dans un dossier

Petit indice : utilisez les modules request et shutil
Pour cette question, il faut que vous cherchiez de vous même certains éléments, tout n’est pas présent dans le TD.

Pour la question 1, l’objectif est d’obtenir le code source d’un tableau comme celui qui suit (Pokemon Nincada).

Pokédex data

National №	290
Type	Bug Ground
Species	Trainee Pokémon
Height	0.5 m (1′08″)
Weight	5.5 kg (12.1 lbs)
Abilities	1. Compound Eyes Run Away (hidden ability)
Local №	042 (Ruby/Sapphire/Emerald) 111 (X/Y — Central Kalos) 043 (Omega Ruby/Alpha Sapphire) 104 (Sword/Shield)

Training

EV yield	1 Defense
Catch rate	255 (33.3% with PokéBall, full HP)
Base Friendship	70 (normal)
Base Exp.	53
Growth Rate	Erratic

Breeding

Egg Groups	Bug
Gender	50% male, 50% female
Egg cycles	15 (3,599–3,855 steps)

Base stats

HP	31	172	266
Attack	45	85	207
Defense	90	166	306
Sp. Atk	30	58	174
Sp. Def	30	58	174
Speed	40	76	196
Total	266	Min	Max

Pour la question 2, l’objectif est d’obtenir les images des pokemon.

Version guidée

Les prochaines parties permettront de faire l’exercice ci-dessus étape par étape, de manière guidée.

Nous souhaitons tout d’abord obtenir les informations personnelles de tous les pokemons sur pokemondb.net.

Les informations que nous aimerions obtenir au final pour les pokemons sont celles contenues dans 4 tableaux :

Pokédex data
Training
Breeding
Base stats

Nous proposons ensuite de récupérer et afficher les images.

Etape 1: constituer un DataFrame de caractéristiques

Exercice 2b : Les pokémons (version guidée)

Pour récupérer les informations, le code devra être divisé en plusieurs étapes :

Trouvez la page principale du site et la transformer en un objet intelligible pour votre code. Les fonctions suivantes vous seront utiles :

urllib.request.Request
urllib.request.urlopen
bs4.BeautifulSoup

Créez une fonction qui permet de récupérer la page d’un pokémon à partir de son nom.
A partir de la page de bulbasaur, obtenez les 4 tableaux qui nous intéressent :

on va chercher l’élément suivant : ('table', { 'class' : "vitals-table"})
puis stocker ses éléments dans un dictionnaire

Récupérez par ailleurs la liste de noms des pokémons qui nous permettra de faire une boucle par la suite. Combien trouvez-vous de pokémons ?
Ecrire une fonction qui récupère l’ensemble des informations sur les dix premiers pokémons de la liste et les intègre dans un DataFrame

A l’issue de la question 3, vous devriez obtenir une liste de caractéristiques proche de celle-ci:

{'National №': '0001',
 'name': 'bulbasaur',
 'Type': ' Grass Poison ',
 'Species': 'Seed Pokémon',
 'Height': '0.7\xa0m (2′04″)',
 'Weight': '6.9\xa0kg (15.2\xa0lbs)',
 'Abilities': '1. OvergrowChlorophyll (hidden ability)',
 'Local №': "0001 (Red/Blue/Yellow)0226 (Gold/Silver/Crystal)0001 (FireRed/LeafGreen)0231 (HeartGold/SoulSilver)0080 (X/Y — Central Kalos)0001 (Let's Go Pikachu/Let's Go Eevee)0068 (The Isle of Armor)",
 'EV yield': ' 1 Sp. Atk ',
 'Catch rate': ' 45 (5.9% with PokéBall, full HP) ',
 'Base Friendship': ' 50 (normal) ',
 'Base Exp.': '64',
 'Growth Rate': 'Medium Slow',
 'Egg Groups': 'Grass, Monster',
 'Gender': '87.5% male, 12.5% female',
 'Egg cycles': '20 (4,884–5,140 steps) ',
 'HP': '45',
 'Attack': '49',
 'Defense': '49',
 'Sp. Atk': '65',
 'Sp. Def': '65',
 'Speed': '45'}

La structure est ici en dictionnaire, ce qui est pratique.

Enfin, vous pouvez intégrer les informations des dix premiers pokémons à un DataFrame, qui aura l’aspect suivant :

	National №	name	Type	Species	Height	Weight	Abilities	Local №	EV yield	Catch rate	...	Growth Rate	Egg Groups	Gender	Egg cycles	HP	Attack	Defense	Sp. Atk	Sp. Def	Speed
0	0001	bulbasaur	Grass Poison	Seed Pokémon	0.7 m (2′04″)	6.9 kg (15.2 lbs)	1. OvergrowChlorophyll (hidden ability)	0001 (Red/Blue/Yellow)0226 (Gold/Silver/Crysta...	1 Sp. Atk	45 (5.9% with PokéBall, full HP)	...	Medium Slow	Grass, Monster	87.5% male, 12.5% female	20 (4,884–5,140 steps)	45	49	49	65	65	45
1	0002	ivysaur	Grass Poison	Seed Pokémon	1.0 m (3′03″)	13.0 kg (28.7 lbs)	1. OvergrowChlorophyll (hidden ability)	0002 (Red/Blue/Yellow)0227 (Gold/Silver/Crysta...	1 Sp. Atk, 1 Sp. Def	45 (5.9% with PokéBall, full HP)	...	Medium Slow	Grass, Monster	87.5% male, 12.5% female	20 (4,884–5,140 steps)	60	62	63	80	80	60
2	0003	venusaur	Grass Poison	Seed Pokémon	2.0 m (6′07″)	100.0 kg (220.5 lbs)	1. OvergrowChlorophyll (hidden ability)	0003 (Red/Blue/Yellow)0228 (Gold/Silver/Crysta...	2 Sp. Atk, 1 Sp. Def	45 (5.9% with PokéBall, full HP)	...	Medium Slow	Grass, Monster	87.5% male, 12.5% female	20 (4,884–5,140 steps)	80	82	83	100	100	80
3	0004	charmander	Fire	Lizard Pokémon	0.6 m (2′00″)	8.5 kg (18.7 lbs)	1. BlazeSolar Power (hidden ability)	0004 (Red/Blue/Yellow)0229 (Gold/Silver/Crysta...	1 Speed	45 (5.9% with PokéBall, full HP)	...	Medium Slow	Dragon, Monster	87.5% male, 12.5% female	20 (4,884–5,140 steps)	39	52	43	60	50	65
4	0005	charmeleon	Fire	Flame Pokémon	1.1 m (3′07″)	19.0 kg (41.9 lbs)	1. BlazeSolar Power (hidden ability)	0005 (Red/Blue/Yellow)0230 (Gold/Silver/Crysta...	1 Sp. Atk, 1 Speed	45 (5.9% with PokéBall, full HP)	...	Medium Slow	Dragon, Monster	87.5% male, 12.5% female	20 (4,884–5,140 steps)	58	64	58	80	65	80

5 rows × 22 columns

Etape 2: récupérer et afficher des photos de Pokemon

Nous aimerions que vous récupériez également les images des 5 premiers pokémons et que vous les enregistriez dans un dossier.

Exercice 2b : Les pokémons (version guidée)

Les URL des images des pokemon prennent la forme “https://img.pokemondb.net/artwork/{pokemon}.jpg”. Utiliser les modules requests et shutil pour télécharger et enregistrer en local les images.
Importer ces images stockées au format JPEG dans Python grâce à la fonction imread du package skimage.io

!pip install scikit-image

Requirement already satisfied: scikit-image in /opt/mamba/lib/python3.9/site-packages (0.21.0)
Requirement already satisfied: numpy>=1.21.1 in /opt/mamba/lib/python3.9/site-packages (from scikit-image) (1.26.0)
Requirement already satisfied: scipy>=1.8 in /opt/mamba/lib/python3.9/site-packages (from scikit-image) (1.11.2)
Requirement already satisfied: networkx>=2.8 in /opt/mamba/lib/python3.9/site-packages (from scikit-image) (3.1)
Requirement already satisfied: pillow>=9.0.1 in /opt/mamba/lib/python3.9/site-packages (from scikit-image) (10.0.0)
Requirement already satisfied: imageio>=2.27 in /opt/mamba/lib/python3.9/site-packages (from scikit-image) (2.31.4)
Requirement already satisfied: tifffile>=2022.8.12 in /opt/mamba/lib/python3.9/site-packages (from scikit-image) (2023.9.18)
Requirement already satisfied: PyWavelets>=1.1.1 in /opt/mamba/lib/python3.9/site-packages (from scikit-image) (1.4.1)
Requirement already satisfied: packaging>=21 in /opt/mamba/lib/python3.9/site-packages (from scikit-image) (21.3)
Requirement already satisfied: lazy_loader>=0.2 in /opt/mamba/lib/python3.9/site-packages (from scikit-image) (0.3)
Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/mamba/lib/python3.9/site-packages (from packaging>=21->scikit-image) (3.0.9)
WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv

`Selenium` : mimer le comportement d’un utilisateur internet

Jusqu’à présent, nous avons raisonné comme si nous connaissions toujours l’url qui nous intéresse. De plus, les pages que nous visitons sont “statiques”, elles ne dépendent pas d’une action ou d’une recherche de l’internaute.

Nous allons voir à présent comment nous en sortir pour remplir des champs sur un site web et récupérer ce qui nous intéresse. La réaction d’un site web à l’action d’un utilisateur passe régulièrement par l’usage de JavaScript dans le monde du développement web. Le package Selenium permet de reproduire, depuis un code automatisé, le comportement manuel d’un utilisateur. Il permet ainsi d’obtenir des informations du site qui ne sont pas dans le code HTML mais qui apparaissent uniquement à la suite de l’exécution de script JavaScript en arrière plan.

Selenium se comporte comme un utilisateur lambda sur internet : il clique sur des liens, il remplit des formulaires, etc.

Premier exemple en scrapant un moteur de recherche

Dans cet exemple, nous allons essayer d’aller sur le site de Bing Actualités et entrer dans la barre de recherche un sujet donné. Pour tester, nous allons faire une recherche avec le mot-clé “Trump”.

L’installation de Selenium nécessite d’avoir Chromium qui est un navigateur Google Chrome minimaliste. La version de chromedriver doit être >= 2.36 et dépend de la version de Chrome que vous avez sur votre environnement de travail. Pour installer cette version minimaliste de Chrome sur un environnement Linux, vous pouvez vous référer à l’encadré dédié.

Installation de `Selenium`

D’abord, il convient d’installer les dépendances. Sur Colab, vous pouvez utiliser les commandes suivantes :

!sudo apt-get update
!sudo apt install -y unzip xvfb libxi6 libgconf-2-4 -y
!sudo apt install chromium-chromedriver -y
!cp /usr/lib/chromium-browser/chromedriver /usr/bin

Si vous êtes sur le SSP Cloud, vous pouvez exécuter les commandes suivantes :

!wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb -O /tmp/chrome.deb
!sudo apt-get update
!sudo -E apt-get install -y /tmp/chrome.deb
!pip install chromedriver-autoinstaller selenium

import chromedriver_autoinstaller
chromedriver_autoinstaller.install()

Vous pouvez ensuite installer Selenium. Par exemple, depuis une cellule de Notebook :

Après avoir installé Chromium, il est nécessaire d’indiquer à Python où le trouver. Si vous êtes sur Linux et que vous avez suivi les consignes précédentes, vous pouvez faire :

import selenium
from webdriver_manager.chrome import ChromeDriverManager

path_to_web_driver = ChromeDriverManager().install()

En premier lieu, il convient d’initialiser le comportement de Selenium en répliquant les paramètres du navigateur. Pour cela, on va d’abord initialiser notre navigateur avec quelques options :

import time

from selenium import webdriver
from selenium.webdriver.common.keys import Keys

chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--headless')
chrome_options.add_argument('--no-sandbox')
chrome_options.add_argument('--disable-dev-shm-usage')
#chrome_options.add_argument('--verbose')

Puis on lance le navigateur :

from selenium.webdriver.chrome.service import Service
service = Service(executable_path=path_to_web_driver)

browser = webdriver.Chrome(service=service,
                           options=chrome_options)

On va sur le site de Bing Actualités, et on lui indique le mot clé que nous souhaitons chercher. En l’occurrence, on s’intéresse aux actualités de Donald Trump. Après avoir inspecté la page depuis les outils de développement du navigateur, on voit que la barre de recherche est un élement du code appelé q (comme query). On va ainsi demander à selenium de chercher cet élément:

browser.get('https://www.bing.com/news')

search = browser.find_element("name", "q")
print(search)
print([search.text, search.tag_name, search.id])

# on envoie à cet endroit le mot qu'on aurait tapé dans la barre de recherche
search.send_keys("Trump")

search_button = browser.find_element("xpath", "//input[@id='sb_form_go']") 
search_button.click()

Selenium permet de capturer l’image qu’on verrait dans le navigateur avec get_screenshot_as_png. Cela peut être utile pour vérifier qu’on a fait la bonne action :

Enfin, on peut extraire les résultats. Plusieurs méthodes sont disponibles. La méthode la plus pratique, lorsqu’elle est disponible, est d’utiliser le XPath qui est un chemin non ambigu pour accéder à un élement. En effet, plusieurs éléments peuvent partager la même classe ou le même attribut ce qui peut faire qu’une recherche de ce type peut renvoyer plusieurs échos. Pour déterminer le XPath d’un objet, les outils de développeurs de votre site web sont pratiques. Par exemple, sous Firefox, une fois que vous avez trouvé un élément dans l’inspecteur, vous pouvez faire click droit > Copier > XPath.

Enfin, pour mettre fin à notre session, on demande à Python de quitter le navigateur:

browser.quit()

On a obtenu les résultats suivants :

['https://www.msn.com/en-us/news/politics/trump-seeks-urgent-review-of-gag-order-ruling-in-new-york-civil-fraud-case/ar-AA1kZ5af', 'https://abcnews.go.com/US/live-updates/trump-fraud-trial/trump-wants-to-appeal-gag-order-in-his-civil-trial-again-105358096?id=103642561', 'https://www.theatlantic.com/magazine/archive/2024/01/trump-2024-reelection-pull-out-of-nato-membership/676120/', 'https://www.msn.com/en-us/news/politics/trump-is-showing-how-a-second-term-would-rewrite-the-rules-of-presidential-power/ar-AA1kWW2r', 'https://www.msn.com/en-us/news/politics/donald-trump-lashes-out-at-joe-biden-as-he-denies-election-fraud-allegations/ar-AA1kVJS6', 'https://www.csmonitor.com/USA/Politics/2023/1204/Trump-claims-immunity-in-Jan.-6-lawsuits.-Federal-court-disagrees', 'https://www.msnbc.com/deadline-white-house/deadline-legal-blog/trump-trial-immunity-2020-election-rcna127896', 'https://www.msn.com/en-in/news/world/trump-really-really-hates-his-ny-gag-order-which-hes-now-trying-to-appeal-again/ar-AA1kZkSY']

Les autres méthodes utiles de Selenium:

Méthode	Résultat
`find_element(****).click()`	Une fois qu’on a trouvé un élément réactif, notamment un bouton, on peut cliquer dessus pour activer une nouvelle page
`find_element(****).send_keys("toto")`	Une fois qu’on a trouvé un élément, notamment un champ où s’authentifier, on peut envoyer une valeur, ici “toto”.

Utiliser `Selenium` pour jouer à 2048

Dans cet exemple, on utilise le module pour que Python appuie lui même sur les touches du clavier afin de jouer à 2048.

Note : ce bout de code ne donne pas une solution à 2048, il permet juste de voir ce qu’on peut faire avec Selenium.

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.keys import Keys

# on ouvre la page internet du jeu 2048
service = Service(executable_path=path_to_web_driver)

browser = webdriver.Chrome(service=service,
                           options=chrome_options)
browser.get('https://play2048.co//')

# Ce qu'on va faire : une boucle qui répète inlassablement la même chose : haut / droite / bas / gauche

# on commence par cliquer sur la page pour que les touches sachent 
button = browser.find_element("class name", 'grid-container')
browser.execute_script("arguments[0].click();", button)
time.sleep(0.5)

grid = browser.find_element("tag name", 'body')

# pour savoir quels coups faire à quel moment, on crée un dictionnaire
direction = {0: Keys.UP, 1: Keys.RIGHT, 2: Keys.DOWN, 3: Keys.LEFT}
count = 0

while True:
    try: # on vérifie que le bouton "Try again" n'est pas là - sinon ça veut dire que le jeu est fini
        retryButton = browser.find_element("link text",'Try again')
        scoreElem = browser.find_element("class name", 'score-container')
        break
    except:
        #Do nothing.  Game is not over yet
        pass
    # on continue le jeu - on appuie sur la touche suivante pour le coup d'après
    count += 1
    grid.send_keys(direction[count % 4]) 
    time.sleep(0.1)

print('Score final : {} en {} coups'.format(scoreElem.text, count))    
browser.quit()

Exercice supplémentaire

Pour découvrir une autre application possible du web scraping, vous pouvez également vous lancer dans le sujet 5 de l’édition 2023 d’un hackathon non compétitif organisé par l’Insee :

Sur Github
Sur le SSPCloud

Le contenu de la section NLP du cours pourra vous être utile pour la seconde partie du sujet !

Back to top

Citation

BibTeX citation:

@book{galiana2023,
  author = {Galiana, Lino},
  title = {Python Pour La Data Science},
  date = {2023},
  url = {https://pythonds.linogaliana.fr/},
  doi = {10.5281/zenodo.8229676},
  langid = {en}
}

For attribution, please cite this work as:

Galiana, Lino. 2023. Python Pour La Data Science. https://doi.org/10.5281/zenodo.8229676.

Enjeux

La zone grise de la légalité du web scraping

Stabilité et fiabilité des informations reçues

Les bonnes pratiques

Un détour par le Web : comment fonctionne un site ?

Les balises

Parent et enfant

Scraper avec Python: le package BeautifulSoup

Les packages disponibles

Note

Récupérer le contenu d’une page HTML

La méthode find

La méthode findAll

Exercice guidé : obtenir la liste des équipes de Ligue 1

Exercice 1 : Récupérer les participants de la Ligue 1

Pour aller plus loin

Récupération des localisations des stades

Carte des stades avec folium

Récupérer des informations sur les pokemons

Version non guidée

Exercice 2 : Les pokemon (version non guidée)

Pokédex data

Training

Breeding

Base stats

Version guidée

Etape 1: constituer un DataFrame de caractéristiques

Exercice 2b : Les pokémons (version guidée)

Etape 2: récupérer et afficher des photos de Pokemon

Exercice 2b : Les pokémons (version guidée)

Selenium : mimer le comportement d’un utilisateur internet

Premier exemple en scrapant un moteur de recherche

Installation de Selenium

Utiliser Selenium pour jouer à 2048

Exercice supplémentaire

Citation

Scraper avec `Python`: le package `BeautifulSoup`

La méthode `find`

La méthode `findAll`

Carte des stades avec `folium`

`Selenium` : mimer le comportement d’un utilisateur internet

Installation de `Selenium`

Utiliser `Selenium` pour jouer à 2048