Skip to content

🕷️ The BEST Web Scraping framework that handles everything from a single request to a full-scale crawl! Don't be shy, join here: https://discord.gg/EMgGbDceNQ and follow here for daily tips and tricks: https://x.com/Scrapling_dev

17.6 KB
Raw Blame

title: "Guide de Scrapling : analyse de pages, HTTP et navigateurs furtifs" description: "DĂ©couvrez Scrapling avec des exemples de CSS, XPath, recherche de texte, requĂŞtes HTTP et navigateurs furtifs."

Premiers pas avec Scrapling {#get-started-with-scrapling}

Choisissez par oĂą commencer {#pick-your-path}

Vous ne savez pas par oĂą commencer ? Choisissez ce que vous voulez faire :

Je veux… Commencez ici
Analyser du HTML que j’ai dĂ©jĂ  SĂ©lection d’élĂ©ments : CSS, XPath et recherche par texte
Extraire une page rapidement et tester une idée Choisissez un fetcher et essayez-le, ou ouvrez le shell interactif
CrĂ©er un crawler capable de traiter plus de pages Spiders : exploration simultanĂ©e avec plusieurs sessions, pause et reprise
Extraire des données sans écrire de code Utilisez les commandes d’extraction ou connectez le serveur MCP à votre outil d’IA
Migrer depuis une autre bibliothèque Depuis BeautifulSoup ou comparaison avec Scrapy

Nous allons d’abord analyser des pages. Ensuite, nous récupérerons des pages avec des navigateurs, enverrons des requêtes et analyserons les réponses.

Nous utiliserons ce document HTML gĂ©nĂ©rĂ© par ChatGPT dans les exemples de cette page :

html_doc = """<html>
  <head>
    <title>Complex Web Page</title>
    <style>
      .hidden { display: none; }
    </style>
  </head>
  <body>
    <header>
      <nav>
        <ul>
          <li> <a href="#home">Home</a> </li>
          <li> <a href="#about">About</a> </li>
          <li> <a href="#contact">Contact</a> </li>
        </ul>
      </nav>
    </header>
    <main>
      <section id="products" schema='{"jsonable": "data"}'>
        <h2>Products</h2>
        <div class="product-list">
          <article class="product" data-id="1">
            <h3>Product 1</h3>
            <p class="description">This is product 1</p>
            <span class="price">$10.99</span>
            <div class="hidden stock">In stock: 5</div>
          </article>

          <article class="product" data-id="2">
            <h3>Product 2</h3>
            <p class="description">This is product 2</p>
            <span class="price">$20.99</span>
            <div class="hidden stock">In stock: 3</div>
          </article>

          <article class="product" data-id="3">
            <h3>Product 3</h3>
            <p class="description">This is product 3</p>
            <span class="price">$15.99</span>
            <div class="hidden stock">Out of stock</div>
          </article>
        </div>
      </section>
      
      <section id="reviews">
        <h2>Customer Reviews</h2>
        <div class="review-list">
          <div class="review" data-rating="5">
            <p class="review-text">Great product!</p>
            <span class="reviewer">John Doe</span>
          </div>
          <div class="review" data-rating="4">
            <p class="review-text">Good value for money.</p>
            <span class="reviewer">Jane Smith</span>
          </div>
        </div>
      </section>
    </main>
    <script id="page-data" type="application/json">
      {
        "lastUpdated": "2024-09-22T10:30:00Z",
        "totalProducts": 3
      }
    </script>
  </body>
</html>"""

Commencez par charger le HTML prĂ©cĂ©dent :

import re
from scrapling.parser import Selector
page = Selector(html_doc)
page  # <data='<html><head><title>Complex Web Page</tit...'>

RĂ©cupĂ©rez tout le texte de la page, y compris celui des Ă©lĂ©ments imbriquĂ©s :

page.get_all_text(ignore_tags=('script', 'style'))
# 'Complex Web Page\nHome\nAbout\nContact\nProducts\nProduct 1\nThis is product 1\n$10.99\nIn stock: 5\nProduct 2\nThis is product 2\n$20.99\nIn stock: 3\nProduct 3\nThis is product 3\n$15.99\nOut of stock\nCustomer Reviews\nGreat product!\nJohn Doe\nGood value for money.\nJane Smith'

Rechercher des éléments {#finding-elements}

Vous pouvez combiner plusieurs méthodes pour trouver les éléments dont vous avez besoin.

Trouvez le premier Ă©lĂ©ment HTML section :

section_element = page.find('section')
# <data='<section id="products" schema='{"jsonabl...' parent='<main><section id="products" schema='{"j...'>

Trouvez tous les Ă©lĂ©ments section :

section_elements = page.find_all('section')
# [<data='<section id="products" schema='{"jsonabl...' parent='<main><section id="products" schema='{"j...'>, <data='<section id="reviews"><h2>Customer Revie...' parent='<main><section id="products" schema='{"j...'>]

Trouvez tous les Ă©lĂ©ments section dont l’attribut id vaut products :

section_elements = page.find_all('section', {'id':"products"})
# Same as
section_elements = page.find_all('section', id="products")
# [<data='<section id="products" schema='{"jsonabl...' parent='<main><section id="products" schema='{"j...'>]

Trouvez tous les Ă©lĂ©ments section dont l’attribut id contient product :

section_elements = page.find_all('section', {'id*':"product"})

Trouvez les Ă©lĂ©ments h3 dont le texte correspond Ă  l’expression rĂ©gulière Product \d :

page.find_all('h3', re.compile(r'Product \d'))
# [<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>, <data='<h3>Product 2</h3>' parent='<article class="product" data-id="2"><h3...'>, <data='<h3>Product 3</h3>' parent='<article class="product" data-id="3"><h3...'>]

Trouvez les Ă©lĂ©ments h3 et h2 dont le texte correspond Ă  l’expression rĂ©gulière Product :

page.find_all(['h3', 'h2'], re.compile(r'Product'))
# [<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>, <data='<h3>Product 2</h3>' parent='<article class="product" data-id="2"><h3...'>, <data='<h3>Product 3</h3>' parent='<article class="product" data-id="3"><h3...'>, <data='<h2>Products</h2>' parent='<section id="products" schema='{"jsonabl...'>]

Trouvez les Ă©lĂ©ments dont le texte est exactement Products. Les espaces ne sont pas pris en compte :

page.find_by_text('Products', first_match=False)
# [<data='<h2>Products</h2>' parent='<section id="products" schema='{"jsonabl...'>]

Ou trouvez les Ă©lĂ©ments dont le texte correspond Ă  l’expression rĂ©gulière Product \d :

page.find_by_regex(r'Product \d', first_match=False)
# [<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>, <data='<h3>Product 2</h3>' parent='<article class="product" data-id="2"><h3...'>, <data='<h3>Product 3</h3>' parent='<article class="product" data-id="3"><h3...'>]

Trouvez des Ă©lĂ©ments similaires Ă  celui que vous avez choisi :

target_element = page.find_by_regex(r'Product \d', first_match=True)
# <data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>
target_element.find_similar()
# [<data='<h3>Product 2</h3>' parent='<article class="product" data-id="2"><h3...'>, <data='<h3>Product 3</h3>' parent='<article class="product" data-id="3"><h3...'>]

Trouvez le premier Ă©lĂ©ment qui correspond Ă  un sĂ©lecteur CSS :

page.css('.product-list [data-id="1"]')[0]
# <data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>

Trouvez tous les Ă©lĂ©ments qui correspondent Ă  un sĂ©lecteur CSS :

page.css('.product-list article')
# [<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>, <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>, <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]

Trouvez le premier Ă©lĂ©ment qui correspond Ă  un sĂ©lecteur XPath :

page.xpath("//*[@id='products']/div/article")[0]
# <data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>

Trouvez tous les Ă©lĂ©ments qui correspondent Ă  un sĂ©lecteur XPath :

page.xpath("//*[@id='products']/div/article")
# [<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>, <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>, <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]

Ce sont les usages de base. Nous verrons d’autres options de ces méthodes de sélection plus loin.

Lire les données des éléments {#accessing-elements-data}

Vous pouvez lire les donnĂ©es ainsi :

>>> section_element.tag
'section'
>>> print(section_element.attrib)
{'id': 'products', 'schema': '{"jsonable": "data"}'}
>>> section_element.attrib['schema'].json()  # If an attribute value can be converted to json, then use `.json()` to convert it
{'jsonable': 'data'}
>>> section_element.text  # Direct text content
''
>>> section_element.get_all_text()  # All text content recursively
'Products\nProduct 1\nThis is product 1\n$10.99\nIn stock: 5\nProduct 2\nThis is product 2\n$20.99\nIn stock: 3\nProduct 3\nThis is product 3\n$15.99\nOut of stock'
>>> section_element.html_content  # The HTML content of the element
'<section id="products" schema=\'{"jsonable": "data"}\'><h2>Products</h2>\n        <div class="product-list">\n          <article class="product" data-id="1"><h3>Product 1</h3>\n            <p class="description">This is product 1</p>\n            <span class="price">$10.99</span>\n            <div class="hidden stock">In stock: 5</div>\n          </article><article class="product" data-id="2"><h3>Product 2</h3>\n            <p class="description">This is product 2</p>\n            <span class="price">$20.99</span>\n            <div class="hidden stock">In stock: 3</div>\n          </article><article class="product" data-id="3"><h3>Product 3</h3>\n            <p class="description">This is product 3</p>\n            <span class="price">$15.99</span>\n            <div class="hidden stock">Out of stock</div>\n          </article></div>\n      </section>'
>>> print(section_element.prettify())  # The prettified version
'''
<section id="products" schema='{"jsonable": "data"}'><h2>Products</h2>
    <div class="product-list">
      <article class="product" data-id="1"><h3>Product 1</h3>
        <p class="description">This is product 1</p>
        <span class="price">$10.99</span>
        <div class="hidden stock">In stock: 5</div>
      </article><article class="product" data-id="2"><h3>Product 2</h3>
        <p class="description">This is product 2</p>
        <span class="price">$20.99</span>
        <div class="hidden stock">In stock: 3</div>
      </article><article class="product" data-id="3"><h3>Product 3</h3>
        <p class="description">This is product 3</p>
        <span class="price">$15.99</span>
        <div class="hidden stock">Out of stock</div>
      </article>
    </div>
</section>
'''
>>> section_element.path  # All the ancestors in the DOM tree of this element
[<data='<main><section id="products" schema='{"j...' parent='<body> <header><nav><ul><li> <a href="#h...'>,
 <data='<body> <header><nav><ul><li> <a href="#h...' parent='<html><head><title>Complex Web Page</tit...'>,
 <data='<html><head><title>Complex Web Page</tit...'>]
>>> section_element.generate_css_selector
'#products'
>>> section_element.generate_full_css_selector
'body > main > #products'
>>> section_element.generate_xpath_selector
"//*[@id='products']"
>>> section_element.generate_full_xpath_selector
"//body/main/*[@id='products']"

Navigation {#navigation}

Utilisez les Ă©lĂ©ments trouvĂ©s prĂ©cĂ©demment :

>>> section_element.parent
<data='<main><section id="products" schema='{"j...' parent='<body> <header><nav><ul><li> <a href="#h...'>
>>> section_element.parent.tag
'main'
>>> section_element.parent.parent.tag
'body'
>>> section_element.children
[<data='<h2>Products</h2>' parent='<section id="products" schema='{"jsonabl...'>,
 <data='<div class="product-list"> <article clas...' parent='<section id="products" schema='{"jsonabl...'>]
>>> section_element.siblings
[<data='<section id="reviews"><h2>Customer Revie...' parent='<main><section id="products" schema='{"j...'>]
>>> section_element.next  # gets the next element, the same logic applies to `quote.previous`.
<data='<section id="reviews"><h2>Customer Revie...' parent='<main><section id="products" schema='{"j...'>
>>> section_element.children.css('h2::text').getall()
['Products']
>>> page.css('[data-id="1"]')[0].has_class('product')
True

Pour aller au-delĂ  du parent d’un Ă©lĂ©ment, vous pouvez parcourir tous ses ancĂŞtres :

for ancestor in section_element.iterancestors():
    print(ancestor.tag)

Vous pouvez aussi chercher un ancĂŞtre qui remplit une condition. Passez une fonction qui reçoit un objet Selector et renvoie True s’il remplit la condition, ou False sinon :

>>> section_element.find_ancestor(lambda ancestor: ancestor.css('nav'))
<data='<body> <header><nav><ul><li> <a href="#h...' parent='<html><head><title>Complex Web Page</tit...'>

Récupérer des pages web {#fetching-websites}

Au lieu de fournir du HTML à Scrapling, vous pouvez récupérer la réponse d’un site par des requêtes HTTP ou un navigateur.

Choisissez le fetcher adapté à votre cas.

RequĂŞtes HTTP {#http-requests}

Pour envoyer des requĂŞtes HTTP, importez et utilisez la classe Fetcher :

from scrapling.fetchers import Fetcher
page = Fetcher.get('https://scrapling.requestcatcher.com/get', impersonate="chrome")

Ces exemples montrent comment utiliser les diffĂ©rentes mĂ©thodes HTTP :

from scrapling.fetchers import Fetcher
page = Fetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)
page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030')
page = Fetcher.put('https://scrapling.requestcatcher.com/put', data={'key': 'value'})
page = Fetcher.delete('https://scrapling.requestcatcher.com/delete')

Pour envoyer des requĂŞtes asynchrones, changez l’importation :

from scrapling.fetchers import AsyncFetcher
page = await AsyncFetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)
page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030')
page = await AsyncFetcher.put('https://scrapling.requestcatcher.com/put', data={'key': 'value'})
page = await AsyncFetcher.delete('https://scrapling.requestcatcher.com/delete')

!!! note "Notes"

1. `stealthy_headers` génère des en-têtes de navigateur réels, dont un en-tête de provenance Google. Cette option est activée par défaut.
2. `impersonate` permet d’imiter l’empreinte TLS d’une version précise de navigateur.
3. `http3` active HTTP/3 pour rapprocher les requêtes de celles d’un vrai navigateur.

Consultez les autres options dans le guide des requĂŞtes HTTP.

Chargement dynamique {#dynamic-loading}

Vous pouvez aussi travailler avec des sites qui chargent leur contenu par JavaScript.

StealthyFetcher propose de nombreuses options pour récupérer et charger des pages avec des navigateurs basés sur Chromium.

from scrapling.fetchers import StealthyFetcher
page = StealthyFetcher.fetch('https://quotes.toscrape.com/js/', disable_resources=True, block_ads=True, wait_selector='.quote')
print(len(page.css(".quote")))  # -> 10

# The async version of fetch
page = await StealthyFetcher.async_fetch('https://quotes.toscrape.com/js/', disable_resources=True, block_ads=True, wait_selector='.quote')
print(len(page.css(".quote")))  # -> 10

Il utilise Playwright avec des changements pour masquer l’automatisation. Utilisez le Chromium inclus, votre Google Chrome installé avec real_chrome=True ou un navigateur déjà ouvert via cdp_url.

Fonctions contre la détection des bots {#anti-bot-features}

Voici quelques-unes de ses fonctions :

  1. Franchit automatiquement les différents types de Cloudflare Turnstile et Interstitial avec solve_cloudflare=True.
  2. Évite les fuites de CDP runtime et WebRTC.
  3. Isole l’exécution de JavaScript, supprime de nombreuses traces de Playwright et évite la détection de certains comportements connus des bots.
  4. Ajoute du bruit au canvas pour empĂŞcher son usage comme empreinte du navigateur.
  5. Corrige les méthodes connues de détection des navigateurs sans interface graphique et permet d’éviter la détection par les différences de fuseau horaire.
  6. Inclut d’autres options pour éviter la détection.
from scrapling.fetchers import StealthyFetcher
page = StealthyFetcher.fetch('https://www.browserscan.net/bot-detection')  # Running headless by default
page.status == 200  # -> True

page = StealthyFetcher.fetch('https://nopecha.com/demo/cloudflare', solve_cloudflare=True)  # Solve Cloudflare captcha automatically if presented
page.status == 200  # -> True

page = StealthyFetcher.fetch('https://www.browserscan.net/bot-detection', block_webrtc=True, hide_canvas=True, dns_over_https=True) # and the rest of arguments...
# The async version of fetch
page = await StealthyFetcher.async_fetch('https://www.browserscan.net/bot-detection')
page.status == 200  # -> True

Consultez le guide de navigation pour connaître les détails et la liste complète des paramètres.


Vous avez maintenant une vue d’ensemble de Scrapling. Passez à la section suivante pour découvrir d’autres fonctions.