Questions courantes sur le Web Scraping - Réponses et conseils

Mihai Maxim le 03 mars 2023

Naviguer dans le monde du web scraping peut s'avérer un peu compliqué. Vous devez choisir le bon langage de programmation et la bonne bibliothèque, et faire face à de nombreux imprévus. C'est vite trop difficile à assimiler. Mais ne vous laissez pas décourager ! Dans cet article, j'ai répondu à quelques-unes des questions les plus fréquemment posées sur le web scraping. Vous apprendrez ce que font d'autres personnes et les difficultés qu'elles ont rencontrées. Cela vous aidera à prendre vos propres décisions. Que vous soyez novice en la matière ou un professionnel chevronné, chacun y trouvera son compte.

Pourquoi mon scraper ne peut-il pas voir les mêmes données que mon navigateur ?

You've written a script to fetch HTML from a website, but you're not getting the full data. You've tested your selectors in the browser and they should work, right? Not always. Websites that rely on JavaScript to render won't work with a simple GET request. There are libraries like Puppeteer and Selenium that use headless browsers to render JavaScript. They allow you to make the request in the context of a browser and wait for JavaScript to finish executing. This way, you can get the full HTML. You may not always need a headless browser to get the missing data. Search for <script> tags in the HTML. The missing data could be hidden inside <script> tags as JavaScript variables.

Comment puis-je récupérer un site web qui utilise des classes CSS générées ?

Certains sites web utilisent des bibliothèques qui créent automatiquement des noms de classe uniques pour les différents composants de la page. Cela peut rendre difficile l'utilisation des 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 présentation de la page, plutôt que sur des noms de classe spécifiques. Cela signifie que même si les noms de classe changent, le sélecteur XPath sera toujours en mesure 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>

You can select the second <a> element with:

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

Est-ce que cheerio est plus rapide que Puppeteer ?

Oui, Cheerio est généralement considéré comme plus rapide que Puppeteer. Cela s'explique par le fait que 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 tête pour charger des pages web et interagir avec elles. Cheerio est limité dans le sens où il ne peut travailler qu'avec des pages statiques, il n'a pas la capacité d'interagir avec le navigateur comme le fait Puppeteer.

Les sélecteurs XPath sont-ils meilleurs que les sélecteurs CSS ?

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

Playwright est-il meilleur que Puppeteer ?

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

Playwright offre une meilleure prise en charge de l'utilisation de plusieurs onglets et fenêtres. Il dispose également d'une prise en charge intégrée de la gestion des contextes de navigation, des cookies et du stockage. Playwright est mieux adapté aux projets complexes.

Comment éviter les bannissements d'adresses IP ?

En général, vous pouvez essayer d'espacer vos demandes. Utilisez des IP différentes. Utilisez des proxys. Essayer de modifier l'empreinte digitale du navigateur. Pour la plupart des gens, il s'agit d'une bataille sans fin. La bonne nouvelle, c'est qu'il n'est pas nécessaire d'en arriver là. Vous pouvez utiliser notre solution, WebScrapingAPI. WebScrapingAPI fournit une API qui se chargera de toutes les tâches lourdes à votre place. Elle peut exécuter du JavaScript, faire tourner des proxies et même gérer des CAPTCHA. Vous n'aurez plus jamais à craindre que votre IP soit bannie. Mais ne nous croyez pas sur parole. Vous pouvez l'essayer gratuitement.

Comment extraire du texte de HTML avec BeautifulSoup ?

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

"""

Comment extraire du texte à partir de HTML avec Selenium ?

Voici comment vous pouvez le faire 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")

# récupère tous les éléments h2

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

print(content.text)

# Imprime 'Extrait de l'article vedette d'aujourd'hui'

Comment sélectionner des éléments HTML par texte avec BeautifulSoup ?

With BeautifulSoup, you can use the soup.find method with the text=re.compile("<text>") parameter:

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)

Comment sélectionner des éléments HTML par texte avec Selenium ?

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")

# récupère tous les éléments avec la classe vector-body

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

print(span.text)

# imprime 'Did you know ...'

driver.quit()

Comment trouver des éléments HTML avec des sélecteurs CSS dans BeautifulSoup ?

Voici comment vous pouvez le faire 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..'

Comment trouver des éléments HTML par classe avec Selenium ?

Voici comment vous pouvez le faire 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")

# récupère tous les éléments avec la classe vector-body

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

for element in elements :

 print(element.text)

driver.quit()

Comment utiliser XPath avec BeautifulSoup ?

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))

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

Comment attendre que la page se charge dans Selenium ?

Si vous souhaitez simplement attendre un certain temps avant d'interrompre la recherche d'un élément, vous pouvez utiliser la fonction driver.implicitly_wait(time_in_secods) :

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")

# l'élément n'existe pas, mais il attend 10 secondes

text = element.text

print(text)

# Fermez le navigateur

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)

# Fermez le navigateur

driver.quit()

Comment trouver des éléments HTML avec des sélecteurs CSS dans Puppeteer ?

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.$() est utilisée pour trouver le premier élément qui correspond au sélecteur. La fonction page.$$() est utilisée pour trouver tous les éléments qui correspondent 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();

})();

Comment trouver des éléments HTML avec des sélecteurs CSS dans Playwright ?

Voici comment vous pouvez le faire avec Playwright. C'est très similaire à 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();

})();

Comment trouver des éléments HTML avec des sélecteurs CSS dans cheerio ?

Avec cheerio, vous devrez récupérer le code HTML (j'ai utilisé la bibliothèque request pour cela) et 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());

    });

  }

});

Comment utiliser XPath avec Puppeteer ?

Avec Puppeteer, vous pouvez utiliser la fonction page.$x() pour sélectionner des éléments avec des 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)

// + / -

Comment utiliser XPath avec Playwright ?

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".

Comment trouver des éléments HTML par texte dans Puppeteer ?

Dans Puppeteer, la manière la plus simple de trouver des éléments par le texte est d'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 ...     

Comment trouver des éléments HTML par texte dans Playwright ?

Si vous souhaitez trouver 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();

})();

Comment trouver des éléments HTML à partir d'un texte dans cheerio ?

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());

    });

  }

});

Comment attendre les sélecteurs dans Puppeteer ?

Dans Puppeteer, vous pouvez utiliser la fonction page.waitForSelector() pour attendre qu'un élément spécifique apparaisse sur la page avant de poursuivre le script. Vous pouvez l'utiliser avec des 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 maximum en ms.

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

Comment attendre les sélecteurs dans Playwright ?

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

Conclusion

Le web scraping est un vaste sujet et cet article ne fait que l'effleurer. Il est essentiel de choisir le bon outil pour votre cas d'utilisation spécifique. Par exemple, si vous souhaitez récupérer un site web en utilisant JavaScript, la bibliothèque cheerio est une bonne option. En revanche, si le site web nécessite JavaScript pour se charger complètement, Puppeteer ou Playwright sont de meilleures options. Le web scraping est un défi, mais la compréhension des outils peut vous éviter bien des maux de tête. J'espère que cet article vous a permis d'élargir votre horizon et je vous souhaite bonne chance dans vos projets de web scraping.