Scrapy ou Requests : lequel est le meilleur pour le Scraping web ?

Dans ce guide Scrapy vs Requests, vous découvrirez :

• Ce que sont Scrapy et Requests
• Une comparaison entre Scrapy et Requests pour le Scraping web
• Une comparaison entre Scrapy et Requests dans un scénario de pagination
• Les limites communes entre Scrapy et Requests dans les scénarios de Scraping web

C’est parti !

Qu’est-ce que Requests ?

Requestsest une bibliothèque Python permettant d’envoyer des requêtes HTTP. Elle est largement utilisée dans le Scraping web, généralement associée à des bibliothèques d’analyse HTML telles queBeautifulSoup.

Les principales fonctionnalités de Requests pour le Scraping web sont les suivantes :

• Prise en charge des méthodes HTTP: vous pouvez utiliser toutes les principales méthodes HTTP telles queGET,POST,PUT,PATCH etDELETE, qui sont essentielles pour interagir avec les pages web et les API.
• En-têtes personnalisés: définissez des en-têtes personnalisés (par exemple,User-Agentet autres) pour imiter un navigateur réel ou gérer l’authentification de base.
• Gestion des sessions: l’objetrequests.Session()vous permet de conserver les cookies et les en-têtes sur plusieurs requêtes. Cela est utile pour le scraping de sites web qui nécessitent une connexion ou le maintien de l’état des sessions.
• Délais d’expiration et gestion des erreurs: vous pouvez définir des délais d’expiration pour éviter les requêtes bloquées et gérer les exceptions pour un scraping robuste.
• Prise en charge des proxys: vous pouvez acheminer vos requêtes via des proxys, ce qui est utile pour contourner les interdictions d’IP et accéder à des contenus soumis à des restrictions géographiques.

Qu’est-ce que Scrapy ?

Scrapyest un framework open source de Scraping web écrit en Python. Il est conçu pour extraire des données de sites web de manière rapide, efficace et évolutive.

Scrapy fournit un framework complet pour explorer des sites web, extraire des données et les stocker dans différents formats (par exemple, JSON, CSV, etc.). Il est particulièrement utile pour les projets de Scraping web à grande échelle, car il peut gérer des tâches d’exploration complexes et des requêtes simultanées tout en respectant les règles d’exploration.

Les principales fonctionnalités de Scrapy pour le Scraping web sont les suivantes :

• Exploration Web intégrée: Scrapy est conçu pour être unrobot d’exploration Web. Cela signifie qu’il peut suivre automatiquement les liens d’une page Web, ce qui vous permet d’explorer plusieurs pages ou des sites entiers avec un minimum d’effort.
• Requêtes asynchrones: il utilise une architecture asynchrone pour traiter plusieurs requêtes simultanément. Cela le rend beaucoup plus rapide queles clients HTTP Pythontels querequests.
• Sélecteurs pour l’extraction de données: Scrapy offre la possibilité d’extraire des données du HTML à l’aide de XPaths et de sélecteurs CSS.
• Middleware pour la personnalisation: il prend en charge le middleware pour personnaliser la manière dont les requêtes et les réponses sont traitées.
• Limitation automatique: il peut limiter automatiquement les requêtes afin d’éviter de surcharger le serveur cible. Cela signifie qu’il peut ajuster la vitesse d’exploration en fonction des temps de réponse et de la charge du serveur.
• Gestiondufichierrobots.txt: il respecte lefichierrobots.txtpour le Scraping web, garantissant ainsi que vos activités de scraping sont conformes aux règles du site.
• Rotation des proxys et des agents utilisateurs: Scrapy prend en chargelarotation des proxysetdes agents utilisateursvia des middlewares, ce qui permet d’éviter les interdictions et la détection d’adresses IP.

Scrapy vs Requests : comparaison des fonctionnalités pour le Scraping web

Maintenant que vous savez ce que sont Requests et Scrapy, il est temps de comparer en détail leurs utilisations pour le Scraping web :

Cas d’utilisation

Scrapy est un framework complet de Scraping web destiné aux projets de scraping complexes et à grande échelle. Il est idéal pour les tâches impliquant l’exploration de plusieurs pages, les requêtes simultanées et l’exportation de données dans des formats structurés.

Requests, quant à lui, est une bibliothèque qui gère les requêtes HHTP. Il est donc mieux adapté aux tâches simples telles que la récupération d’une seule page web, l’interaction avec des API ou le téléchargement de fichiers.

Requêtes asynchrones et concurrence

Scrapy est basé surTwisted, un framework réseau événementiel pour Python. Cela signifie qu’il peut traiter simultanément des requêtes asynchrones et multiples, ce qui le rend beaucoup plus rapide pour le scraping à grande échelle.

Requests, en revanche, ne prend pas en charge les requêtes asynchrones ou simultanées de manière native. Si vous souhaitez effectuer des requêtes HTTP asynchrones, vous pouvez l’intégrer àGRequests.

Exploration

Lorsque le paramètreROBOTSTXT_OBEYest défini surTrue, Scrapy lit le fichierrobots.txt, suit automatiquement les liens autorisés sur une page web et explore les pages autorisées.

Requests ne dispose pas de capacités de crawling intégrées, vous devez donc définir manuellement les liens et effectuer des requêtes supplémentaires.

Extraction de données

Scrapy offre une prise en charge intégrée pour l’extraction de données à l’aide desélecteurs XPath et CSS, ce qui facilite l’analyse du HTML et du XML.

Requests n’inclut aucune fonctionnalité d’extraction de données. Vous devez utiliser des bibliothèques externes telles queBeautifulSoup pour effectuer l’analyse et l’extraction des données.

Middleware

Scrapy propose des middlewares personnalisables pour gérerles Proxies,les réessais,les en-têtes, etc. Cela le rend très extensible pour les tâches de scraping avancées.

Requests ne fournit quant à lui aucune prise en charge des middlewares. Vous devez donc implémenter manuellement des fonctionnalités telles quela rotation des Proxysou les réessais.

Limitation

Scrapy inclut une fonctionnalité de régulation automatique intégrée qui permet d’ajuster la vitesse d’exploration en fonction des temps de réponse et de la charge du serveur. Vous pouvez ainsi éviter de saturer le serveur cible avec des requêtes HTTP.

Requests ne dispose pas d’une fonctionnalité de régulation intégrée. Si vous souhaitez implémenter la régulation, vous devez ajouter manuellement des délais entre les requêtes, par exemple en utilisant la méthode time.sleep().

Rotation des proxys

Scrapy prend en charge la rotation des Proxies via des middlewares, ce qui permet d’éviter facilement les interdictions d’IP et de scraper des sites de manière anonyme.

Requests ne fournit pas de fonctionnalité de rotation des proxys intégrée. Si vous souhaitez gérer les proxys avecRequests, vous devez les configurer manuellement et écrire une logique personnalisée,comme expliqué dans notre guide.

Gestion des erreurs

Scrapy inclut des mécanismes de réessai intégrés pourles requêtes ayant échoué, ce qui le rend robuste pour gérer les erreurs réseau ou les problèmes de serveur.

Au contraire, Requests vous oblige à gérer manuellement les erreurs et les exceptions, par exemple en utilisant le bloctry-except. Envisagez également des bibliothèques telles queretry-requests.

Téléchargement de fichiers

Scrapy prend en charge le téléchargement de fichiers viaFilesPipeline, mais nécessite une configuration supplémentaire pour gérer les fichiers volumineux ou le streaming.

Requests fournit une prise en charge simple et directe du téléchargement de fichiers avec le paramètre stream=True dans la méthode requests.get().

Scrapy vs Requests : comparaison des deux bibliothèques dans un scénario de pagination

Vous savez désormais ce que sont Requests et Scrapy. Préparez-vous à découvrir un tutoriel comparatif étape par étape pour un scénario spécifique de Scraping web !

L’accent sera mis sur la comparaison entre ces deux bibliothèques dans un scénario de pagination.La gestion de la pagination dans le Scraping webnécessite une logique personnalisée pour le suivi des liens et l’extraction de données sur plusieurs pages.

Le site cible seraQuotes to Scrape, qui fournit des citations d’auteurs célèbres sur différentes pages :

L’objectif du tutoriel est de montrer comment utiliser Scrapy et Requests pour récupérer les citations de toutes les pages. Nous commencerons par Requests, car son utilisation peut être plus complexe que celle de Scrapy.

Configuration requise

Pour reproduire les tutoriels pour Scrapy et Requests, vous devez avoir installéPython 3.7 ou une version supérieuresur votre ordinateur.

Comment utiliser Requests pour le Scraping web

Dans ce chapitre, vous apprendrez à utiliser Requests pour extraire toutes les citations du site cible.

Gardez à l’esprit que vous ne pouvez pas utiliser Requests seul pour extraire des données directement à partir de pages web. Vous aurez également besoin d’unanalyseur HTML tel que BeautifulSoup.

Étape n° 1 : configuration de l’environnement et installation des dépendances

Supposons que vous appeliez le dossier principal de votre projet requests_scraper/. À la fin de cette étape, le dossier aura la structure suivante :

requests_scraper/
    ├── requests_scraper.py
    └── venv/

Où :

• requests_scraper.pyest le fichier Python qui contient tout le code
• venv/contient l’environnement virtuel

Vous pouvez créer le répertoired’environnement virtuelvenv/comme suit :

python -m venv venv

Pour l’activer, sous Windows, exécutez :

venvScriptsactivate

De manière équivalente, sous macOS et Linux, exécutez :

source venv/bin/activate

Vous pouvez maintenant installer les bibliothèques requises avec :

pip install requests beautifulsoup4

Étape n° 2 : configuration des variables

Vous êtes maintenant prêt à commencer à écrire du code dans le fichier requests_scraper.py.

Commencez par configurer les variables comme suit :

base_url = "https://quotes.toscrape.com"
all_quotes = []

Ici, vous avez défini :

• base_urlcomme URL de départ du site web à scraper
• all_quotescomme une liste vide utilisée pour stocker toutes les citations au fur et à mesure qu’elles sont extraites

Étape n° 3 : créer la logique de scraping

Vous pouvez implémenter la logique de scraping et de crawling à l’aide du code suivant :

url = base_url
while url:
    # Envoyer une requête GET à la page actuelle
    response = requests.get(url)

    # Analyser le code HTML de la page
    soup = BeautifulSoup(response.text, "html.parser")

    # Trouver tous les blocs de citations
    quotes = soup.select(".quote")
    for quote in quotes:
        text = quote.select_one(".text").get_text(strip=True)
        author = quote.select_one(".author").get_text(strip=True)
        tags = [tag.get_text(strip=True) for tag in quote.select(".tag")]
        all_quotes.append({
            "text": text, 
            "author": author, 
            "tags": ",".join(tags)
        })

    # Rechercher le bouton « Suivant »
    next_button = soup.select_one("li.next")
    if next_button:
        # Extraire l'URL du bouton « Suivant » et
        # la définir comme prochaine page à extraire
        next_page = next_button.select_one("a")["href"]
        url = base_url + next_page
    else:
        url = None

Ce code :

• Instancier une bouclewhilequi continuera à s’exécuter jusqu’à ce que toutes les pages soient extraites
• Sous la bouclewhile:
  • soup.``select``()intercepte tous les éléments HTML de citation sur la page. Le code HTML de la page est structuré de manière à ce que chaque élément de citation ait une classe appeléequote.
  • Le cycleforitère sur toutes les classesquotepour extraire le texte, l’auteur et les balises des citations à l’aide des méthodes de scraping de Beautiful Soup. Ici, vous avez besoin d’une logique personnalisée pour les balises, car chaque élément quote peut contenir plusieurs balises.
    
• Après avoir scrapé toute la page, le script recherche le boutonsuivant. Si le bouton existe, il extrait le lien vers la page suivante. Ensuite, l’URL de base est mise à jour pour devenir la suivante via la variableurl = base_url + next_page. Lorsque le processus atteint la dernière page, l’URL suivante est définie surNone et le processus se termine.

Étape n° 4 : ajouter les données à un fichier CSV

Maintenant que vous avez récupéré toutes les données, vous pouvez les ajouter à un fichier CSV comme ci-dessous :

with open("quotes.csv", mode="w", newline="", encoding="utf-8") as file:
    writer = csv.DictWriter(file, fieldnames=["text", "author", "tags"])
    writer.writeheader()
    writer.writerows(all_quotes)

Cette partie du script utilise la bibliothèquecsvpour :

• Spécifier le nom du fichier CSV de sortie commequotes.csv.
• Ouvrir le CSV en mode écriture (mode="w") et :
  • Écrire la ligne d’en-tête dans le CSV
  • Écrire toutes les citations récupérées dans le fichier

Étape n° 5 : assembler le tout

Voici le code complet pour cette partie du tutoriel consacrée à Scrapy vs Requests :

import requests
from bs4 import BeautifulSoup
import csv

# URL du site web
base_url = "https://quotes.toscrape.com"
# Liste pour stocker toutes les citations
all_quotes = []

# Commencez à extraire les données à partir de la première page
url = base_url
while url:
    # Envoyez une requête GET à la page actuelle
    response = requests.get(url)

    # Analysez le code HTML de la page
    soup = BeautifulSoup(response.text, "html.parser")

    # Rechercher tous les blocs de citations
    quotes = soup.select(".quote")
    for quote in quotes:
        text = quote.select_one(".text").get_text(strip=True)
        author = quote.select_one(".author").get_text(strip=True)
        tags = [tag.get_text(strip=True) for tag in quote.select(".tag")]
        all_quotes.append({
            "text": text, 
            "author": author, 
            "tags": ",".join(tags)
        })

    # Rechercher le bouton « Suivant »
    next_button = soup.select_one("li.next")
    if next_button:
        # Extraire l'URL du bouton « Suivant » et
        # la définir comme prochaine page à extraire
        next_page = next_button.select_one("a")["href"]
        url = base_url + next_page
    else:
        url = None

# Enregistrer les citations dans un fichier CSV
with open("quotes.csv", mode="w", newline="", encoding="utf-8") as file:
    writer = csv.DictWriter(file, fieldnames=["text", "author", "tags"])
    writer.writeheader()
    writer.writerows(all_quotes)

Exécutez le script ci-dessus :

python requests_scraper.py

Un fichierquotes.csvapparaîtra dans le dossier du projet :

Comment utiliser Scrapy pour le Scraping web

Maintenant que vous avez appris à utiliser Requests pour le Scraping web, vous êtes prêt à découvrir comment utiliser Scrapy avec la même page cible et le même objectif.

Étape n° 1 : configuration de l’environnement et installation des dépendances

Supposons que vous souhaitiez appeler le dossier principal de votre projet scrapy_scraper/.

Tout d’abord, créez et activez un environnement virtuel comme indiqué précédemment, puis installez Scrapy :

pip install scrapy

Lancez Scrapy pour remplir le dossier principal avec des fichiers prédéfinis dans quotes_scraper/ à l’aide de la commande suivante :

scrapy startproject quotes_scraper

Voici la structure finale de votre projet :

scrapy_scraper/ 
├── quotes_scraper/ # Dossier principal du projet Scrapy
│   ├── __init__.py  
│   ├── items.py # Définit la structure des données pour les éléments extraits 
│   ├── middlewares.py # Middlewares personnalisés
│   ├── pipelines.py # Gère le post-traitement des données récupérées 
│   ├── settings.py # Paramètres du projet 
│   └── spiders/ # Dossier pour tous les spiders  
├── venv/ 
└── scrapy.cfg # Fichier de configuration Scrapy

Étape n° 2 : définir les éléments

Le fichier items.py définit la structure des données que vous souhaitez extraire. Puisque vous souhaitez récupérer les citations, les auteurs et les balises, définissez-le comme suit :

import scrapy

class QuotesScraperItem(scrapy.Item):
    quote = scrapy.Field()
    author = scrapy.Field()
    tags = scrapy.Field()

Étape n° 3 : définir le spider principal

Dans le dossier spiders/, créez les fichiers Python suivants :

• __init__.py, qui marque le répertoire comme un paquet Python
• quotes_spider.py

Le fichier quotes_spider.py contient la logique de scraping proprement dite :

import scrapy
from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule
from ..items import QuotesScraperItem

class QuotesSpider(CrawlSpider):
    name = "quotes"
    allowed_domains = ["quotes.toscrape.com"]
    start_urls = ["https://quotes.toscrape.com/"]

    # Définir les règles pour suivre les liens de pagination
    rules = (
        Rule(LinkExtractor(restrict_css="li.next a"), callback="parse_item", follow=True),
    )

    def parse_item(self, response):
        # Extraire les citations, les auteurs et les balises
        for quote in response.css("div.quote"):
            item = QuotesScraperItem()
            item["quote"] = quote.css("span.text::text").get()
            item["author"] = quote.css("small.author::text").get()
            item["tags"] = quote.css("div.tags a.tag::text").getall()
            yield item

L’extrait ci-dessus définit la classe QuotesSpider() qui effectue les opérations suivantes :

• Définit l’URL à scraper.
• Définit la règle de pagination avec la classeRule(), permettant au crawler de suivre toutes les pages suivantes.
• Extrait la citation, l’auteur et la balise à l’aide de la méthodeparse_item().

Étape n° 4 : définir les paramètres

L’ajout des données à un fichier CSV nécessite certaines configurations spéciales dans Scrapy. Pour ce faire, ouvrez le fichier settings.py et ajoutez-y les variables suivantes :

FEED_FORMAT = "csv"  
FEED_URI = "quotes.csv" 

Voici ce que font ces paramètres :

• FEED_FORMATdéfinit le format de sortie du fichier (qui peut être de différents types)
• FEED_URIdéfinit le nom du fichier de sortie

Étape n° 5 : lancer le crawler

Les fichiers Python non mentionnés dans les étapes précédentes ne sont pas utiles pour ce tutoriel, vous pouvez donc les laisser avec les données par défaut.

Pour lancer le crawler, allez dans le dossier quotes_scraper/:

cd quotes_scraper

Ensuite, lancez le crawler :

scrapy crawl quotes

Cette commande instancie la classe QuotesSpider() dans le fichier quotes_spider.py, qui est celle qui lance le crawler. Le fichier CSV final que vous obtenez est identique à celui que vous avez obtenu avec Requests et BeautifulSoup !

Cet exemple montre donc :

• En quoi Scrapy est plus adapté aux projets de grande envergure en raison de sa nature.
• La gestion de la pagination est plus facile avec Scrapy, car vous n’avez qu’à gérer une règle au lieu d’écrire une logique personnalisée, comme dans le cas précédent.
• Comment l’ajout de données à un fichier CSV est plus simple avec Scrapy. En effet, vous n’avez qu’à ajouter deux paramètres au lieu de créer la logique personnalisée classique que vous créeriez en écrivant un script Python qui le ferait.

Limitations communes entre Scrapy et Requests

Bien que Scrapy et Requests soient largement utilisés dans les projets de Scraping web, ils présentent certains inconvénients.

Plus précisément, l’une des limitations courantes auxquelles toutes les bibliothèques ou tous les frameworks de scraping sont soumis estle bannissement d’adresse IP. Vous avez appris que Scrapy offre une fonction de limitation, qui permet d’ajuster la vitesse à laquelle le serveur est sollicité. Cependant, cela n’est souvent pas suffisant pour éviter que votre adresse IP ne soit bannie.

La solution pour éviter que votre IP ne soit bannie consiste à implémenter des Proxys dans votre code. Voyons comment !

Utilisation d’un Proxy avec Requests

Si vous souhaitez utiliser un seul Proxy dans Requests, utilisez la logique suivante :

 Proxy = {
     "http": "<HTTP_PROXY_URL>",
     "https": "<HTTPS_PROXY_URL>"
 }
 response = requests.get(url, proxies=Proxy)

Pour en savoir plus sur les proxys et la rotation des proxys dans Requests, consultez ces guides sur notre blog :

• Guide d’utilisation d’un Proxy avec Python Requests
• Comment utiliser des proxys pour faire tourner les adresses IP dans Python

Utilisation d’un Proxy dans Scrapy

Si vous souhaitez implémenter un seul Proxy dans votre code, ajoutez les paramètres suivants au fichier settings.py:

# Configurer un seul Proxy
HTTP_PROXY = "<PROXY_URL>"

# Activer HttpProxyMiddleware et désactiver UserAgentMiddleware par défaut
DOWNLOADER_MIDDLEWARES = {
    'scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware': 110,
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
}

Ces paramètres achemineront toutes les requêtes via le Proxy spécifié. Pour en savoir plus, consultez notreguide d’intégration du Proxy Scrapy.

Si vous souhaitez plutôt mettre en place des Proxys rotatifs, vous pouvez utiliser labibliothèquescrapy-rotating-proxies. De même, vous pouvez utiliser un Proxy résidentiel à rotation automatique.

Si vous recherchez des Proxys fiables, n’oubliez pas que le réseau de Proxys de Bright Data bénéficie de la confiance des entreprises du Fortune 500 et de plus de 20 000 clients dans le monde entier. Ce vaste réseau comprend :

• Proxys résidentiels: plus de 72 millions d’IPs résidentielles dans plus de 195 pays.
• Proxy de centre de données: plus de 770 000 adresses IP de centre de données.
• Proxy ISP: plus de 700 000 adresses IP ISP.
• Proxy mobile: plus de 7 millions d’adresses IP mobiles.

Conclusion

Dans cet article de blog comparant Scrapy et Requests, vous avez découvert le rôle de ces deux bibliothèques dans le Scraping web. Vous avez exploré leurs fonctionnalités pour la récupération de pages et l’extraction de données, et comparé leurs performances dans un scénario de pagination réel.

Requests nécessite davantage de logique manuelle, mais offre une plus grande flexibilité pour les cas d’utilisation personnalisés, tandis que Scrapy est légèrement moins adaptable, mais fournit la plupart des outils nécessaires au scraping structuré.

Vous avez également découvert leurs limites, telles que les interdictions potentielles d’IP et les problèmes liés au contenu géo-restreint. Heureusement, ces défis peuvent être surmontésà l’aide de proxysoudesolutions de Scraping web dédiées telles queles Web Scrapers de Bright Data.

Les Scrapers s’intègrent parfaitement à Scrapy et Requests, vous permettant d’extraire des données publiques des principaux sites web sans aucune restriction.

Créez dès aujourd’hui un compte Bright Data gratuit pour découvrir nos API Proxy et Scraper et commencer votre essai gratuit !