Questions fréquentes sur le web scraping - Réponses et conseils

Vous avez écrit un script pour récupérer du code HTML depuis un site web, mais vous n'obtenez pas toutes les données. Vous avez testé vos sélecteurs dans le navigateur et ils devraient fonctionner, n'est-ce pas ? Pas toujours. Les sites web qui s'appuient sur JavaScript pour s'afficher ne fonctionneront pas avec une simple requête GET. Il existe des bibliothèques telles que Puppeteer et Selenium qui utilisent des navigateurs sans interface graphique pour exécuter le JavaScript. Elles vous permettent d'effectuer la requête dans le contexte d'un navigateur et d'attendre que l'exécution du JavaScript soit terminée. De cette façon, vous pouvez récupérer l'intégralité du code HTML. Vous n'aurez pas toujours besoin d'un navigateur sans interface graphique pour récupérer les données manquantes. Recherchez les balises <script> dans le code HTML. Les données manquantes pourraient être cachées à l'intérieur de ces balises sous forme de variables JavaScript.

Certains sites web utilisent des bibliothèques qui créent automatiquement des noms de classes uniques pour différents composants de la page. Cela peut rendre difficile l'utilisation de sélecteurs CSS traditionnels pour cibler des éléments spécifiques.

Une solution consiste à utiliser des expressions XPath à la place. Les sélecteurs XPath s'appuient sur la mise en page de la page, plutôt que sur des noms de classes spécifiques. Cela signifie que même si les noms de classes changent, le sélecteur XPath sera toujours capable de localiser l'élément souhaité.

Par exemple, si vous avez un composant HTML qui ressemble à ceci :

<div class="container">

    <div class="subcontainer_af21">

        <ul class="ul_ax1">

            <li class="li_adef">

                <a href="https://link1">Winter Storm</a>

            </li>

        </ul>

        <ul class="ul_cgt4">

            <li class="li_ocv2">

                <a href="https://lin2">SpaceX</a>

            </li>

        </ul>

    </div>

</div>

Vous pouvez sélectionner le deuxième élément <a> avec :

//div[@class='container']/div/ul[2]/li/a

Oui, Cheerio est généralement considéré comme plus rapide que Puppeteer. En effet, Cheerio est une bibliothèque côté serveur qui travaille directement avec le contenu HTML. Puppeteer est une bibliothèque d'automatisation de navigateur qui contrôle un navigateur sans interface graphique pour charger des pages web et interagir avec elles. Cheerio est limité dans le sens où il ne peut fonctionner qu'avec des pages statiques ; il n'a pas la capacité d'interagir avec le navigateur comme le fait Puppeteer

Cela dépend du contexte. Si vous cherchez à extraire des données en fonction de la position des éléments, XPath est le meilleur choix. En revanche, si vous cherchez à extraire des données en fonction de propriétés telles que la classe ou l'identifiant, les sélecteurs CSS constituent une meilleure option.

Les deux offrent des fonctionnalités similaires, mais Playwright prend en charge plusieurs navigateurs, notamment Chrome, Firefox et Safari. Puppeteer ne prend en charge que Chrome et Chromium.

Playwright offre une meilleure prise en charge pour travailler avec plusieurs onglets et fenêtres. Il intègre également une prise en charge native de la gestion des contextes de navigateur, des cookies et du stockage. Playwright est mieux adapté aux projets complexes.

En général, vous pouvez essayer d'espacer vos requêtes. Utilisez différentes adresses IP. Utilisez des proxys. Essayez de modifier l'empreinte du navigateur. Pour la plupart des gens, c'est une bataille sans fin. La bonne nouvelle, c'est que cela ne doit pas nécessairement être le cas. Vous pouvez utiliser notre solution, WebScrapingAPI. WebScrapingAPI fournit une API qui se chargera de tout le travail fastidieux à votre place. Elle peut exécuter du JavaScript, faire tourner les proxys et même gérer les CAPTCHA. Vous n'aurez plus jamais à vous soucier d'un blocage de votre adresse IP. Mais ne nous croyez pas sur parole. Vous pouvez l'essayer gratuitement.

Vous pouvez utiliser la bibliothèque BeautifulSoup. Voici un exemple d'extraction de texte à l'aide de la fonction .get_text() :

from bs4 import BeautifulSoup

html_doc = """

<html>

 <head>

   <title>title of the page</title>

 </head>

 <body>

   <p>a paragraph</p>

   <a href='https://link.com'>a link</a>

 </body>

</html>

"""

soup = BeautifulSoup(html_doc, 'html.parser')

paragraph_text = soup.find('p').text

print(paragraph_text)

#Prints 'a paragraph'

link_text = soup.find('a').text

print(link_text)

#Prints 'a link'

all_text = soup.get_text()

print(all_text)

"""

title of the page

a paragraph

a link

"""

Voici comment procéder dans Selenium :

from selenium import webdriver

from selenium.webdriver.common.by import By

DRIVER_PATH = 'path/to/chromedriver'

driver = webdriver.Chrome(executable_path=DRIVER_PATH)

driver.get("https://en.wikipedia.org/wiki/Main_Page")

# get all the h2 elements

content = driver.find_element(By.TAG_NAME, "h2")

print(content.text)

# Prints 'From today's featured article'

Avec BeautifulSoup, vous pouvez utiliser la méthode soup.find avec le paramètre text=re.compile("<text>") :

from bs4 import BeautifulSoup

import re

html_doc = """

<html>

<body>

  <p class="my_paragraph">a paragraph.</p>

  <p class="my_paragraph">another paragraph.</p>

</body>

</html>

"""

soup = BeautifulSoup(html_doc, 'html.parser')

# find the first pTag that contains the text 'a par'

pTag = soup.find("p", text=re.compile("a par"))

print(pTag)

Dans Selenium, vous pouvez le faire avec XPath :

from selenium import webdriver

from selenium.webdriver.common.by import By

DRIVER_PATH = 'path/to/chromedriver'

driver = webdriver.Chrome(executable_path=DRIVER_PATH)

driver.get("https://en.wikipedia.org/wiki/Main_Page")

# get all the elements with class vector-body

span = driver.find_element(By.XPATH, "//span[contains(text(), 'Did')]")

print(span.text)

# Prints 'Did you know ...'

driver.quit()

Voici comment procéder avec BeautifulSoup et les méthodes find et find_all :

from bs4 import BeautifulSoup

html_doc = """

<html>

  <body>

    <p class="my_paragraph">First paragraph.</p>

    <p class="my_paragraph">Second paragraph..</p>

    <p>Last paragraph.</p>

  </body>

</html>

"""

soup = BeautifulSoup(html_doc, 'html.parser')

# find all elements with class 'my_paragraph

elements = soup.find_all(class_="my_paragraph")

for element in elements:

    print(element.text)

# prints 'First paragraph.' and 'Second paragraph..'

Voici comment procéder avec Selenium :

from selenium import webdriver

from selenium.webdriver.common.by import By

DRIVER_PATH = 'path/to/chromedriver'

driver = webdriver.Chrome(executable_path=DRIVER_PATH)

driver.get("https://en.wikipedia.org/wiki/Main_Page")

# get all the elements with class vector-body

elements = driver.find_elements(By.CLASS_NAME, "vector-body")

for element in elements:

   print(element.text)

driver.quit()

Vous aurez besoin de la bibliothèque Python lxml :

import requests

from bs4 import BeautifulSoup

from lxml import etree

response = requests.get("https://en.wikipedia.org/wiki/Main_Page")

soup = BeautifulSoup(response.content, 'html.parser')

dom = etree.HTML(str(body))

xpath_str = '//h1//text()'

print(dom.xpath(xpath_str))

#Prints ['Main Page', 'Welcome to ', 'Wikipedia']

Si vous souhaitez simplement attendre un certain temps avant d'expirer lorsque vous essayez de trouver un élément, vous pouvez utiliser la fonction driver.implicitly_wait(time_in_seconds) :

from selenium import webdriver

from selenium.webdriver.common.by import By

DRIVER_PATH = 'C:/Users/Michael/Desktop/chromedriver'

driver = webdriver.Chrome(executable_path=DRIVER_PATH)

driver.implicitly_wait(10)

driver.get("https://en.wikipedia.org/wiki/Main_Page")

element = driver.find_element(By.ID, "not_found_id")

# the element does not exist, but it waits 10 seconds for it

text = element.text

print(text)

# Close the browser

driver.quit()

Vous pouvez également choisir d'attendre qu'une certaine condition soit remplie :

from selenium import webdriver

from selenium.webdriver.common.by import By

from selenium.webdriver.support.ui import WebDriverWait

from selenium.webdriver.support import expected_conditions as EC

DRIVER_PATH = 'C:/Users/Michael/Desktop/chromedriver'

driver = webdriver.Chrome(executable_path=DRIVER_PATH)

driver.get("https://en.wikipedia.org/wiki/Main_Page")

# Wait for the element with id 'content' to be present on the page

wait = WebDriverWait(driver, 10)

element = wait.until(EC.presence_of_element_located((By.ID, "content")))

element = driver.find_element(By.ID, "content")

text = element.text

print(text)

# Close the browser

driver.quit()

Dans Puppeteer, vous pouvez utiliser les fonctions page.$() et page.$$() pour sélectionner des éléments à l'aide de sélecteurs CSS. La fonction page.$() sert à trouver le premier élément correspondant au sélecteur. La fonction page.$$() sert à trouver tous les éléments correspondant au sélecteur.

const puppeteer = require('puppeteer');

(async () => {

  const browser = await puppeteer.launch({

    headless: false,

  });

 

  const page = await browser.newPage();

  await page.goto('https://www.scrapethissite.com/pages/simple/');

  // Extract the first odd row element 

  const firstOddRow = await page.$('.container .row');

  console.log(await firstOddRow.evaluate(node => node.textContent));

  // Extract all the odd rows

  const allOddRows = await page.$$('.container .row');

  for (const oddRow of allOddRows) {

    console.log(await oddRow.evaluate(node => node.textContent));

  }

  await browser.close();

})();

Voici comment procéder avec Playwright. La méthode est très similaire à celle de Puppeteer :

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

(async () => {

  const browser = await chromium.launch({

    headless: false,

  });

  const context = await browser.newContext();

  const page = await context.newPage();

  await page.goto('https://www.scrapethissite.com/pages/simple/');

  // Extract the first odd row element

  const firstOddRow = await page.$('.container .row');

  console.log(await firstOddRow.textContent());

  // Extract all the odd rows

  const allOddRows = await page.$$('.container .row');

  for (const oddRow of allOddRows ) {

    console.log(await oddRow.textContent());

  }

  await browser.close();

})();

Avec cheerio, vous devrez récupérer le code HTML (j'ai utilisé la bibliothèque request pour cela), puis le transmettre à la bibliothèque cheerio :

const request = require('request');

const cheerio = require('cheerio');

const url = 'https://www.scrapethissite.com/pages/simple/';

request(url, (error, response, html) => {

  if (!error && response.statusCode === 200) {

    const $ = cheerio.load(html);

    const firstOddRow = $('.container .row').first();

    console.log(firstOddRow.text());

    const allOddRows = $('.container .row');

    allOddRows.each((i, oddRow) => {

      console.log($(oddRow).text());

    });

  }

});

Avec Puppeteer, vous pouvez utiliser la fonction page.$x() pour sélectionner des éléments à l'aide de sélecteurs XPath :

const puppeteer = require('puppeteer');

(async () => {

  const browser = await puppeteer.launch();

  const page = await browser.newPage();

  await page.goto('https://www.scrapethissite.com/pages/forms/');

  // Extract the table header elements

  const allTableHeaders = await page.$x('//table/tbody/tr[1]//th');

  for(let i = 0; i < allTableHeaders.length; i++) {

    const header = await page.evaluate(el => el.textContent, allTableHeaders[i]);

    console.log(header.trim());

  }

  await browser.close();

})();

// Output:

// Team Name

// Year

// Wins

// Losses

// OT Losses

// Win %

// Goals For (GF)

// Goals Against (GA)

// + / -

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

(async () => {

  const browser = await chromium.launch({

    headless: false,

  });

  const context = await browser.newContext();

  const page = await context.newPage();

  await page.goto('https://www.scrapethissite.com/pages/forms/');

  // Extract the table header elements

  const allTableHeaders = await page.locator('xpath=//table/tbody/tr[1]//th').all();

 

  for (let i = 0; i < allTableHeaders.length; i++) {

    const headerText = await allTableHeaders[i].innerText();

    console.log(headerText);

  }

  await browser.close();

})();

Toute chaîne de sélection commençant par // ou .. est considérée comme un sélecteur XPath. Par exemple, Playwright convertit « //html/body » en « xpath=//html/body ».

Dans Puppeteer, la manière la plus simple de rechercher des éléments par texte consiste à utiliser la fonction XPath text() :

const puppeteer = require('puppeteer');

(async () => {

  const browser = await puppeteer.launch({

    headless: false,

  });

  const page = await browser.newPage();

  await page.goto('https://en.wikipedia.org/wiki/Web_scraping');

   // Select all the p tags texts that contain the word "prevent" 

   const pTags = await page.$x('//p[contains(text(), "prevent")]/text()');

   for(let i = 0; i < pTags.length; i++) {

     const pTag = await page.evaluate(el => el.textContent, pTags[i]);

     console.log(pTag,"\n");

   }

  await browser.close();

})();

//Output:

There are methods that some websites use to prevent web scraping, such as detecting and disallowing bots from crawling (viewing) their pages. In response, there are web scraping systems that rely on using techniques in ...     

Si vous souhaitez rechercher des éléments par texte dans Playwright, vous pouvez utiliser la fonction allInnerTexts() en combinaison avec XPath.

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

(async () => {

  const browser = await chromium.launch({

    headless: false,

  });

  const context = await browser.newContext();

  const page = await context.newPage();

  await page.goto('https://en.wikipedia.org/wiki/Web_scraping');

  // Select all the p tags texts that contain the word "prevent" 

  const pTags  = await page.locator('//p[contains(text(), "prevent")]').allInnerTexts();

 

  for (let i = 0; i < pTags.length; i++) {

    console.log(pTags[i], "\n");

  }

  await browser.close();

})();

const request = require('request');

const cheerio = require('cheerio');

const url = 'https://en.wikipedia.org/wiki/Web_scraping';

request(url, (error, response, html) => {

  if (!error && response.statusCode === 200) {

    const $ = cheerio.load(html);

  // Select all the p tags texts that contain the word "prevent" 

    const elements = $('p').filter((i, el) => $(el).text().includes('prevent'));

    elements.each((i, el) => {

        console.log($(el).text());

    });

  }

});

Dans Puppeteer, vous pouvez utiliser la fonction page.waitForSelector() pour attendre qu'un élément spécifique apparaisse sur la page avant de poursuivre l'exécution du script. Vous pouvez l'utiliser avec les sélecteurs CSS et XPath :

await page.waitForSelector('.basic-element', { timeout: 10000 });

await page.waitForXPath("//div[@class='basic-element']"), { timeout: 10000 });

Le paramètre timeout spécifie le temps d'attente maximal en millisecondes.

Vous pouvez également attendre qu'un élément atteigne un certain état :

await page.waitForSelector('.basic-element', { visible: true });

// wait until the element becomes visible

Playwright est similaire à Puppeteer. Vous pouvez utiliser la méthode page.waitForSelector() pour attendre qu'un élément spécifique apparaisse sur la page.

await page.waitForSelector('.element-class', { timeout: 10000 });

Vous pouvez également attendre qu'un élément atteigne un certain état :

 await page.waitForSelector('.basic-element', { state: 'visible' });

 // wait for element to become visible

Le web scraping est un vaste sujet et cet article n'en aborde que les grandes lignes. Il est essentiel de choisir l'outil adapté à votre cas d'utilisation spécifique. Par exemple, si vous souhaitez extraire des données d'un site web à l'aide de JavaScript, la bibliothèque cheerio est une bonne option. Cependant, si le site web nécessite JavaScript pour se charger entièrement, Puppeteer ou Playwright constituent de meilleures options. Le web scraping est un défi, mais la maîtrise des outils peut vous éviter bien des maux de tête. J'espère que cet article vous a ouvert de nouvelles perspectives et je vous souhaite bonne chance dans vos projets de web scraping.