Comment travailler avec des données Web à l’aide de requêtes et de Beautiful Soup with Python 3

introduction

Le Web nous fournit plus de données que n’importe lequel d’entre nous peut lire et comprendre. Nous souhaitons donc souvent utiliser ces informations par programmation pour les comprendre. Parfois, ces données nous sont fournies par les créateurs de sites Web via des fichiers de valeurs "+ .csv +" ou séparés par des virgules, ou via une API (interface de programmation d’application). D’autres fois, nous devons collecter nous-mêmes le texte provenant du Web.

Ce tutoriel va expliquer comment utiliser les Requests et les Beautiful Soup Packages Python afin d’utiliser les données des pages Web. Le module Requests vous permet d’intégrer vos programmes Python à des services Web, tandis que le module Beautiful Soup est conçu pour que le nettoyage d’écran se fasse rapidement. À l’aide de la console interactive Python et de ces deux bibliothèques, nous allons expliquer comment collecter une page Web et utiliser les informations textuelles disponibles.

Conditions préalables

Pour compléter ce didacticiel, vous aurez besoin d’un environnement de développement pour Python 3. Vous pouvez suivre le guide correspondant à votre système d’exploitation disponible dans la série https://www.digitalocean.com/community/tutorial_series/how-to-install-and-set-up-a-Local-programming-environment-for- python-3 [Comment installer et configurer un environnement de programmation local pour Python 3] ou https://www.digitalocean.com/community/tutorials/how-to-install-python-3-and-set-up-a -programming-environment-on-an-ubuntu-16-04-server [Comment installer Python 3 et configurer un environnement de programmation sur un serveur Ubuntu 16.04] pour configurer tout ce dont vous avez besoin.

De plus, vous devez connaître:

Tenant compte de votre environnement de développement et de ces concepts de programmation Python, commençons à travailler avec Requests et Beautiful Soup.

Installation de demandes

Commençons par activer notre environnement de programmation Python 3. Assurez-vous que vous êtes dans le répertoire où se trouve votre environnement et exécutez la commande suivante:

. /bin/activate

Pour pouvoir utiliser des pages Web, nous allons devoir demander la page. La bibliothèque Requests vous permet d’utiliser HTTP dans vos programmes Python de manière lisible par l’homme.

Avec notre environnement de programmation activé, nous installerons Requests avec pip:

pip install requests

Pendant l’installation de la bibliothèque Requests, vous recevrez le résultat suivant:

OutputCollecting requests
 Downloading requests-2.18.1-py2.py3-none-any.whl (88kB)
   100% |████████████████████████████████| 92kB 3.1MB/s
...
Installing collected packages: chardet, urllib3, certifi, idna, requests
Successfully installed certifi-2017.4.17 chardet-3.0.4 idna-2.5 requests-2.18.1 urllib3-1.21.1

Si Requests était précédemment installé, vous auriez reçu un retour d’information semblable à celui-ci de la fenêtre de votre terminal:

OutputRequirement already satisfied
...

Avec Requests installé dans notre environnement de programmation, nous pouvons continuer à installer le module suivant.

Installer une belle soupe

Comme nous l’avons fait avec Requests, nous installerons Beautiful Soup with pip. La version actuelle de Beautiful Soup 4 peut être installée avec la commande suivante:

pip install beautifulsoup4

Une fois que vous avez exécuté cette commande, le résultat devrait ressembler à celui-ci:

OutputCollecting beautifulsoup4
 Downloading beautifulsoup4-4.6.0-py3-none-any.whl (86kB)
   100% |████████████████████████████████| 92kB 4.4MB/s
Installing collected packages: beautifulsoup4
Successfully installed beautifulsoup4-4.6.0

Maintenant que Beautiful Soup et Requests sont installés, nous pouvons maintenant comprendre comment travailler avec les bibliothèques pour supprimer les sites Web.

Collecte d’une page Web avec des demandes

Avec les deux bibliothèques Python que nous allons utiliser maintenant installées, nous pouvons nous familiariser avec la navigation dans une page Web de base.

Passons tout d’abord à la Python Interactive Console:

python

À partir de là, nous allons importer le module Requests afin de pouvoir collecter un exemple de page Web:

import requests

Nous attribuerons l’URL (ci-dessous) de l’exemple de page Web, + mockturtle.html +, à la page https://www.digitalocean.com/community/tutorials/how-to-use-variables-in-python-3. [variable] + url +:

url = 'https://assets.digitalocean.com/articles/eng_python/beautiful-soup/mockturtle.html'

Ensuite, nous pouvons affecter le résultat d’une requête de cette page à la variable + page + avec le http://docs.python-requests.org/en/master/user/quickstart/#make-a-request [` + request.get () + méthode]. Nous passons l’URL de la page (qui a été assignée à la variable `+ url +) à cette méthode.

page = requests.get(url)

La variable + page + est affectée à un objet Response:

>>> page
<Response [200]>
>>>

L’objet Response ci-dessus nous indique la propriété + status_code + entre crochets (dans ce cas, + 200 +). Cet attribut peut être appelé explicitement:

>>> page.status_code
200
>>>

Le code renvoyé de «+ 200 » nous indique que la page a été téléchargée avec succès. Les codes commençant par le nombre ` 2 ` indiquent généralement le succès, alors que les codes commençant par le signe ' 4 + ou + 5 + `indiquent qu’une erreur s’est produite. Pour en savoir plus sur les codes d’état HTTP, consultez la page W3C.

Pour pouvoir utiliser les données Web, nous allons vouloir accéder au contenu textuel des fichiers Web. Nous pouvons lire le contenu de la réponse du serveur avec + page.text (sur` + page.content` si nous souhaitons accéder à la réponse en octets).

page.text

Une fois que vous avez appuyé sur + ENTER +, nous recevrons le résultat suivant:

Output'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"\n
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">\n\n<html lang="en-US"
xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">\n<head>\n  <meta
http-equiv="content-type" content="text/html; charset=us-ascii" />\n\n  <title>Turtle
Soup</title>\n</head>\n\n<body>\n  <h1>Turtle Soup</h1>\n\n  <p class="verse"
id="first">Beautiful Soup, so rich and green,<br />\n  Waiting in a hot tureen!<br />\n  Who for
such dainties would not stoop?<br />\n  Soup of the evening, beautiful Soup!<br />\n  Soup of
the evening, beautiful Soup!<br /></p>\n\n  <p class="chorus" id="second">Beau--ootiful
Soo--oop!<br />\n  Beau--ootiful Soo--oop!<br />\n  Soo--oop of the e--e--evening,<br />\n
Beautiful, beautiful Soup!<br /></p>\n\n  <p class="verse" id="third">Beautiful Soup! Who cares
for fish,<br />\n  Game or any other dish?<br />\n  Who would not give all else for two<br />\n
Pennyworth only of Beautiful Soup?<br />\n  Pennyworth only of beautiful Soup?<br /></p>\n\n
<p class="chorus" id="fourth">Beau--ootiful Soo--oop!<br />\n  Beau--ootiful Soo--oop!<br />\n
Soo--oop of the e--e--evening,<br />\n  Beautiful, beauti--FUL SOUP!<br
/></p>\n</body>\n</html>\n'
>>>

Nous voyons ici que le texte intégral de la page a été imprimé, avec toutes ses balises HTML. Cependant, il est difficile à lire car il n’y a pas beaucoup d’espacement.

Dans la section suivante, nous pouvons utiliser le module Beautiful Soup pour utiliser ces données textuelles de manière plus conviviale.

Parcourir une page avec une belle soupe

La bibliothèque Beautiful Soup crée une arborescence d’analyse à partir de documents HTML et XML analysés (y compris des documents avec des balises non fermées ou tag soup et d’autres balises malformées). Cette fonctionnalité rendra le texte de la page Web plus lisible que ce que nous avons vu dans le module Requests.

Pour commencer, nous allons importer Beautiful Soup dans la console Python:

from bs4 import BeautifulSoup

Ensuite, nous allons passer le document + page.text + à travers le module pour nous donner un objet + BeautifulSoup + - c’est-à-dire un arbre d’analyse de cette page analysée que nous obtiendrons en exécutant le https intégré de Python: //docs.python.org/3/library/html.parser.html [+ html.parser +] sur le code HTML. L’objet construit représente le document + mockturtle.html + sous la forme d’une structure de données imbriquée. Ceci est assigné à la variable + soup + +.

soup = BeautifulSoup(page.text, 'html.parser')

Pour afficher le contenu de la page sur le terminal, nous pouvons l’imprimer avec la méthode + prettify () + afin de transformer l’arbre d’analyse Beautiful Soup en une chaîne Unicode joliment formatée.

print(soup.prettify())

Cela rendra chaque balise HTML sur sa propre ligne:

Output<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html lang="en-US" xml:lang="en-US" xmlns="http://www.w3.org/1999/xhtml">
<head>
 <meta content="text/html; charset=utf-8" http-equiv="content-type"/>
 <title>
  Turtle Soup
 </title>
</head>
<body>
 <h1>
  Turtle Soup
 </h1>
 <p class="verse" id="first">
  Beautiful Soup, so rich and green,
  <br/>
  Waiting in a hot tureen!
  <br/>
  Who for such dainties would not stoop?
  <br/>
  Soup of the evening, beautiful Soup!
...
</html>

Dans la sortie ci-dessus, nous pouvons voir qu’il y a une balise par ligne et que les balises sont imbriquées en raison du schéma d’arborescence utilisé par Beautiful Soup.

Recherche d’instances d’une balise

Nous pouvons extraire une seule balise d’une page en utilisant la méthode + find_all + de Beautiful Soup. Cela renverra toutes les occurrences d’une balise donnée dans un document.

soup.find_all('p')

L’exécution de cette méthode sur notre objet renvoie le texte intégral de la chanson ainsi que les balises + + appropriées et toutes les balises contenues dans la balise demandée, qui inclut ici les balises de saut de ligne + +:

Output[<p class="verse" id="first">Beautiful Soup, so rich and green,<br/>
 Waiting in a hot tureen!<br/>
 Who for such dainties would not stoop?<br/>
 Soup of the evening, beautiful Soup!<br/>
 Soup of the evening, beautiful Soup!<br/></p>, <p class="chorus" id="second">Beau--ootiful Soo--oop!<br/>
...
 Beau--ootiful Soo--oop!<br/>
 Soo--oop of the e--e--evening,<br/>
 Beautiful, beauti--FUL SOUP!<br/></p>]

Vous remarquerez dans la sortie ci-dessus que les données sont entre crochets + [] +. Cela signifie qu’il s’agit d’un type de données Python https://www.digitalocean.com/community/tutorials/understanding-lists-in-python-3listlist].

Comme il s’agit d’une liste, nous pouvons appeler un élément en particulier (par exemple, le troisième élément + +), et utiliser la méthode + get_text () + pour extraire tout le texte de cette balise :

soup.find_all('p')[2].get_text()

La sortie que nous recevons sera ce qui est dans le troisième élément + + dans ce cas:

Output'Beautiful Soup! Who cares for fish,\n  Game or any other dish?\n  Who would not give all else for two\n  Pennyworth only of Beautiful Soup?\n  Pennyworth only of beautiful Soup?'

Notez que les sauts de ligne + \ n + sont également affichés dans la chaîne renvoyée ci-dessus.

Recherche d’étiquettes par classe et par ID

Les éléments HTML faisant référence à des sélecteurs CSS tels que class et ID peuvent être utiles lorsque vous travaillez avec des données Web à l’aide de Beautiful Soup. Nous pouvons cibler des classes et des ID spécifiques en utilisant la méthode + find_all () + et en transmettant les chaînes de classe et d’ID en tant qu’arguments.

Tout d’abord, trouvons toutes les instances de la classe + chorus +. Dans Beautiful Soup, nous allons affecter la chaîne de la classe au mot-clé argument + class_ +:

soup.find_all(class_='chorus')

Lorsque nous exécutons la ligne ci-dessus, nous recevons la liste suivante en sortie:

Output[<p class="chorus" id="second">Beau--ootiful Soo--oop!<br/>
 Beau--ootiful Soo--oop!<br/>
 Soo--oop of the e--e--evening,<br/>
 Beautiful, beautiful Soup!<br/></p>, <p class="chorus" id="fourth">Beau--ootiful Soo--oop!<br/>
 Beau--ootiful Soo--oop!<br/>
 Soo--oop of the e--e--evening,<br/>
 Beautiful, beauti--FUL SOUP!<br/></p>]

Les deux sections + + -tagged avec la classe + chorus + ont été imprimées sur le terminal.

Nous pouvons également spécifier que nous voulons rechercher la classe + chorus + uniquement dans les balises + +, au cas où elle serait utilisée pour plusieurs balises:

soup.find_all('p', class_='chorus')

L’exécution de la ligne ci-dessus produira le même résultat qu’auparavant.

Nous pouvons également utiliser Beautiful Soup pour cibler les identifiants associés aux balises HTML. Dans ce cas, nous attribuerons la chaîne + 'third' + au mot-clé ʻ + id + `:

soup.find_all(id='third')

Une fois que nous avons exécuté la ligne ci-dessus, nous recevrons le résultat suivant:

Output[<p class="verse" id="third">Beautiful Soup! Who cares for fish,<br/>
 Game or any other dish?<br/>
 Who would not give all else for two<br/>
 Pennyworth only of Beautiful Soup?<br/>
 Pennyworth only of beautiful Soup?<br/></p>]

Le texte associé à la balise + + avec l’id de + tiers + est imprimé sur le terminal avec les balises correspondantes.

Conclusion

Ce tutoriel vous a permis de récupérer une page Web avec le module Requests en Python et de faire un premier balayage des données textuelles de cette page Web afin de mieux comprendre Beautiful Soup.

À partir de là, vous pouvez créer un programme de nettoyage Web qui créera un fichier CSV à partir de données collectées sur le Web en suivant le tutoriel https://www.digitalocean.com/community/tutorials/how-to-scrape- web-pages-with-beautiful-soup-and-python-3 [Comment faire pour gratter des pages Web avec une belle soupe et Python 3].

TOC