Scrapy vs Playwright : Une comparaison pour le Web Scraping

Dans ce guide, vous apprendrez :

• Qu’est-ce que Scrapy ?
• Quel dramaturge est
• Les fonctionnalités qu’ils offrent pour le web scraping et leur comparaison
• Une introduction au web scraping avec les deux outils
• Comment construire un scraper avec Playwright
• Comment construire un script de web scraping avec Scrapy
• Quel est le meilleur outil pour le web scraping ?
• Leurs limites communes et la manière de les surmonter

Plongeons dans l’aventure !

Qu’est-ce que Scrapy ?

Scrapy est un framework de scraping web open-source écrit en Python, développé pour l’extraction efficace de données. Il offre un support intégré pour des capacités telles que les requêtes parallèles, le suivi de liens et l’exportation de données dans des formats tels que JSON et CSV. Il propose également un intergiciel, l’intégration d’un proxy et des tentatives de relance automatiques. Scrapy fonctionne de manière asynchrone et sur des pages HTML statiques.

Qu’est-ce que le dramaturge ?

Playwright est un cadre d’automatisation open-source pour les tests E2E et le web scraping dans le navigateur. Il prend en charge de nombreux navigateurs, tels que Chrome, Firefox et WebKit, chacun en mode avec ou sans en-tête. De plus, l’API d’automatisation du navigateur est disponible dans plusieurs langages de programmation, notamment TypeScript/JavaScript, Python, Java et C#.

Scrapy vs. Playwright : les fonctionnalités du Web Scraping en tête à tête

Comparons Scrapy et Playwright sur cinq aspects différents qui contribuent à en faire d’excellents outils de scraping web.

Pour d’autres articles de blog en tête-à-tête, lisez :

• Scrapy vs. Beautiful Soup
• Scrapy vs Pyspider : Lequel est le meilleur pour le Web Scraping ?
• Scrapy vs. Selenium pour le Web Scraping
• Scrapy vs. Puppeteer pour le Web Scraping
• Scrapy vs. Requests : Lequel est le meilleur pour le Web Scraping ?

Commençons maintenant la comparaison entre Scrapy et Playwright !

Facilité d’installation et de configuration

Scrapy offre une installation simple avec une configuration minimale. Vous pouvez rapidement créer un projet, définir des spiders et exporter des données, grâce à son CLI intégré. À l’inverse, Playwright nécessite davantage de configuration, car il faut installer les dépendances du navigateur et vérifier que la configuration est correcte.

Courbe d’apprentissage

Scrapy a une courbe d’apprentissage plus raide pour les débutants en raison de sa structure modulaire, de ses fonctionnalités étendues et de ses configurations uniques. La compréhension de concepts tels que les spiders, les middlewares et les pipelines peut prendre du temps. Playwright est beaucoup plus facile à utiliser, car son API est familière à ceux qui ont une certaine connaissance de l’automatisation des navigateurs.

Traitement du contenu dynamique

Scrapy a des difficultés avec les sites web qui utilisent JavaScript, car il ne peut traiter que des documents HTML statiques. La gestion du contenu dynamique est possible, mais nécessite une intégration avec Splash ou des outils similaires. Playwright excelle dans le traitement des contenus dynamiques ou rendus par JavaScript, car il rend nativement les pages dans le navigateur. Cela signifie que vous pouvez l’utiliser pour récupérer des pages qui s’appuient sur des cadres clients tels que React, Angular ou Vue.

Personnalisation et extensibilité

Scrapy offre de nombreuses options de personnalisation grâce à la prise en charge de middlewares, d’extensions et de pipelines. De plus, plusieurs plugins et add-ons sont disponibles. Playwright, en revanche, n’est pas extensible de manière native. Heureusement, la communauté a remédié à cette limitation avec le projet Playwright Extra.

Autres fonctionnalités de scraping

Scrapy vous offre des fonctionnalités intégrées telles que l’intégration de proxy, les tentatives automatiques et l’exportation de données configurables. Il propose également des méthodes intégrées pour la rotation des adresses IP et d’autres scénarios avancés. Playwright ne prend pas en charge l’intégration de proxy et d’autres fonctionnalités clés de scraping. Par conséquent, pour obtenir les mêmes résultats, il faut plus d’efforts manuels que pour Scrapy.

Playwright vs Scrapy : Comparaison des scripts d’extraction

Dans les deux sections suivantes, vous apprendrez à récupérer le même site en utilisant Playwright et Scrapy. Nous commencerons par Playwright, qui peut prendre un peu plus de temps car il n’est pas spécifiquement optimisé pour le web scraping comme Scrapy.

Le site cible sera le bac à sable de scraping Books to Scrape:

L’objectif des deux scrapers est de récupérer tous les livres Fantasy du site, ce qui nécessite de gérer la pagination.

Scrapy traitera les pages comme statiques et analysera directement leurs documents HTML. Au lieu de cela, Playwright les rendra dans un navigateur et interagira avec les éléments des pages, simulant ainsi les actions de l’utilisateur.

Le script Scrapy sera écrit en Python, tandis que le script Playwright sera en JavaScript – les deux langages principalement pris en charge par les deux outils. Néanmoins, vous pouvez facilement convertir le script JavaScript de Playwright en Python en utilisant la bibliothèque playwright-python, qui expose la même API sous-jacente.

Dans les deux cas, à la fin du script, vous obtiendrez un fichier CSV contenant tous les détails des livres Fantasy provenant de Books to Scrape.

Passons maintenant à la comparaison entre Playwright et Scrapy en matière de scraping !

Comment utiliser Playwright pour l’exploration du Web

Suivez les étapes ci-dessous pour écrire un script simple d’exploration du Web en JavaScript à l’aide de Playwright. Si vous n’êtes pas familier avec le processus, lisez d’abord notre guide sur le web scraping avec Playwright.

Étape 1 : Configuration du projet

Avant de commencer, assurez-vous que la dernière version de Node.js est installée localement. Si ce n’est pas le cas, téléchargez-la et suivez l’assistant d’installation.

Ensuite, créez un dossier pour votre scraper Playwright et accédez-y à l’aide du terminal :

mkdir playwright-scraper
cd playwright-scraper

Dans le dossier playwright-scraper, initialiser un projet npm en exécutant :

npm init -y

Maintenant, ouvrez le dossier playwright-scraper dans votre IDE JavaScript préféré. IntelliJ IDEA ou Visual Studio Code sont d’excellentes options. Dans le dossier, créez un fichier script.js, qui contiendra bientôt la logique de scraping :

C’est génial ! Vous êtes maintenant prêt à faire du scraping web dans Node.js avec Playwright.

Étape 2 : Installation et configuration de Playwright

Dans le dossier du projet, exécutez la commande suivante pour installer Playwright :

npm install playwright

Ensuite, installez le navigateur et toutes les dépendances supplémentaires en exécutant :

npx playwright install

Maintenant, ouvrez script.js et ajoutez le code suivant pour importer Playwright et lancer une instance de navigateur Chromium :

const { chromium } = require("playwright");

(async () => {
  // initialize a Chromium browser
  const browser = await chromium.launch({
    headless: false, // comment out in production
  });

  // scraping logic goes here...

  // close the browser and release resources
  await browser.close();
})();

L’option headless : false lance le navigateur en mode head. Cela vous permet de voir ce que fait le script, ce qui est utile pour le débogage pendant le développement.

Étape 3 : Connexion à la page cible

Initialiser une nouvelle page dans le navigateur et utiliser la fonction goto() pour naviguer vers la page cible :

const page = await browser.newPage();
await page.goto("https://books.toscrape.com/catalogue/category/books/fantasy_19/index.html");

Si vous exécutez le script dans le débogueur avec un point d’arrêt avant la fonction close(), vous verrez le navigateur s’ouvrir et naviguer vers la page cible :

C’est incroyable ! Playwright contrôle le navigateur comme prévu.

Étape 4 : Mise en œuvre de la logique d’analyse des données

Avant d’écrire la logique de scraping, vous devez comprendre la structure de la page. Pour ce faire, ouvrez le site cible dans une fenêtre incognito de votre navigateur. Ensuite, cliquez avec le bouton droit de la souris sur un élément du livre et sélectionnez l’option “Inspecter”.

C’est ce que vous devriez voir dans les DevTools :

Ci-dessus, vous pouvez constater que chaque élément de livre peut être sélectionné à l’aide du sélecteur CSS .product_pod.

Comme la page contient plusieurs livres, il faut d’abord initialiser un tableau pour stocker les données extraites :

books = []

Sélectionnez-les tous et itérez sur eux comme ci-dessous :

const bookElements = await page.locator(".product_pod").all();
for (const bookElement of bookElements) {
  // extract book details...
}

De chaque élément du livre, comme le montre l’image ci-dessus, vous pouvez extraire :

• L’URL du livre à partir de la balise <a>
• Le titre du livre dans le nœud h3 a
• L’image du livre de l’élément .thumbnail
• L’évaluation du livre à partir de l’élément .star-rating
• Le prix du produit de l’élément .product_price .price_color
• La disponibilité du produit à partir de l’élément .availability

Maintenant, mettez en œuvre la logique d’extraction dans la boucle :

const urlElement = await bookElement.locator("a").first();
const url = makeAbsoluteURL(
  await urlElement.getAttribute("href"),
  "https://books.toscrape.com/catalogue/"
);

const titleElement = await bookElement.locator("h3 a");
const title = await titleElement.getAttribute("title");

const imageElement = await bookElement.locator(".thumbnail");
const image = makeAbsoluteURL(
  await imageElement.getAttribute("src"),
  "https://books.toscrape.com/"
);

const ratingElement = await bookElement.locator(".star-rating");
const ratingClass = await ratingElement.getAttribute("class");
let rating;
switch (true) {
  case ratingClass.includes("One"):
    rating = 1;
    break;
  case ratingClass.includes("Two"):
    rating = 2;
    break;
  case ratingClass.includes("Three"):
    rating = 3;
    break;
  case ratingClass.includes("Four"):
    rating = 4;
    break;
  case ratingClass.includes("Five"):
    rating = 5;
    break;
  default:
    rating = null;
}

const priceElement = await bookElement.locator(
  ".product_price .price_color"
);
const price = (await priceElement.textContent()).trim();

const availabilityElement = await bookElement.locator(".availability");
const availability = (await availabilityElement.textContent()).trim();

L’extrait ci-dessus utilise les fonctions Playwright getAttribute() et textContent() pour extraire des attributs HTML spécifiques et du texte à partir de nœuds HTML, respectivement. Notez la logique personnalisée pour récupérer le score d’évaluation.

En outre, comme les URL de la page sont relatives, elles peuvent être converties en URL absolues à l’aide de la fonction personnalisée suivante :

function makeAbsoluteURL(url, baseURL) {
  // use a regular expression to remove any ../ or ../../ patterns
  const cleanURL = url.replace(/(\.\.\/)+/, "");

  // combine the base URL with the cleaned relative URL
  return baseURL + cleanURL;
}

Ensuite, remplissez un nouvel objet avec les données extraites et ajoutez-le au tableau des livres :

const book = {
  "url": url,
  "title": title,
  "image": image,
  "rating": rating,
  "price": price,
  "availability": availability,
};
books.push(book);

Parfait ! La logique de raclage de Playwright est maintenant terminée.

Étape 4 : Mise en œuvre de la logique d’exploration

Si vous jetez un coup d’œil sur le site cible, vous remarquerez que certaines pages ont un bouton “suivant” en bas :

En cliquant dessus, la page suivante est chargée. Notez que la dernière page de pagination ne l’inclut pas pour des raisons évidentes.

Ainsi, vous pouvez mettre en œuvre la logique d’exploration du web avec une boucle while (true) qui :

1. Récupère les données de la page actuelle
2. Cliquez sur le bouton “suivant” s’il est présent et attendez le chargement de la nouvelle page.
3. Répéter le processus jusqu’à ce que le bouton “suivant” ne soit plus trouvé.

Voici comment vous pouvez y parvenir :

while (true) {
  // select the book elements ...

  // select the "next" button and check if it is on the page
  const nextElement = await page.locator("li.next a");
  if ((await nextElement.count()) !== 0) {
    // click the "next" button and go to the next page
    await nextElement.click();
    // wait for the page to have been loaded
    await page.waitForLoadState("domcontentloaded")
  } else {
    break;
  }
}

Formidable ! La logique du crawling est mise en œuvre.

Étape 5 : Exporter au format CSV

La dernière étape consiste à exporter les données scannées vers un fichier CSV. Bien que vous puissiez y parvenir en utilisant Node.js, il est beaucoup plus facile d’utiliser une bibliothèque dédiée comme fast-csv.

Installez le paquetage fast-csv en exécutant la commande suivante :

npm install fast-csv

Au début de votre fichier scraping.js, importez les modules nécessaires :

const { writeToPath } = require("fast-csv");

Ensuite, utilisez l’extrait suivant pour écrire les données extraites dans un fichier CSV :

writeToPath("books.csv", books, { headers: true });

Et voilà ! Le script de scraping web Playwright est prêt.

Étape n° 6 : Assembler le tout

Votre fichier script.js doit contenir

const { chromium } = require("playwright");
const { writeToPath } = require("fast-csv");

(async () => {
  // initialize a Chromium browser
  const browser = await chromium.launch({
    headless: false, // comment out in production
  });

  // initialize a new page in the browser
  const page = await browser.newPage();

  // visit the target page
  await page.goto(
    "https://books.toscrape.com/catalogue/category/books/fantasy_19/index.html"
  );

  // where to store the scraped data
  books = [];

  while (true) {
    // select the book elements
    const bookElements = await page.locator(".product_pod").all();
    // iterate over them to extract data from them
    for (const bookElement of bookElements) {
      // data extraction logic
      const urlElement = await bookElement.locator("a").first();
      const url = makeAbsoluteURL(
        await urlElement.getAttribute("href"),
        "https://books.toscrape.com/catalogue/"
      );

      const titleElement = await bookElement.locator("h3 a");
      const title = await titleElement.getAttribute("title");

      const imageElement = await bookElement.locator(".thumbnail");
      const image = makeAbsoluteURL(
        await imageElement.getAttribute("src"),
        "https://books.toscrape.com/"
      );

      const ratingElement = await bookElement.locator(".star-rating");
      const ratingClass = await ratingElement.getAttribute("class");
      let rating;
      switch (true) {
        case ratingClass.includes("One"):
          rating = 1;
          break;
        case ratingClass.includes("Two"):
          rating = 2;
          break;
        case ratingClass.includes("Three"):
          rating = 3;
          break;
        case ratingClass.includes("Four"):
          rating = 4;
          break;
        case ratingClass.includes("Five"):
          rating = 5;
          break;
        default:
          rating = null;
      }

      const priceElement = await bookElement.locator(
        ".product_price .price_color"
      );
      const price = (await priceElement.textContent()).trim();

      const availabilityElement = await bookElement.locator(".availability");
      const availability = (await availabilityElement.textContent()).trim();

      // populate a new book item with the scraped data and
      // then add it to the array
      const book = {
        "url": url,
        "title": title,
        "image": image,
        "rating": rating,
        "price": price,
        "availability": availability,
      };
      books.push(book);
    }

    // select the "next" button and check if it is on the page
    const nextElement = await page.locator("li.next a");
    if ((await nextElement.count()) !== 0) {
      // click the "next" button and go to the next page
      await nextElement.click();
      // wait for the page to have been loaded
      await page.waitForLoadState("domcontentloaded");
    } else {
      break;
    }
  }

  // export the scraped data to CSV
  writeToPath("books.csv", books, { headers: true });

  // close the browser and release resources
  await browser.close();
})();

function makeAbsoluteURL(url, baseURL) {
  // use a regular expression to remove any ../ or ../../ patterns
  const cleanURL = url.replace(/(\.\.\/)+/, "");

  // combine the base URL with the cleaned relative URL
  return baseURL + cleanURL;
}

Lancez-la avec cette commande Node.js :

node script.js

Le résultat sera le fichier books.csv suivant :

Mission accomplie ! Maintenant, il est temps de voir comment obtenir le même résultat avec Scrapy.

Comment utiliser Scrapy pour le Web Scraping ?

Suivez les étapes ci-dessous et voyez comment construire un simple scraper web avec Scrapy. Pour plus d’informations, consultez notre tutoriel sur le scraping web avec Scrapy.

Étape 1 : Configuration du projet

Avant de commencer, vérifiez que Python 3 est installé localement. Si ce n’est pas le cas, téléchargez-le depuis le site officiel et installez-le.

Créez un dossier pour votre projet et initialisez un environnement virtuel à l’intérieur de celui-ci :

mkdir scrapy-scraper
cd scrapy-scraper
python -m venv venv

Sous Windows, exécutez la commande suivante pour activer l’environnement :

venv\Scripts\activate

De manière équivalente, sous Unix ou macOS, exécutez :

source venv/bin/activate

Dans un environnement activé, installez Scrapy avec :

pip install scrapy

Ensuite, lancez la commande ci-dessous pour créer un projet Scrapy appelé “books_scraper” :

scrapy startproject books_scraper

C’est bien ! Vous êtes prêt pour le web scraping avec Scrapy.

Étape 2 : Créer l’araignée Scrapy

Entrez dans le dossier du projet Scrapy et générez un nouveau spider pour le site cible :

cd books_scraper
scrapy genspider books books.toscrape.com

Scrapy créera automatiquement tous les fichiers nécessaires pour vous. Plus précisément, le répertoire books_scraper devrait maintenant contenir la structure de fichiers suivante :

books_scraper/
   │── __init__.py
   │── items.py
   │── middlewares.py
   │── pipelines.py
   │── settings.py
   └── spiders/
       │── __init__.py
       └── books.py

Pour mettre en œuvre la logique de scraping souhaitée, remplacez le contenu de books_scraper/spiders/books.py par le code suivant :

import scrapy

class BooksSpider(scrapy.Spider):
    name = "books"
    allowed_domains = ["books.toscrape.com"]
    start_urls = ["https://books.toscrape.com/catalogue/page-1.html"]

    def parse(self, response):
        # Extract book details
        for book in response.css(".product_pod"):
            yield {
                "title": book.css("h3 a::attr(title)").get(),
                "url": response.urljoin(book.css("h3 a::attr(href)").get()),
                "image": response.urljoin(book.css(".thumbnail::attr(src)").get()),
                "rating": book.css(".star-rating::attr(class)").get().split()[-1],
                "price": book.css(".product_price .price_color::text").get(),
                "availability": book.css(".availability::text").get().strip(),
            }

        # Handle pagination
        next_page = response.css("li.next a::attr(href)").get()
        if next_page:
            yield response.follow(next_page, callback=self.parse)

Étape 3 : Lancer l’araignée

Dans le dossier books_scraper, dans un environnement virtuel activé, lancez la commande suivante pour exécuter votre spider Scrapy et exporter les données scrappées vers un fichier CSV :

scrapy crawl books -o books.csv

Cela générera un fichier books.csv contenant les données extraites, tout comme celui produit par le script Playwright. Encore une fois, la mission est terminée !

Scrapy vs Playwright : Lequel utiliser ?

Le script de scraping de Playwright a nécessité six longues étapes, alors que Scrapy n’en a nécessité que trois. Cela n’est pas surprenant puisque Scrapy est conçu pour le scraping web, alors que Playwright est un outil général d’automatisation du navigateur utilisé à la fois pour les tests et le scraping.

En particulier, la principale différence réside dans la logique d’exploration du web. Playwright nécessitait des interactions manuelles et une logique personnalisée pour la pagination, alors que Scrapy peut la gérer avec seulement quelques lignes de code.

En bref, choisissez Scrapy plutôt que Playwright dans l’un de ces scénarios :

1. Vous avez besoin d’une extraction de données à grande échelle avec une prise en charge intégrée de l’exploration.
2. La performance et la rapidité sont des priorités, car Scrapy est optimisé pour des requêtes rapides et parallèles.
3. Vous préférez un cadre qui gère pour vous la pagination, les tentatives, l’extraction de données dans de nombreux formats et le scraping parallèle.

Au contraire, préférez Playwright à Scrapy lorsque :

1. Vous devez extraire des données de sites web à forte composante JavaScript nécessitant un rendu du navigateur.
2. Des interactions dynamiques telles que le défilement infini sont nécessaires.
3. Vous souhaitez mieux contrôler les interactions avec l’utilisateur (par exemple, dans le cas de schémas de navigation complexes de type “web scraping”).

Pour terminer cette comparaison entre Scrapy et Playwright, reportez-vous au tableau récapitulatif ci-dessous :

Limites du dramaturge et du scrapeur

Scrapy et Playwright sont tous deux des outils puissants pour le scraping web, mais ils ont chacun certaines limites.

Scrapy, par exemple, a du mal à récupérer le contenu dynamique des sites qui utilisent JavaScript pour le rendu ou la récupération des données. Étant donné que de nombreux sites web modernes requièrent désormais JavaScript, Scrapy est plus vulnérable aux mesures anti-scraping courantes. Bien sûr, Playwright peut gérer les sites à forte composante JavaScript, mais il est confronté à des problèmes tels que les interdictions d’IP.

Lorsque vous effectuez de nombreuses demandes, vous risquez de déclencher des limiteurs de débit, ce qui peut entraîner des refus de demande, voire des interdictions d’IP. Pour atténuer ce risque, vous pouvez intégrer un serveur proxy afin d’assurer la rotation des IP.

Si vous avez besoin de serveurs proxy fiables, le réseau proxy de Bright Data a la confiance des entreprises Fortune 500 et de plus de 20 000 clients dans le monde entier. Leur réseau comprend :

• Proxies de centres de données: Plus de 770 000 adresses IP de centres de données.
• Proxies résidentiels: Plus de 72 millions d’adresses IP résidentielles dans plus de 195 pays.
• Proxies ISP: Plus de 700 000 IP de FAI.
• Proxies mobiles: Plus de 7 millions d’adresses IP mobiles.

Les CAPTCHA constituent un autre défi pour Playwright. Ils sont conçus pour bloquer les robots d’exploration fonctionnant dans les navigateurs. Pour y remédier, vous pouvez explorer les solutions permettant de contourner les CAPTCHA dans Playwright.

Conclusion

Dans cet article de blog Playwright vs Scrapy, vous avez appris les rôles des deux bibliothèques dans le web scraping. Vous avez exploré leurs fonctions d’extraction de données et comparé leurs performances dans un scénario de pagination réel.

Scrapy fournit tout ce dont vous avez besoin pour l’analyse des données et l’exploration des sites web, tandis que Playwright se concentre davantage sur la simulation des interactions avec les utilisateurs.

Vous avez également découvert leurs limites, telles que les interdictions d’IP et les CAPTCHA. Heureusement, ces défis peuvent être surmontés à l’aide de proxys ou de solutions anti-bots dédiées comme CAPTCHA Solver de Bright Data.

Créez un compte Bright Data gratuit dès aujourd’hui pour découvrir nos solutions de proxy et de scraping !