` au sein d’une balise ``. Le point (`.`) au début de l’expression XPath indique de lancer la recherche à partir de la balise <article> `` plutôt que depuis le point de départ par défaut. La ligne suivante utilise la méthode `cssselect` pour extraire le prix d’une balise `
` avec la classe `price_color`. Puisque `cssselect` renvoie une liste, l’indexation (`[0]`) accède au premier élément et `text_content ()` récupère le texte contenu dans l’élément. Chaque paire de titres et de prix extraite est ensuite ajoutée à la liste `books` sous forme de dictionnaire, qui peut être facilement stocké dans un fichier JSON.
Maintenant que vous avez terminé le processus de web scraping, il est temps de sauvegarder ces données localement. Ouvrez votre fichier de script et saisissez le code suivant:
```none
with open("books.json", "w", encoding="utf-8") as file:
json.dump(books ,file)
```
Dans ce code, un nouveau fichier nommé `books.json` est créé. Ce fichier est renseigné à l’aide de la méthode `json.dump` , qui prend la liste `books` comme source et un objet `file` comme destination.
Vous pouvez tester ce script en ouvrant le terminal et en exécutant la commande suivante:
```none
python static_scrape.py
```
Cette commande génère un nouveau fichier dans votre répertoire avec le résultat suivant:
Tout le code source de ce tutoriel est disponible sur [GitHub](https://gist.github.com/vivekthedev/c1c5f0fb0e23cabfa3fa5c364b939f7c).
### Analyse du contenu HTML dynamique
Il est plus difficile de récupérer du contenu Web dynamique que du contenu statique, car JavaScript affiche les données en continu plutôt qu’en une seule fois. Pour vous aider à extraire le contenu dynamique, vous utilisez un outil d’automatisation du navigateur appelé [Selenium](https://www.selenium.dev/), qui vous permet de créer et d’exécuter une instance de navigateur et de la contrôler par programmation.
Pour installer Selenium, ouvrez le terminal et exécutez la commande suivante:
```none
pip install selenium
```
YouTube est un excellent exemple de contenu rendu à l’aide de JavaScript. Lorsque vous visitez une chaîne, seul un nombre limité de vidéos est initialement chargé. D’autres vidéos sont chargées au fur et à mesure que vous faites défiler la page vers le bas. Ici, vous pouvez extraire les données des cent meilleures vidéos de la chaîne YouTube [FreeCodeCamp.org](https://www.youtube.com/c/Freecodecamp) en émulant des appuis sur le clavier pour faire défiler la page.
Pour commencer, examinez le code HTML de la page Web. Lorsque vous ouvrez **Dev Tools**, les informations suivantes s’affichent:
Le code suivant identifie les éléments responsables de l’affichage du titre et du lien de la vidéo:
```none
GitHub Advanced Security Certification – Pass the Exam!
```
Le titre de la vidéo se trouve dans la balise `yt-formatted-string` avec l’ID `video-title`, et le lien vidéo se trouve dans l’attribut `href` de la balise `a` avec l’ID `video-title-link`.
Une fois que vous avez identifié ce que vous souhaitez extraire, créez un nouveau fichier nommé `dynamic_scrape.py` et ajoutez le code suivant, qui importe tous les modules requis pour le script:
```none
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from lxml import html
from time import sleep
import json
```
Ici, vous commencez par importer `webdriver` depuis `selenium`, ce qui crée une instance de navigateur que vous pouvez contrôler par programmation. Les lignes suivantes importent `By` et `Keys`, qui sélectionnent un élément sur le web et effectuent quelques pressions sur le clavier. La fonction `sleep` est importée pour suspendre l’exécution du programme et attendre que le code JavaScript affiche le contenu de la page.
Une fois toutes les importations triées, vous pouvez définir l’instance de pilote pour le navigateur de votre choix. Ce didacticiel utilise [Chrome](https://www.selenium.dev/documentation/webdriver/browsers/chrome/), mais Selenium prend également en charge [Edge](https://www.selenium.dev/documentation/webdriver/browsers/edge/), [Firefox](https://www.selenium.dev/documentation/webdriver/browsers/firefox/)et [Safari](https://www.selenium.dev/documentation/webdriver/browsers/safari/).
Pour définir l’instance de pilote pour le navigateur, ajoutez le script avec le code suivant:
```none
URL = "https://www.youtube.com/@freecodecamp/videos"
videos = []
driver = webdriver.Chrome()
driver.get(URL)
sleep(3)
```
Comme dans le script précédent, vous déclarez une variable `URL` contenant l’URL Web que vous souhaitez extraire et une variable `videos` qui stocke toutes les données sous forme de liste. Ensuite, une variable `driver` est déclarée (*c’est-à-dire* une instance `Chrome` ) que vous utilisez lorsque vous interagissez avec le navigateur. La fonction `get ()` ouvre l’instance du navigateur et envoie une demande à l’adresse `URL`spécifiée. Ensuite, vous appelez la fonction `sleep` pour attendre trois secondes avant d’accéder à un élément de la page Web afin de vous assurer que tout le code HTML est chargé dans le navigateur.
Comme indiqué précédemment, YouTube utilise JavaScript pour charger d’autres vidéos lorsque vous faites défiler la page vers le bas. Pour extraire les données d’une centaine de vidéos, vous devez faire défiler la page vers le bas par programmation après avoir ouvert le navigateur. Vous pouvez le faire en ajoutant le code suivant à votre script:
```none
parent = driver.find_element(By.TAG_NAME, 'html')
for i in range(4):
parent.send_keys(Keys.END)
sleep(3)
```
Dans ce code, la balise `` est sélectionnée à l’aide de la fonction `find_element` . Elle renvoie le premier élément correspondant aux critères donnés, qui dans ce cas est la balise `html` . La méthode `send_keys` simule l’appui sur la touche `END` pour faire défiler la page vers le bas, ce qui déclenche le chargement d’autres vidéos. Cette action est répétée quatre fois dans une boucle `pour` pour s’assurer que suffisamment de vidéos sont chargées. La fonction `sleep` s’arrête pendant trois secondes après chaque défilement pour permettre aux vidéos de se charger avant de les faire défiler à nouveau.
Maintenant que vous disposez de toutes les données nécessaires pour démarrer le processus de scraping, il est temps d’utiliser lxml avec cssselect pour sélectionner les éléments que vous souhaitez extraire:
```none
html_data = html.fromstring(driver.page_source)
videos_html = html_data.cssselect("a#video-title-link")
for video in videos_html:
title = video.text_content()
link = "https://www.youtube.com" + video.get("href")
videos.append( {"title": title, "link": link} )
```
Dans ce code, vous transmettez le contenu HTML de l’attribut `page_source` du pilote à la méthode `fromstring` , qui crée une arborescence hiérarchique du code HTML. Ensuite, vous sélectionnez toutes les balises `` comportant l’ID `video-title-link` à l’aide de sélecteurs CSS. Le signe `#` indique la sélection à l’aide de l’ID de la balise. Cette sélection renvoie une liste d’éléments qui répondent aux critères donnés. Le code répète ensuite sur chaque élément pour extraire le titre et le lien. La méthode `text_content` extrait le texte intérieur (le titre de la vidéo), tandis que la méthode `get` récupère la valeur de l’attribut `href` (le lien vidéo). Enfin, les données sont stockées dans une liste appelée `vidéos`.
À ce stade, vous avez terminé le processus de grattage. L’étape suivante consiste à stocker ces données extraites localement dans votre système. Pour stocker les données, ajoutez le code suivant dans le script:
```none
with open('videos.json', 'w') as file:
json.dump(videos, file)
driver.close()
```
Ici, vous créez un fichier `videos.json` et vous utilisez la méthode `json.dump` pour sérialiser la liste des vidéos au format JSON et l’écrire dans l’objet du fichier. Enfin, vous appelez la méthode close sur l’objet pilote pour fermer et détruire l’instance du navigateur en toute sécurité.
Vous pouvez maintenant tester votre script en ouvrant le terminal et en exécutant la commande suivante:
```none
python dynamic_scrape.py
```
Après avoir exécuté le script, un nouveau fichier nommé `videos.json` est créé dans votre répertoire:
Tout le code source de ce tutoriel est disponible sur [GitHub](https://gist.github.com/vivekthedev/36489fbaf896eb7c06ebb9350dec298a).
### Utilisation de lxml avec les proxies de Bright Data
Bien que le web scraping soit une excellente technique pour automatiser la collecte de données provenant de différentes sources, le processus n’est pas sans difficultés. Vous devez faire face aux outils anti-grattage mis en place par les sites Web, à la limitation des taux, au géoblocage et à l’absence d’anonymat. [Les serveurs proxy](https://brightdata.fr/proxy-types/proxy-servers) peuvent résoudre ces problèmes en agissant comme des intermédiaires qui masquent l’adresse IP de l’utilisateur, permettant ainsi aux scrapers de contourner les restrictions et d’accéder à des données ciblées sans être détectés. Bright Data est le meilleur choix pour [services proxy fiables](https://brightdata.fr/proxy-types).
L’exemple suivant montre à quel point il est facile de travailler avec les proxys Bright Data. Cela implique d’apporter quelques modifications au fichier `script_scrape.py` pour scraper le site Web Books to Scrape.
Pour commencer, vous devez obtenir des proxys auprès de Bright Data en vous inscrivant à un essai gratuit, qui fournit des ressources proxy d’une valeur de 5 dollars américains. Après avoir créé un compte Bright Data, le tableau de bord suivant s’affiche:
Accédez à l’option **Mes zones** et créez une nouvelle zone [proxy résidentiel](https://brightdata.fr/proxy-types/residential-proxies) . La création d’une nouvelle zone révèle votre nom d’utilisateur, votre mot de passe et votre hôte du proxy, dont vous aurez besoin à l’étape suivante.
Ouvrez le fichier `static_scrape.py` et ajoutez le code suivant sous la variable URL:
```none
URL = "https://books.toscrape.com/"
# new
username = ""
password = ""
hostname = ""
proxies = {
"http": f"https://{username}:{password}@{hostname}",
"https": f"https://{username}:{password}@{hostname}",
}
content = requests.get(URL, proxies=proxies).text
```
Remplacez les espaces réservés `username`, `password` et `hostname` par les informations d’identification de votre proxy. Ce code indique à la bibliothèque `requests` d’utiliser le proxy spécifié. Le reste de votre script reste inchangé.
Testez votre script en exécutant la commande suivante:
```none
python static_scrape.py
```
Après avoir exécuté ce script, vous verrez un résultat similaire à celui que vous avez reçu dans l’exemple précédent.
Vous pouvez consulter l’intégralité de ce script sur [GitHub](https://gist.github.com/vivekthedev/201f994bc14e4dbc7263b03983f917b3).
## Conclusion
lxml est un outil robuste et facile à utiliser pour extraire des données à partir de documents HTML. lxml est optimisé pour la vitesse et prend en charge les sélecteurs XPath et CSS, ce qui permet une analyse efficace des documents XML et HTML volumineux.
Dans ce didacticiel, vous avez tout appris sur le web scraping avec lxml et sur le scraping de contenu dynamique et statique. Vous avez également appris comment l’utilisation des serveurs proxy [de Bright Data](/) peut vous aider à contourner les restrictions imposées par les sites Web aux scrapers.
Bright Data est votre plateforme unique pour toutes les solutions de web scraping. Bright Data propose des fonctionnalités telles que les proxies, les navigateurs de scraping et les reCAPTCHA qui permettent aux utilisateurs de résoudre efficacement leurs problèmes de web scraping. Bright Data propose également un blog détaillé [](/blog) contenant des didacticiels et des bonnes pratiques liés au web scraping.
Vous souhaitez commencer? Inscrivez-vous dès maintenant et testez nos produits gratuitement!
Contacter ventesEssai gratuit
Table des matières
Dedicated Scraper APIs & No-Code Scrapers
Over 1000 scrapers for all popular domains. Simplify your web scraping.
[See pricing](/pricing/web-scraper "See pricing")
Just want data? Skip scraping.
Hundreds of ready-to-use datasets from all popular domains.
[See pricing](/pricing/datasets "See pricing")
[ ](https://news.ycombinator.com/submitlink?t=Comment+utiliser+lxml+pour+le+web+scraping%C2%A0%3F&u=https://brightdata.fr/blog/donnees-web/lxml-web-scraping) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Comment+utiliser+lxml+pour+le+web+scraping%C2%A0%3F&url=https://brightdata.fr/blog/donnees-web/lxml-web-scraping) [ ](http://www.reddit.com/submit?title=Comment+utiliser+lxml+pour+le+web+scraping%C2%A0%3F&url=https://brightdata.fr/blog/donnees-web/lxml-web-scraping)
## Vous pourriez aussi être intéressé par
[  ](https://brightdata.fr/blog/ai/openhuman-with-bright-data "Accès Web Prêt pour la Production dans OpenHuman via le CLI Bright Data")
[AI
Antonello Zanini
Technical Writer
### Accès Web Prêt pour la Production dans OpenHuman via le CLI Bright Data
Intégrez le CLI Bright Data avec OpenHuman pour permettre un accès web prêt pour la production et la collecte de données pour les agents IA.
09-Sep-2026
14 min de lecture
](https://brightdata.fr/blog/ai/openhuman-with-bright-data)
[  ](https://brightdata.fr/blog/donnees-web/multimodal-web-scraping-with-minimax "Scraping Web Multimodal avec MiniMax")
[Données Web
Antonello Zanini
Technical Writer
### Scraping Web Multimodal avec MiniMax
Associez Bright Data Web Unlocker avec la vision MiniMax M3 pour extraire des données structurées à partir d’images et de captures d’écran de pages web.
09-Sep-2026
5 min de lecture
](https://brightdata.fr/blog/donnees-web/multimodal-web-scraping-with-minimax)
[  ](https://brightdata.fr/blog/ai/best-cli-tools-for-codex "Les 10 meilleurs outils CLI pour Codex en 2026 – Testés & Classés")
[AI
Daniel Shashko
Web Data & AI Expert
### Les 10 meilleurs outils CLI pour Codex en 2026 – Testés & Classés
Les 10 outils CLI qui rendent Codex plus rapide et plus capable, en commençant par le Bright Data CLI pour un accès web réel depuis l’intérieur du sandbox.
06-Sep-2026
24 min de lecture
](https://brightdata.fr/blog/ai/best-cli-tools-for-codex)