Web Scraping avec Python : Le guide ultime pour construire votre scraper

Raluca Penciuc le 30 mars 2021

Si, au 20e siècle, l'état d'esprit était "le temps, c'est de l'argent", aujourd'hui, tout tourne autour des données. Plus de données signifie plus de connaissances, donc de meilleures décisions et plus d'argent.

La popularité du web scraping et des web scrapers s'est considérablement accrue au cours de la dernière décennie. De plus en plus d'entreprises ont besoin d'une stratégie de marketing précise, ce qui implique de grandes quantités d'informations en peu de temps.

Avec les nouveaux projecteurs braqués sur l'extraction de données, les entreprises commencent à voir comment elles peuvent en bénéficier. Pour les développeurs, il peut s'agir d'un bon moyen de stimuler leur activité ou simplement d'un projet intéressant pour perfectionner leurs compétences en matière de codage.

Même si votre travail n'a rien à voir avec le web scraping, mais que vous êtes un joueur d'équipe Python, à la fin de cet article, vous découvrirez un nouveau créneau où vous pourrez utiliser vos compétences. Nous allons voir comment nous pouvons construire notre propre Web Scraping avec Python.

Comprendre le Web Scraping avec Python

Mais tout d'abord, qu'est-ce que le web scraping ? Au niveau le plus élémentaire, un scrapeur web extrait les données d'un site web, à condition que tous les sites ne proposent pas leurs données dans le cadre d'une API publique.

Ce processus est plus utile qu'il n'y paraît si l'on considère que plus vous disposez d'informations, meilleures sont les décisions que vous prenez dans votre entreprise.

De nos jours, les sites web sont de plus en plus chargés en contenu, de sorte qu'effectuer ce processus entièrement à la main est loin d'être une bonne idée. C'est là que la construction d'un outil automatisé de scraping entre en ligne de compte.

"Vous vous demandez peut-être pourquoi j'ai besoin de ces données. Jetons un coup d'œil à quelques-uns des principaux cas d'utilisation pour lesquels le web scraping nous sauve la vie :

• Renseignements sur les prix: une entreprise de commerce électronique aura besoin d'informations sur les prix pratiqués par ses concurrents pour prendre de meilleures décisions en matière de prix et de marketing.
• Étude de marché: l'analyse de marché est synonyme d'informations de haute qualité, de volume important et d'une grande perspicacité.
• Immobilier: les particuliers ou les entreprises ont besoin de regrouper des offres provenant de sources multiples.
• Génération de leads: trouver des clients pour votre entreprise en pleine croissance.
• Surveillance de la marque: les entreprises analysent les forums, les plateformes de médias sociaux et les avis pour savoir comment leur marque est perçue.
• La surveillance du prix minimum annoncé (PMA) permet de s'assurer que les prix en ligne d'une marque correspondent à sa politique de prix.
• Apprentissage automatique: les développeurs doivent fournir des données d'entraînement pour que leurs solutions basées sur l'IA fonctionnent correctement.

Vous trouverez d'autres cas d'utilisation et une description plus détaillée ici.

"Vous vous dites peut-être : "Cool, commençons ! Pas si vite.

Même si vous avez compris comment fonctionne le web scraping et comment il peut améliorer votre activité, il n'est pas si facile de construire un web scraper. Tout d'abord, certaines personnes ne veulent pas d'un scraper sur leur site web pour différentes raisons.

L'une d'entre elles est que le scraping signifie que de nombreuses requêtes sont envoyées en une seconde, ce qui peut surcharger le serveur. Les propriétaires de sites web peuvent parfois considérer cela comme une attaque de pirates informatiques(déni de service), et les sites web adoptent donc des mesures pour se protéger en bloquant les robots.

Certaines de ces mesures peuvent être :

• Le blocage d'IP: ce phénomène se produit lorsqu'un site web détecte un nombre élevé de demandes provenant de la même adresse IP ; le site web peut vous interdire totalement l'accès ou vous ralentir considérablement).
  
• CAPTCHA (Completely Automated Public Turing tests to tell Computers and Humans Apart) : il s'agit de problèmes logiques assez triviaux à résoudre pour les personnes, mais qui constituent un casse-tête pour les scrappers.
  
• Honeypot: liens intégrés invisibles pour les humains mais visibles pour les robots ; une fois qu'ils sont tombés dans le piège, le site web bloque leur IP.
  
• Connexion requise: les sites web peuvent cacher certaines informations dont vous avez besoin derrière une page de connexion ; même si vous vous authentifiez sur le site web, le scraper n'a pas accès à vos informations d'identification ou aux cookies de votre navigateur.

Certains sites web ne mettent pas en œuvre ces techniques, mais le simple fait qu'ils veuillent offrir une meilleure expérience à l'utilisateur en utilisant Javascript complique la vie d'un scrapeur web.

Lorsqu'un site web utilise Javascript ou un cadre de génération HTML, une partie du contenu n'est accessible qu'après certaines interactions avec le site web ou après l'exécution d'un script (généralement écrit en Javascript) qui génère le document HTML.

Considérons également la qualité des données extraites. Par exemple, sur un site de commerce électronique, vous pouvez voir des prix différents selon la région où vous vivez. Ces données ne sont pas très précises, et le robot doit donc trouver un moyen d'extraire les données le plus précisément possible.

Si vous parvenez à surmonter tous ces obstacles, vous devez néanmoins tenir compte du fait que la structure d'un site web peut toujours subir des modifications. Après tout, un site web doit être convivial pour les utilisateurs, et non pour les robots, et notre outil automatisé doit donc s'adapter à ces changements.

Dans cette guerre sans fin du scraping, les bots trouvent eux-mêmes des solutions. L'objectif de toutes ces solutions est de recréer le mieux possible le comportement humain sur l'internet.

Par exemple, vous pouvez éviter le blocage de l'IP en utilisant des services de proxy IP. Il est préférable d'utiliser des services payants, car les services gratuits rendent leurs IP publiques, de sorte qu'un site web peut les bloquer.

Vous pouvez également intégrer des résolveurs de CAPTCHA. Ils vous aideront à obtenir des flux de données continus, mais ralentiront légèrement le processus de scraping.

Comme solution aux pièges à miel, vous pouvez utiliser XPath (ou même des expressions régulières si vous êtes assez audacieux) pour récupérer des éléments spécifiés au lieu de l'ensemble du document HTML.

L'examen de tous ces problèmes et de la manière de les résoudre peut devenir un processus laborieux et fastidieux. C'est la raison pour laquelle, au cours de la dernière décennie, les API de web scraping ont suscité de plus en plus d'intérêt.

Ici, sur WebScrapingAPI, nous collectons le contenu HTML de n'importe quel site web, en gérant tous les défis possibles (comme ceux mentionnés plus haut). De plus, nous utilisons les services Web d'Amazon, de sorte que la vitesse et l'évolutivité ne sont pas un problème. Êtes-vous tenté d'essayer ? Vous pouvez commencer par un compte gratuit, qui vous offre 1000 appels API par mois. C'est génial, non ?

Comprendre le Web

Mais revenons à l'objet de cet article. Nous voulons apprendre à construire un scraper web en utilisant Python.

Le premier concept à connaître est le protocole de transfert hypertexte (HTTP), qui explique la communication entre un serveur et un client. L'idée sous-jacente est assez simple. Le client (l'application) envoie un message (requête HTTP) au serveur, qui lui renvoie une réponse.

Le message contient plusieurs informations qui décrivent le client et la manière dont il traitera les données : méthode, version HTTP et en-têtes.

Dans le domaine du web scraping, la méthode la plus utilisée pour une requête HTTP est GET. Cela signifie que vous allez récupérer les données que vous demandez. Si vous souhaitez en savoir plus, vous trouverez ici une liste complète et détaillée.

Les en-têtes contiennent des informations supplémentaires sur la requête ou la réponse HTTP. Nous parlerons des plus pertinentes dans le cadre du web scraping, mais vous pouvez consulter la liste complète.

• User-Agent: utilisé pour identifier l'application, le système d'exploitation, le logiciel et sa version ; un scraper web utilise cet en-tête pour rendre les requêtes plus réalistes.
  
• Cookie: contient des informations sur l'état de la demande (par exemple, le jeton d'authentification).
• Host: spécifie le nom de domaine du serveur et, éventuellement, le numéro de port sur lequel le serveur est à l'écoute.
• Référent: contient le site source d'où provient l'utilisateur ; en fonction de celui-ci, le contenu affiché peut être différent, de sorte qu'un scraper web doit également en tenir compte.
• Acceptation: indique au serveur le type de contenu qu'il peut renvoyer en réponse ; cette fonction est souvent négligée dans le cadre du "web scraping", bien qu'elle puisse offrir une communication plus organique entre le client et le serveur.

Comprendre Python

Python est un langage de programmation général et de haut niveau qui parvient à se maintenir dans les préférences des développeurs pour de multiples raisons :

• Code lisible: sa syntaxe simple en fait un choix idéal pour les débutants.
• Paradigmes de programmation: la programmation orientée objet, structurée, fonctionnelle et orientée aspect n'en sont que quelques exemples.
• Bibliothèque standard robuste: large éventail de modules pour tous les besoins
• Communauté active: nombreuses bibliothèques et outils à code source ouvert

Bien, ceci étant dit, préparons notre espace de travail. Tout d'abord, nous avons besoin de Python3. Vous pouvez le télécharger et l'installer ici.

Ce tutoriel est indépendant de l'IDE, vous pouvez donc choisir celui avec lequel vous êtes le plus à l'aise. Nous préférons Visual Studio Code parce qu'il est léger et disponible dans plusieurs langues.

Nous allons également utiliser un certain nombre de bibliothèques Python :

• requêtes: pour effectuer une requête HTTP
• beautifulsoup: pour analyser le document HTML
• selenium: pour récupérer du contenu dynamique
• nltk (facultatif) : pour traiter le langage naturel

Il n'est pas nécessaire de les installer tous à l'avance, car des détails et des instructions d'installation sont fournis à chaque étape.

Maintenant, commençons à fouiller le Web !

Fabriquer son propre scraper web

Pour vous faciliter la tâche, le tutoriel est divisé en étapes. Vous verrez également quelques étapes bonus marquées d'un .1 après le numéro. Il s'agit d'alternatives qui pourraient vous intéresser.

Étape 1 : Inspecter la page que vous souhaitez récupérer

Bon, trêve de bavardages, entrons dans le vif du sujet.

Tout d'abord, nous devons choisir un site web que nous voulons récupérer. Pour illustrer les principes, choisissons un site web éducatif simple : https://en.wikipedia.org/wiki/Beer.

Dans cette étape, nous voulons seulement vérifier le document HTML de la page pour avoir une brève idée de sa structure. Peu importe le navigateur ou le système d'exploitation que vous utilisez pour cette étape, le processus est le même. Cliquez avec le bouton droit de la souris n'importe où, sur une image, un lien ou un simple bloc de texte, puis choisissez l'option "Inspecter l'élément".

L'onglet "Éléments" est le seul élément sur lequel nous nous concentrerons. Selon le site web, vous pouvez voir beaucoup de code HTML. Il est important de ne pas se laisser submerger par ce code et de ne vérifier que les données qui vous intéressent.

Étape 2 : Envoyer une requête HTTP

Nous pouvons maintenant commencer à écrire le code de notre scraper web. Nous commençons simplement par envoyer une requête HTTP à notre site web pour renvoyer le code HTML complet que nous venons de voir dans le navigateur. À quoi cela ressemblerait-il dans le code ? Eh bien, c'est époustouflant ! Nous parlons de Python, après tout.

Installons la bibliothèque requests pour effectuer la requête HTTP :

pip install requests

Maintenant, écrivons le code :

import requests
URL = 'https://en.wikipedia.org/wiki/Beer'
page = requests.get(URL)

C'est assez simple, n'est-ce pas ? Nous avons importé la bibliothèque que nous avons installée précédemment. Nous avons ensuite défini l'URL du site web que nous voulons récupérer, et nous avons effectué une requête GET. Si vous voulez voir le résultat, allez-y et imprimez-le. Pour l'instant, vous ne verrez qu'une chaîne désordonnée qui devrait représenter le HTML que vous avez vu dans votre navigateur. Cela ne nous aide pas beaucoup, nous devons donc la traiter.

Étape 3 : Récupérer le code HTML de la page

Pour extraire des informations utiles de nos résultats, nous allons installer la bibliothèque beautifulsoup:

pip install beautifulsoup4

Commençons par mettre en forme notre résultat :

import requests
from bs4 import BeautifulSoup
 
URL = 'https://en.wikipedia.org/wiki/Beer'
page = requests.get(URL)
 
soup = BeautifulSoup(page.content, 'html.parser')
prettyHTML = soup.prettify()
print(prettyHTML)

Nous convertissons le résultat précédent en un objet BeautifulSoup. Avec l'attribut .content, vous pouvez accéder aux données HTML. En appliquant la méthode .prettify(), vous pouvez voir le même format que vous avez vu dans votre navigateur plus tôt.

Malheureusement, tous les sites web ne vous donneront pas leur code HTML complet de cette manière. Comme nous l'avons dit plus haut, les web scrapers rencontrent certaines difficultés.

Étape 3.1 : Contenu dynamique

Par exemple, certaines pages ne sont visibles qu'après connexion. Même si vous vous authentifiez à partir de votre navigateur, votre script python ne pourra pas accéder aux données.

Une autre situation courante est celle des sites web dynamiques. Cela signifie que la réponse à la requête GET n'est pas un document HTML mais un script Javascript. Même si vous pouvez voir le HTML dans le navigateur, c'est parce qu'il exécute le script. Mais dans votre code, vous devez exécuter le script localement pour obtenir le HTML.

Mais voyons cette situation en pratique. Nous choisirons un exemple minimaliste de site web rapidement construit à partir d'un ancien exercice collégial : https://dynamic-website.surge.sh.

Vous pouvez voir le code HTML complet dans votre navigateur. Dans cet exemple, il s'agit d'un tableau dont les cellules contiennent des images.

import requests
from bs4 import BeautifulSoup
 
URL = 'https://dynamic-website.surge.sh'
page = requests.get(URL)
soup = BeautifulSoup(page.content, 'html.parser')
 
file = open('page.txt', mode='w', encoding='utf-8')
file.write(soup.prettify())

Nous allons maintenant extraire ce code HTML, ce qui signifie que nous allons exécuter le même code que précédemment, avec quelques modifications : nous avons mis à jour l'URL et ouvert un fichier texte pour stocker notre résultat. Nous exécutons le programme et vérifions le fichier page.txt pour la même section de tableau.

What is that? Where is the table? Well, it is there, except that there was no one to generate it yet. You can look into the <head> tag of the HTML document to see if there are any scripts used:

Et oui, nous utilisons un script.

Pour résoudre ce problème, nous avons besoin de selenium, une bibliothèque utilisée pour les tests web et l'automatisation des activités du navigateur. Nous l'utiliserons en mode headless, ce qui signifie qu'il se comportera comme un navigateur normal qui exécutera le code Javascript mais sans interface utilisateur visible.

pip install selenium

Dans ce tutoriel, nous allons utiliser le ChromeDriver pour configurer le pilote web pour selenium. N'oubliez pas de copier le chemin où vous l'avez téléchargé ! Nous l'avons sauvegardé dans le répertoire C, mais n'importe quel emplacement fonctionnera.

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from bs4 import BeautifulSoup
 
CHROMEDRIVER_PATH = "your/path/here/chromedriver_win32/chromedriver"
URL = "https://dynamic-website.surge.sh"
 
options = Options()
options.headless = True
driver = webdriver.Chrome(CHROMEDRIVER_PATH, options=options)
 
driver.get(URL)
soup = BeautifulSoup(driver.page_source, 'html.parser')
 
file = open('page.txt', mode='w', encoding='utf-8')
file.write(soup.prettify())

Le reste du processus est à peu près le même, sauf que nous n'utilisons plus la bibliothèque requests pour effectuer la requête HTTP.

Nous relançons le programme, et...

...Voilà ! Nous avons maintenant le code HTML complet.

Étape 4 : Extraction de sections spécifiques

Très bien, revenons à nos moutons.

Disposer du code HTML complet est un excellent progrès, mais le processus n'est pas terminé. La plupart du temps, nous avons besoin d'informations spécifiques sur un site web, alors voyons comment nous pouvons les extraire.

Let’s start with something small -  the title of the website. You can find it in the <head> section of the HTML, under a <title> tag.

Nous savons qu'un site web n'a qu'un seul titre, c'est pourquoi nous utiliserons la méthode.find(). Elle prend le nom de la balise en entrée et renvoie l'élément HTML, de sorte que si vous avez besoin de son contenu, il vous suffit d'y accéder par l'intermédiaire de l'attribut .text. Nous allons également ajouter un peu de structure à notre petit scraper.

def extract_title(soup):
    title = soup.find('title')
 
    #output: <title>Beer - Wikipedia</title>    
    print('Title element: ', title)
 
    #output: Beer - Wikipedia
    print('Title: ', title.text)
 
def main():
    URL = 'https://en.wikipedia.org/wiki/Beer'
    page = requests.get(URL)
    soup = BeautifulSoup(page.content, 'html.parser')
 
    extract_title(soup)
 
main()

Rien de bien sorcier ici. BeautifulSoup est une bibliothèque puissante qui prend en charge différents modèles d'extraction de données spécifiques. Vous pouvez obtenir des éléments HTML par leur nom, id, et attribut de classe, ou vous pouvez même utiliser des sélecteurs CSS. Tout est possible !

Allons plus loin, par exemple en extrayant les éléments qui apparaissent plusieurs fois. Dans ce cas, nous utilisons la méthode.find_all(). La seule différence est qu'elle renvoie une liste d'éléments au lieu d'un seul. C'est pourquoi nous la parcourons ensuite et affichons les attributs de chaque élément. À titre d'exemple, nous avons extrait toutes les images de l'article :

def extract_images(soup) :
 images = soup.find_all('img')
 for image in images :
 imageAlt = image.get('alt')
 imageSrc = image.get('src')
 print("ALT : ", imageAlt, "SRC : ", imageSrc)
 
def main() :
   URL = 'https://en.wikipedia.org/wiki/Beer'
 page = requests.get(URL)
 soup = BeautifulSoup(page.content, 'html.parser')
 
 extract_images(soup)
 
main()

Étape 5 : Passer les fonctions pendant le raclage

Une situation courante dans le domaine du web scraping est celle où la liste des résultats de l'analyse est très longue et contient des informations mixtes.

Par exemple, vous avez peut-être remarqué que nos images précédentes contenaient ou non un attribut alt.

Ou imaginons que nous extrayons tous les liens de l'article. Nous savons tous qu'un article de Wikipédia contient BEAUCOUP de liens, et nous ne voulons peut-être pas en obtenir une liste complète. Le résultat comportera des liens externes et internes, des références et des citations, et nous devons donc les classer en plusieurs catégories.

Pour résoudre ce problème, nous allons utiliser une fonction lambda. En principe, la fonction lambda prend en paramètre chaque élément de la liste de résultats et applique la condition que nous avons définie, tout comme un filtre.

Pour un exemple pratique, supposons que nous ayons besoin d'extraire tous les liens internes, d'accéder à leur article et de faire un résumé de chacun d'entre eux. Étant donné que l'un des cas d'utilisation de Python est l'intelligence artificielle, cet exemple pourrait être une excellente application pour obtenir des données d'entraînement.

Tout d'abord, nous devons installer la bibliothèque NLTK, car le calcul d'un résumé implique le traitement du langage humain.

pip install -U nltk

Et, bien sûr, de l'importer dans notre code :

import re
import nltk
import heapq
# ne télécharger que pour la première exécution
# avertissement : la taille du jeu de données est importante ; cela prendra donc du temps
nltk.download()

Note : si vous utilisez macOS, il se peut que vous obteniez une erreur "SSL : certificate verify failed". La cause peut être que Python3.6 utilise une version intégrée d'OpenSSL. Tout ce que vous avez à faire est d'ouvrir l'emplacement où vous avez installé Python et d'exécuter ce fichier :

/Votre/Path/Here/Python 3.6/Installer les certificats.command

Comme vous pouvez le voir, nous avons également importé la bibliothèque re, utilisée pour les opérations avec les expressions régulières, et heapq, une implémentation de la file d'attente du tas.

Bien, nous avons tout ce qu'il faut pour commencer à écrire le code. Commençons par extraire les liens internes. Si vous retournez dans le navigateur, vous remarquerez certaines choses sur les éléments qui nous intéressent.

Ces choses seraient :

• L'attribut href a une valeur ;
• La valeur href commence par "/wiki/" ;
• The link’s parent is a <p> tag;

Ces caractéristiques nous aideront à différencier les liens dont nous avons besoin de tous les autres.

Maintenant que nous savons comment trouver les liens, voyons comment les extraire.

count = 0
 
def can_do_summary(tag) :
 global count
 if count > 10 : return False
 
 # Rejet si le parent n'est pas un paragraphe
 if not tag.parent.name == 'p' : return False
 
 href = tag.get('href')
 # Rejet si href n'est pas défini
 if href is None : return False
 
 # Rejet si la valeur href ne commence pas par /wiki/
 if not href.startswith('/wiki/') : return False
 
 compute_summary(href)
 return True
 
 
def extract_links(soup) :
 soup.find_all(lambda tag : tag.name == 'a' and can_do_summary(tag))
 
def main() :
   URL = 'https://en.wikipedia.org/wiki/Beer'
 page = requests.get(URL)
 soup = BeautifulSoup(page.content, 'html.parser')
 
 extract_links(soup)
 
main()

D'accord, que s'est-il passé ici ? En examinant la fonction extract_links(), nous pouvons voir qu'au lieu du nom d'une balise, nous avons passé une fonction lambda comme paramètre à la méthode .find_all(). Cela signifie que nous ne sélectionnons que celles qui correspondent à notre condition parmi toutes les balises du document HTML.

Comme vous pouvez le voir, la condition d'une balise est d'être un lien et d'être acceptée par la fonction can_do_summary() définie ci-dessus. Là, nous rejetons tout ce qui ne correspond pas aux caractéristiques observées précédemment. Nous avons également utilisé une variable globale pour limiter le nombre de liens extraits à 10. Si vous avez besoin de tous les liens, n'hésitez pas à supprimer la variable count.

À la fin, nous appelons la fonction compute_summary() pour le nouveau lien trouvé. C'est là que l'article est résumé.

def compute_summary(href):
    global count
    full_link = 'https://en.wikipedia.org' + href
    page = requests.get(full_link)
    soup = BeautifulSoup(page.content, 'html.parser')
 
    # Concatenate article paragraphs
    paragraphs = soup.find_all('p')
    article_text = ""
    for p in paragraphs:
        article_text += p.text
 
    # Removing Square Bracket, extra spaces, special characters and digits
    article_text = re.sub(r'\[[0-9]*\]', ' ', article_text)
    article_text = re.sub(r'\s+', ' ', article_text)
    formatted_article_text = re.sub('[^a-zA-Z]', ' ', article_text)
    formatted_article_text = re.sub(r'\s+', ' ', formatted_article_text)
 
    # Converting text to sentences
    sentence_list = nltk.sent_tokenize(article_text)
 
    # Find frequency of occurrence of each word
    stopwords = nltk.corpus.stopwords.words('english')
 
    word_frequencies = {}
    for word in nltk.word_tokenize(formatted_article_text):
        if word not in stopwords:
            if word not in word_frequencies.keys():
                word_frequencies[word] = 1
            else:
                word_frequencies[word] += 1
 
    maximum_frequency = max(word_frequencies.values())
 
    for word in word_frequencies.keys():
        word_frequencies[word] = (word_frequencies[word] / maximum_frequency)
 
    # Calculate the score of each sentence
    sentence_scores = {}
    for sent in sentence_list:
        for word in nltk.word_tokenize(sent.lower()):
            if word in word_frequencies.keys():
                if len(sent.split(' ')) < 30:
                    if sent not in sentence_scores.keys():
                        sentence_scores[sent] = word_frequencies[word]
                    else:
                        sentence_scores[sent] += word_frequencies[word]
 
    # Pick top 7 sentences with highest score
    summary_sentences = heapq.nlargest(7, sentence_scores, key=sentence_scores.get)
    summary = '\n'.join(summary_sentences)
    count += 1

Pour faire court, nous effectuons une requête HTTP vers l'URL trouvée et convertissons le résultat en un objet BeautifulSoup, comme nous l'avons fait au début de l'article.

Pour calculer un résumé, nous extrayons tous les paragraphes de l'article et les concaténons. Ensuite, nous supprimons tous les caractères spéciaux qui pourraient interférer avec les calculs.

En termes simples, un résumé est réalisé en calculant les mots les plus fréquents et en attribuant à chaque phrase un score basé sur la fréquence des mots. Au final, nous sélectionnons les 7 phrases ayant le score le plus élevé.

Ce n'est pas le sujet de notre article, mais vous pouvez en savoir plus ici si vous êtes curieux ou même passionné par le traitement du langage naturel.

Étape 6 : Générer un fichier CSV pour stocker vos données

Pour passer à la dernière étape de ce guide, nous devons examiner les résultats du scraping. Jusqu'à présent, nous les avons simplement affichés dans le terminal parce qu'il n'y avait que quelques lignes de données.

Mais le scraping dans la vie réelle signifie une quantité considérable d'informations, nous devrions donc voir comment nous pouvons sauvegarder les résultats dans un fichier.

Utilisons la bibliothèque native csv (il n'est donc pas nécessaire d'installer quoi que ce soit d'autre) et ouvrons un fichier nommé summaries.csv.

import csv
fichier_sommaires = open('summaries.csv', mode='a', encoding='utf-8')

La bibliothèque créera le fichier s'il n'existe pas. En outre, nous l'ouvrons en mode "append", car chaque lien est traité séquentiellement, un par un.

    summaries_writer = csv.writer(summaries_file, delimiter=',', quotechar='""', quoting=csv.QUOTE_MINIMAL)
 summaries_writer.writerow([full_link, summary])

À la fin de la fonction compute_summary(), nous initialisons simplement le rédacteur et commençons à ajouter les données. Une ligne est composée de l'URL de l'article et de son résumé.

Étape 6.1 : Générer un fichier JSON

Un autre format de sérialisation des données qui est devenu populaire ces dernières années est JavaScript Object Notation (JSON). Il est facilement lisible par l'homme et pratique si vous souhaitez transmettre les données scannées à une API ou à une autre application.

En Python, la manière la plus simple d'écrire un fichier JSON est de passer les données à un objet dict.

import json
 
summaries_file = open('summaries.json', mode='a', encoding='utf-8')
data = {}
data['summaries'] = []

Nous allons utiliser la bibliothèque native pour les fichiers JSON et ouvrir un nouveau fichier, comme nous l'avons fait précédemment avec notre fichier CSV. Ensuite, nous initialisons un objet dict vide et une liste vide qui contiendra nos résumés.

data['summaries'].append({
'url': full_link,
      'summary': summary
})

À la fin de la fonction compute_summary(), juste à l'endroit où nous avons écrit le CSV plus tôt, nous ajoutons maintenant un nouvel objet dict à la liste finale.

json.dump(data, summaries_file, indent=4)

Enfin, dans notre fonction main(), après avoir exécuté le processus extract_links(), nous écrivons l'objet final dans le fichier. Le paramètre indent ne fera que mettre en forme le résultat.

Conclusion et alternatives

Voilà, c'est la fin de notre tutoriel. J'espère qu'il vous a été utile et qu'il vous a donné un bon aperçu du web scraping en utilisant Python.

Nous avons découvert ses avantages et la manière dont il peut améliorer votre entreprise/application. En même temps, nous avons équilibré ces informations avec certains des défis rencontrés dans le web scraping.

Si vous êtes un développeur, vous trouverez peut-être passionnant de construire vous-même un scraper web en surmontant tous ces problèmes. Cela peut être une expérience d'apprentissage intéressante.

Mais en tant que chef d'entreprise (ou en tant que personne ayant besoin de données pour une application réelle à grande échelle), vous voudrez peut-être éviter les coûts que cela implique (temps, argent, personnel).

Dans ce cas, l'utilisation d'une API dédiée résoudra le problème. WebScrapingAPI surmonte tous les points de blocage possibles : rendu Javascript, proxies, CAPTHA, etc., et offre des fonctionnalités personnalisables. De plus, si vous n'êtes pas tout à fait sûr de vous, rappelez-vous qu'il existe une option de plan gratuit, alors pourquoi ne pas l'essayer ?