Analysez le HTML en Python : trouvez des éléments par tag, id et class, sélectionnez avec des sélecteurs CSS, et extrayez texte, liens et un tableau entier en lignes — enseigné sur une page en mémoire reproductible, puis appliqué à une récupération en direct.
Récupérez les données d’une page web en Python avec BeautifulSoup. Analysez le HTML, trouvez des éléments par tag, id et class, sélectionnez avec des sélecteurs CSS (find/find_all et select/select_one), extrayez texte et attributs, et lisez un tableau en lignes — chaque mécanisme enseigné sur un document HTML en mémoire et reproductible pour que chaque exemple s’exécute vraiment. Puis récupérez une page en direct avec requests, et scrapez poliment. Copiez chaque bloc et exécutez-le.
Date de publication
18 juillet 2026
Modifié
18 juillet 2026
AstucePoints clés
BeautifulSoup transforme le HTML d’une page en un arbre que vous pouvez interroger. Le web scraping consiste à extraire des données qui vivent sur une page web plutôt que dans un téléchargement bien rangé ; le HTML est le balisage dans lequel une page est écrite, et BeautifulSoup l’analyse (lit le texte pour en faire une structure navigable) afin que vous puissiez en extraire les parties voulues. Installez-le une fois avec pip install beautifulsoup4.
Trouvez des éléments de deux façons — choisissez celle que vous préférez.find() / find_all() cherchent par nom de tag plus id= / class_= ; select_one() / select() prennent un sélecteur CSS ("table#products tr"). Un élément HTML (ou tag) est une pièce de la page — un titre <h1>, un lien <a>, une ligne <tr> ; un sélecteur CSS est un court motif qui sélectionne des éléments (#title, .price, ul.nav a).
Extrayez le texte avec get_text(strip=True), les attributs avec el["href"].get_text(strip=True) renvoie le texte visible d’un élément, débarrassé des espaces qui l’entourent ; un attribut est un couple nom/valeur sur un tag (le href d’un lien, le src d’une image), lu en indexant l’élément comme un dict.
Passez à l’échelle une structure répétée en une liste de dicts.find_all (ou select) le bloc répété — lignes de tableau, cartes produit — puis bouclez et construisez un dict par élément. C’est le motif de fond derrière tout scraping réel.
Le jugement qu’une ligne d’IA saute : utilisez des sélecteurs stables et scrapez poliment. Préférez les id et les class aux chemins positionnels fragiles, et avant de récupérer un site en direct, consultez son robots.txt et ses conditions, et mettez un délai entre les requêtes.
Introduction
Vous avez besoin de données qui vivent sur une page web — une liste de produits avec leurs prix, un tableau de résultats, un ensemble de liens — mais le site n’offre aucun téléchargement ni aucune API web à appeler. Les données sont là, dans le HTML de la page, mêlées au balisage qui l’affiche. Le web scraping est la technique qui les extrait par programme : lire le HTML de la page et en tirer les parties voulues.
En Python, l’outil standard est BeautifulSoup (le paquet beautifulsoup4, importé sous le nom bs4). Il analyse le HTML — lit le texte brut pour en faire un arbre d’éléments — et vous laisse trouver et extraire du contenu avec les mêmes sélecteurs CSS que ceux dont vous vous serviriez pour styler une page. Installez-le dans l’environnement virtuel de votre projet (voir Environnements virtuels et dépendances en Python) :
pip install beautifulsoup4
La plupart des tutoriels scrapent un site en direct et collent une capture d’écran que personne ne peut reproduire, parce que le site change dès le lendemain. Cette leçon suit une voie plus propre : nous enseignons chaque mécanisme fondamental sur un petit document HTML en mémoire — une chaîne — pour que chaque exemple ci-dessous s’exécute vraiment et renvoie la sortie que vous voyez. Puis nous montrons la recette réseau en direct (récupérer une vraie URL avec requests, puis l’analyser) sous forme de code clairement étiqueté à exécuter localement.
Note
Comment cette page fonctionne. Les exemples d’analyse construisent une chaîne HTML fixe et s’exécutent ici même — copiez n’importe quel bloc et exécutez-le pour reproduire la sortie affichée. La seule récupération en direct (requests.get("https://…")) atteint Internet, elle ne peut donc pas être figée dans une page reproductible ; elle est marquée à exécuter localement et vous la collez dans votre propre script. Exécutez les blocs dans l’ordre — chacun réutilise l’objet soup construit dans le premier.
Analyser du HTML en un document BeautifulSoup
Tout scraping commence par analyser du HTML en un objet document que vous pouvez interroger. Passez le texte HTML et un parser — le composant qui lit le balisage — à BeautifulSoup(). Nous utilisons "html.parser", fourni avec la bibliothèque standard de Python, il n’y a donc rien de plus à installer.
Voici une petite page de boutique : un titre, une ligne d’introduction, une liste de liens de catégories, un tableau de produits, et trois « cartes » produit. Construisez-la une fois dans soup :
soup est le document analysé — la page entière sous forme d’arbre navigable. Pour un vrai site, la seule différence est la provenance du HTML : vous le récupérez d’abord sur le réseau (montré à la fin), puis vous passez ce texte au même appel BeautifulSoup().
Note
Quel parser ?"html.parser" est intégré et ne nécessite aucune installation — le bon choix par défaut pour apprendre et pour la plupart des scrapings. Deux parsers tiers plus rapides existent, "lxml" et "html5lib" ; vous en feriez le pip install et passeriez son nom à la place seulement si vous avez besoin de la vitesse ou de sa gestion plus tolérante du balisage cassé. Le code BeautifulSoup que vous écrivez est identique quel que soit votre choix. Voir installer un parser.
Trouver un élément ou plusieurs : find et find_all
Deux méthodes font la recherche, et la différence compte :
find() renvoie le premier élément correspondant (un tag), ou None s’il n’y a pas de correspondance.
find_all() renvoie une liste de tous les éléments correspondants.
Cherchez par nom de tag, et affinez avec id= ou class_= (c’est class_ avec un underscore final, parce que class est un mot réservé en Python). Récupérez le titre de la page — le seul <h1> avec id="title" — puis lisez son texte :
soup.find("h1", id="title")
<h1 id="title">Datanovia Gadget Store</h1>
Cela renvoie le tag <h1> entier. Pour n’en extraire que les mots visibles, ajoutez get_text(strip=True) — nous reviendrons sur l’extraction de texte dans un instant :
soup.find("h1", id="title").get_text(strip=True)
'Datanovia Gadget Store'
Pour récupérer chaque élément d’un ensemble, passez à find_all(). Ici, nous récupérons les trois liens de catégories d’un coup et lisons le texte de chacun :
links = soup.find_all("a")[a.get_text() for a in links]
['Laptops', 'Phones', 'Tablets']
find() n’aurait renvoyé que le premier lien. Quand vous voulez une colonne de valeurs, vous voulez presque toujours find_all().
Sélectionner avec des sélecteurs CSS : select et select_one
BeautifulSoup parle aussi les sélecteurs CSS — les mêmes motifs que ceux d’une feuille de style — via select() (renvoie une liste) et select_one() (renvoie la première correspondance). Beaucoup trouvent les sélecteurs plus naturels que la forme tag-plus-mot-clé, surtout pour l’imbrication. Les deux API se recouvrent ; utilisez celle qui se lit le plus clairement pour la tâche.
Un sélecteur cible les éléments de quelques façons courantes. #title sélectionne l’élément avec id="title" ; .intro sélectionne tout ce qui a class="intro" ; ul.nav a sélectionne chaque <a>à l’intérieur d’un <ul class="nav"> :
# By id — one elementsoup.select_one("#title").get_text(strip=True)
'Datanovia Gadget Store'
# Descendant selector — every <a> inside <ul class="nav">[a.get_text() for a in soup.select("ul.nav a")]
['Laptops', 'Phones', 'Tablets']
L’espace dans ul.nav a signifie un <a> n’importe où à l’intérieur d’une liste .nav — les sélecteurs se composent exactement comme en CSS. Voici comment les deux styles se correspondent, pour que vous puissiez choisir l’un ou l’autre :
Objectif
find / find_all
select / select_one (CSS)
Premier élément par tag
soup.find("h1")
soup.select_one("h1")
Élément par id
soup.find(id="title")
soup.select_one("#title")
Tous les éléments d’une class
soup.find_all(class_="price")
soup.select(".price")
Un tag avec une class
soup.find_all("span", class_="price")
soup.select("span.price")
Imbriqué (descendant)
(chaînez deux appels find/find_all)
soup.select("ul.nav a")
find/find_all prennent de purs arguments Python ; select/select_one prennent une seule chaîne de sélecteur et gèrent l’imbrication en une seule expression. Pour découvrir le bon sélecteur sur un vrai site, ouvrez-le dans votre navigateur, faites un clic droit sur l’élément voulu, et choisissez Inspecter — les outils de développement vous montrent les tags, id et class à cibler. Le support complet des sélecteurs se trouve dans la section sélecteurs CSS de la documentation.
Extraire texte et attributs
Sélectionner un élément vous donne le tag ; il reste à en extraire les données. Deux choses les portent : le texte entre les tags, et les attributs sur le tag.
Le texte vient de get_text(). Passez strip=True pour supprimer les espaces et retours à la ligne que l’indentation HTML laisse autour du contenu — presque toujours ce que vous voulez :
soup.select_one("p.intro").get_text(strip=True)
'Our three best sellers this week.'
Un attribut est un couple nom/valeur écrit sur le tag lui-même — la destination d’un lien vit dans son href, la source d’une image dans son src. Lisez-en un en indexant l’élément comme un dictionnaire. Rassemblez le texte visible de chaque lien à côté de son URL :
links = soup.select("ul.nav a")[(a.get_text(strip=True), a["href"]) for a in links]
Sélectionnez les éléments <a> une fois, puis extrayez deux choses de chacun — le texte avec get_text() et la destination avec a["href"]. L’indexation lève une KeyError si l’attribut est absent ; quand un tag peut l’avoir ou non, utilisez a.get("href"), qui renvoie None au lieu de lever une exception. L’extraction de texte est traitée sous get_text, et la lecture des attributs d’un tag sous kinds of objects.
Extraire un tableau en lignes
Les données d’une page se trouvent souvent dans un <table> HTML — des lignes <tr>, chacune contenant des cellules (<td>, ou <th> dans l’en-tête). BeautifulSoup n’a pas de lecteur de tableau en un seul appel, mais le motif est court : sélectionnez les lignes, sautez l’en-tête, et lisez les cellules de chaque ligne dans une liste.
Sélectionnez chaque <tr> dans le tableau des produits, retirez le premier (la ligne d’en-tête) avec une tranche [1:], et extrayez le texte des <td> de chaque ligne :
rows = []for tr in soup.select("table#products tr")[1:]: cells = [td.get_text(strip=True) for td in tr.find_all("td")] rows.append(cells)rows
Chaque liste interne est une ligne de données — nom de produit et prix sous forme de chaînes. find_all("td") à l’intérieur de la boucle garde les cellules d’une ligne ensemble ; la tranche [1:] saute l’en-tête <th> pour ne vous laisser que les données. À partir de là, vous convertiriez les chaînes de prix en nombres, ou vous passeriez rows directement à pandas — pandas.DataFrame(rows, columns=["product", "price"]) — pour continuer à le travailler (voir Les DataFrames pandas en Python).
Astuce
Raccourci pour les tableaux propres. Si le tableau d’une page est bien formé, pandas.read_html(html) lit tous ses tableaux dans une liste de DataFrames en un seul appel — pratique quand vous voulez juste le tableau. Recourez à la boucle BeautifulSoup manuelle ci-dessus quand le balisage est plus désordonné, ou quand vous avez besoin de cellules que la disposition du tableau ne vous donne pas proprement (un lien dans une cellule, un attribut data-*).
Passer un motif à l’échelle : des cartes répétées en une liste de dicts
Les vraies pages répètent une structure — une grille de cartes produit, une liste de résultats de recherche. Le motif de fond est : find_all (ou select) le conteneur répété, puis bouclez et construisez un dict par élément, ce qui vous donne une liste d’enregistrements prête à charger dans pandas ou à écrire en JSON.
Notre page a trois <div class="card">, chacun avec un nom et un prix. Sélectionnez les cartes, et pour chacune extrayez ses champs dans un dict :
products = []for card in soup.select("div.card"): products.append({"name": card.select_one(".name").get_text(strip=True),"price": int(card.select_one(".price").get_text(strip=True)), })products
Deux détails rendent ceci robuste. À l’intérieur de la boucle, nous sélectionnons depuis card, pas depuis soup — ainsi le nom et le prix de chaque enregistrement viennent de la même carte et ne peuvent pas se contaminer entre eux. Et nous appelons select_one() (singulier) parce que chaque carte a exactement un nom et un prix. Envelopper le texte du prix dans int() convertit "1200" en le nombre 1200, pour que les valeurs soient prêtes pour l’arithmétique. Cette boucle « sélectionner l’ensemble, construire un dict par élément » est la forme de presque tout scraping non trivial.
Récupérer une page en direct avec requests
Tout jusqu’ici tournait sur une chaîne fixe. Pour scraper un vrai site, vous récupérez d’abord son HTML sur le réseau, puis vous confiez ce texte au même appel BeautifulSoup() que vous connaissez déjà. La récupération est le travail de la bibliothèque requests — BeautifulSoup ne fait qu’analyser ; il ne touche jamais lui-même au réseau.
Parce que ceci atteint un serveur en direct, ça ne peut pas faire partie de cette page reproductible — copiez-le dans votre propre script et exécutez-le localement :
import requestsfrom bs4 import BeautifulSoup# 1. Fetch the page's HTML over the network (set a timeout; check the status)response = requests.get("https://example.com/store", timeout=10)response.raise_for_status()# 2. Parse the fetched HTML — identical to the in-memory examples abovesoup = BeautifulSoup(response.text, "html.parser")# 3. Extract with the same find / select callstitles = [h.get_text(strip=True) for h in soup.select(".card .name")]print(titles)
La seule ligne nouvelle est l’étape 1 : requests.get(url).text vous donne le HTML de la page sous forme de chaîne, qui s’écoule directement dans BeautifulSoup(..., "html.parser"). À partir de là, l’extraction est exactement ce que vous avez pratiqué plus haut. Remarquez que les bonnes habitudes de la leçon requests se reportent ici — un timeout= pour que la récupération ne puisse pas se bloquer, et raise_for_status() pour que vous n’analysiez jamais une page d’erreur comme si c’étaient les données.
Scraper poliment et légalement
Avant de pointer un scraper vers un site, vérifiez ce qu’il autorise et allez-y doucement — un script peut marteler un serveur bien plus vite qu’un humain ne le ferait jamais. Quelques habitudes vous gardent du bon côté :
Lisez le robots.txt et les conditions d’utilisation du site.robots.txt est un fichier situé à https://site.com/robots.txt dans lequel un site indique quels chemins les clients automatisés peuvent récupérer — le très suivi Robots Exclusion Protocol. Les conditions d’utilisation d’un site peuvent par ailleurs restreindre le scraping ou la réutilisation des données. La bibliothèque standard de Python fournit urllib.robotparser pour vérifier le robots.txt par programme.
Mettez un délai entre les requêtes. Un time.sleep(1) entre les récupérations vous évite de submerger le serveur — et d’être limité en débit ou bloqué.
Préférez une API officielle quand il en existe une. Elle est plus rapide, plus stable, et clairement autorisée — appelez-la avec requests au lieu de scraper.
Mettez en cache ce que vous récupérez pour ne pas retélécharger la même page chaque fois que vous ajustez votre code d’extraction.
Important
Ceci est une orientation générale, pas un conseil juridique. Qu’un scraping donné soit autorisé dépend des conditions du site, de la nature des données et de votre juridiction — autant d’éléments qui varient. En cas de doute sur un site ou un jeu de données précis, consultez ses conditions et sollicitez un avis qualifié.
Quand une IA écrit le scraper
Demandez à un assistant de code de « scraper les prix de cette page » et vous obtiendrez souvent du code qui trouve le bloc voulu puis découpe le texte à la main — text.split("$")[1][:4], ou un décalage de caractères fixe. Ça tourne sur l’exemple et a l’air correct, et c’est exactement la forme que cette leçon existe pour corriger. Le découpage de chaînes casse dès que le balisage bouge d’un espace ou que le prix gagne une virgule ; une ligne générée a aussi tendance à récupérer dans une boucle serrée sans aucun délai ni aucune vérification du robots.txt.
La compétence durable n’est pas de mémoriser BeautifulSoup — c’est d’être le juge de toute réponse, générée ou non. Quand vous recevez un extrait, vérifiez deux choses : sélectionne-t-il par un id ou une class stable (select_one(".price")) plutôt que par une chirurgie de chaînes fragile, et est-il poli (un délai, un coup d’œil au robots.txt) avant de récupérer un site en direct ? Exécutez-le sur la vraie page et relisez ce qu’il a extrait. Un sélecteur généré est un bon point de départ ; la version que vous livrez est celle qui survit au prochain petit changement du site.
🟢 Avec un agent IA
Vous avez une page à scraper, ou un extrait généré qui découpe des chaînes pour arriver aux données ? Collez le HTML et demandez à Prova« extrais ces champs avec BeautifulSoup en utilisant des sélecteurs CSS stables, pas du découpage de chaînes — et montre-moi une récupération polie avec requests » — puis exécutez-le contre la vraie page et relisez ce qu’il a tiré. Prova rédige les sélecteurs ; ce sont les valeurs extraites qui sont votre preuve, pas sa parole. The runtime is the judge. Demander à Prova →
Problèmes fréquents
find() a renvoyé None et ma ligne suivante a planté. Aucun élément n’a correspondu à votre recherche, donc find() a renvoyé None, et appeler .get_text() sur None lève une AttributeError. Deux causes : le tag, l’id ou la class diffère de ce que vous supposiez — ouvrez l’outil Inspecter de la page et confirmez les noms exacts — ou le contenu est chargé par JavaScript après l’arrivée de la page, donc il n’est pas dans le HTML que requests a récupéré (voir la FAQ ci-dessous). Protégez l’appel quand une correspondance est optionnelle : el = soup.find(...); if el: el.get_text().
Mon texte extrait a des espaces et des retours à la ligne en trop. Le HTML brut est indenté, donc le texte d’un élément porte les espaces qui l’entourent. Utilisez get_text(strip=True) au lieu de get_text() pour les supprimer — ou " ".join(el.get_text().split()) pour aussi réduire les suites d’espaces internes à un seul.
Mon scraper a cassé quand le site a changé sa mise en page. Vous avez sélectionné par un chemin positionnel fragile — une longue chaîne de tags, ou un index [3] dans une liste. Préférez un id ou une class stable (select_one("#price"), select(".product .name")) qui nomme ce que vous voulez, pas où il se trouve pour l’instant. Les id et les class sémantiques survivent aux petites refontes ; les chemins positionnels non.
Questions fréquentes
NoteComment scraper un site web en Python ?
Récupérez le HTML de la page avec requests et analysez-le avec BeautifulSoup : html = requests.get(url, timeout=10).text, puis soup = BeautifulSoup(html, "html.parser"). Trouvez les éléments voulus avec soup.find() / soup.find_all() (par tag, id=, class_=) ou soup.select() (un sélecteur CSS), extrayez le texte avec get_text(strip=True) et les attributs par indexation (a["href"]), et bouclez sur un bloc répété pour construire un enregistrement par élément. Avant de scraper un site en direct, consultez son robots.txt et ses conditions, et mettez un délai entre les requêtes.
NoteQu’est-ce que BeautifulSoup ?
BeautifulSoup (le paquet beautifulsoup4, importé sous le nom bs4) est une bibliothèque Python pour analyser le HTML et le XML — elle lit le balisage d’une page pour en faire un arbre navigable d’éléments que vous pouvez chercher avec find/find_all ou avec des sélecteurs CSS via select. Elle ne récupère pas les pages sur le réseau (associez-la à requests pour cela) et elle n’exécute pas JavaScript ; elle travaille sur le HTML que vous lui donnez. Installez-la avec pip install beautifulsoup4. Voir la documentation.
NoteQuelle est la différence entre BeautifulSoup, Scrapy et Selenium ?
Ils résolvent des parties différentes du problème. BeautifulSoup analyse le HTML que vous avez déjà — l’étape d’extraction — et s’associe à requests pour la récupération. Scrapy est un framework de scraping complet pour les gros crawls : il gère la récupération, le suivi des liens, la concurrence et les pipelines sur de nombreuses pages. Selenium (ou Playwright) pilote un vrai navigateur, il peut donc exécuter JavaScript et interagir avec une page — cliquer, faire défiler, remplir des formulaires — ce dont vous avez besoin quand le contenu n’est pas dans le HTML initial. Commencez par requests + BeautifulSoup ; recourez à Scrapy à l’échelle d’un crawl, et à Selenium seulement pour les pages rendues par JavaScript ou interactives.
NoteComment extraire un tableau d’un site web en Python ?
Deux façons. Pour un tableau bien formé, pandas.read_html(html) lit chaque tableau de la page dans une liste de DataFrames en un seul appel — choisissez celui que vous voulez par index. Pour un balisage plus désordonné ou quand vous avez besoin de quelque chose que la disposition du tableau cache (un lien dans une cellule), faites-le à la main avec BeautifulSoup : sélectionnez les lignes avec soup.select("table#id tr"), sautez l’en-tête avec une tranche [1:], et lisez les cellules de chaque ligne avec [td.get_text(strip=True) for td in tr.find_all("td")].
NoteLe web scraping est-il légal ?
Le web scraping est une technique neutre — la légalité dépend de ce que vous scrapez et de comment, pas de l’outil. Des données publiques et factuelles récupérées poliment présentent généralement moins de risque ; scraper des données personnelles, du contenu protégé par le droit d’auteur, ou des chemins que le robots.txt ou les conditions d’utilisation d’un site interdisent, non. Consultez toujours le robots.txt et les conditions du site, limitez le débit de vos requêtes, et préférez une API officielle quand il en existe une. Ceci est une information générale, pas un conseil juridique — les règles varient selon la juridiction et selon le site.
Testez vos connaissances
ImportantÀ vous : extraire une liste d’enregistrements
On vous donne cette page en mémoire. Analysez-la, sélectionnez les trois cartes de livres, et construisez une liste de dicts avec un title (chaîne) et une year numérique pour chacune.
Analysez avec BeautifulSoup(html, "html.parser"), puis select("div.book") pour obtenir le conteneur répété. Bouclez sur l’ensemble et, à l’intérieur de la boucle, sélectionnez chaque champ depuis la carte avec select_one(".title") et select_one(".year"). Utilisez get_text(strip=True) pour le texte, et enveloppez l’année dans int().
Sélectionnez l’ensemble, bouclez dessus, et extrayez un champ par carte avec le select_one() singulier — en sélectionnant depuis card, pas depuis soup, pour que les champs de chaque enregistrement restent ensemble. Le même motif que les cartes produit ci-dessus.
Vérification rapide. Vous exécutez soup.select_one(".price") sur une page avec cinq éléments .price. Combien d’éléments reviennent — et comment obtiendriez-vous les cinq ?
AstuceAfficher la réponse
Un — select_one() ne renvoie que le premier élément correspondant (ou None s’il n’y a pas de correspondance). Pour obtenir les cinq, utilisez select(".price"), qui renvoie une liste de toutes les correspondances. La même distinction singulier/pluriel s’applique à find() (premier) face à find_all() (tous).
Conclusion
Scraper une page en Python est une boucle courte et répétable : analysez le HTML avec BeautifulSoup(html, "html.parser"), trouvez les éléments voulus (find/find_all par tag et class, ou select/select_one avec un sélecteur CSS), et extrayez les données — le texte avec get_text(strip=True), les attributs par indexation (a["href"]), un tableau en lisant ses lignes, un bloc répété en une liste de dicts. Pour scraper un vrai site, récupérez son HTML avec requests et confiez le texte au même appel d’analyse — puis faites-le poliment : consultez le robots.txt et les conditions, et espacez vos requêtes. Parce que les mécanismes présentés ici tournent sur un document en mémoire, chaque exemple fondamental est reproductible par copier-coller — remplacez la chaîne par requests.get(url).text et le même code scrape le web en direct.