Scraper des tableaux depuis un site webGoogle Sheets, Python ou R

Les tableaux HTML sont la façon dont le web stocke ses données les plus prêtes à l'analyse : cours boursiers, classements sportifs, chiffres de population, comparatifs de produits, archives historiques. Un tableau sur une page publique est déjà sous forme de lignes et de colonnes, donc la partie difficile est rarement l'analyse. C'est d'extraire les données de la page et de les placer dans un outil avec lequel vous pouvez travailler, proprement et de façon répétable, sans copier les cellules à la main.

Ce guide vous montre trois façons de scraper des tableaux depuis un site web, chacune adaptée à un niveau de compétence et à un flux de travail différents : une formule Google Sheets sans code, quelques lignes de Python avec pandas, et un script R avec rvest. L'exemple fil conducteur est un tableau Wikipedia public, qui convient bien parce que les données sont ouvertes et le balisage est propre. Chaque méthode reste limitée aux données publiques, et la courte section sur le scraping responsable près de la fin vaut la peine d'être lue avant de pointer ceci sur une source réelle.

Ce que vous allez construire

À la fin, vous disposerez de trois façons fonctionnelles d'extraire un tableau public dans un format utilisable. Chacune cible le même type de source, un <table> HTML sur une page publique, et produit le même type de résultat, une grille ordonnée que vous pouvez trier, filtrer ou exporter. Les éléments que vous obtiendrez sont :

• Une formule Google Sheets qui importe un tableau en direct avec un seul appel IMPORTHTML, sans aucun code.
• Un script Python qui lit les tableaux avec pandas.read_html en une ligne, avec un repli sur BeautifulSoup pour les balisages désordonnés.
• Un script R qui extrait les tableaux avec html_table de rvest dans un data frame.
• Une sortie tabulaire propre de chaque méthode, prête à exporter en CSV ou à alimenter une analyse.

Pourquoi certains tableaux nécessitent plus qu'une requête simple

Pour une page propre rendue côté serveur comme la plupart de Wikipedia, les trois méthodes ci-dessous fonctionnent directement : le balisage du tableau est déjà dans le HTML, donc une formule ou une lecture en une ligne l'extrait directement. C'est le cas facile et courant, et c'est là que vous devez commencer.

Les problèmes surgissent sur les sources qui ne vous donnent pas le tableau aussi facilement. Deux problèmes apparaissent le plus souvent. Premièrement, certains sites construisent leurs tableaux avec JavaScript après le chargement de la page, donc le HTML brut que vous récupérez est dépourvu des lignes que vous cherchiez. Deuxièmement, de nombreux sites surveillent le trafic aux allures de scraper et limitent le débit ou challengent les requêtes provenant d'adresses IP de centres de données après la première poignée. Quand l'un ou l'autre se produit, IMPORTHTML retourne une erreur, et un simple requests.get en Python retourne une page de blocage ou un balisage vide au lieu du tableau.

La solution pour les deux est la même : récupérer la page via un navigateur qui exécute ses scripts, depuis une adresse IP que le site perçoit comme un vrai visiteur. Vous pouvez assembler cela vous-même avec un pool d'IP rotatif et un navigateur sans interface graphique, mais c'est l'essentiel du travail. Dans la section Python nous utilisons la Crawling API précisément pour ces sources bloquées ou rendues par JavaScript, tout en gardant la voie simple pour tout ce qui n'en a pas besoin.

Prérequis

Ce dont vous avez besoin dépend de la méthode que vous choisissez. Aucune ne prend longtemps à configurer.

Pour Google Sheets : juste un compte Google et un navigateur. Rien à installer.

Pour Python : Python 3.8 ou version ultérieure. Vérifiez votre version avec python --version. Vous devez être à l'aise pour exécuter un script et installer des paquets avec pip. Si l'analyse HTML est nouvelle pour vous, notre guide sur l'utilisation de BeautifulSoup en Python couvre les bases que cette section suppose.

Pour R : une installation R récente (4.0 ou ultérieure convient) et la capacité d'installer des paquets depuis CRAN.

Pour les sources bloquées ou rendues par JavaScript : un compte Crawlbase et un token. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token normal. Traitez le token comme un mot de passe et ne le mettez pas dans le contrôle de version. Vous n'en avez besoin que pour la voie Python quand une requête simple échoue.

Méthode 1 : Google Sheets avec IMPORTHTML

La façon la plus rapide d'extraire un tableau d'une page publique ne nécessite aucun code. Google Sheets possède une fonction intégrée IMPORTHTML qui récupère une page, trouve un tableau ou une liste par index et le dépose dans votre feuille sous forme de cellules actives. Elle se rafraîchit même d'elle-même, de sorte que les données restent à jour.

Ouvrez une nouvelle feuille, cliquez sur une cellule vide et entrez la formule. Elle prend trois arguments : l'URL de la page, si vous voulez un "table" ou une "list", et l'index de celui à saisir (le premier tableau de la page est 1, le deuxième est 2, et ainsi de suite).

=IMPORTHTML("https://en.wikipedia.org/wiki/List_of_largest_cities", "table", 1)

Appuyez sur Entrée et Sheets récupère la page, extrait le premier tableau et le répartit sur les cellules à partir de là où vous avez tapé la formule. Si le premier tableau n'est pas celui que vous cherchez, augmentez l'index jusqu'à le trouver ; une page a souvent des tableaux de navigation ou d'infobox avant les données principales. Une fois les données en place, vous pouvez redimensionner les colonnes ou reformater les cellules, et vous pouvez laisser la formule en place pour que la feuille se rafraîchisse quand la source change.

Méthode 2 : Python avec pandas et la Crawling API

Python est le cheval de bataille pour cela. Pour un tableau public propre, pandas.read_html fait presque tout en une ligne : donnez-lui une URL ou un fragment de HTML et il retourne une liste de chaque tableau sur la page sous forme de data frames. Commencez par installer les bibliothèques.

python -m venv tables_env
source tables_env/bin/activate

pip install pandas lxml beautifulsoup4 crawlbase

Sous Windows, activez l'environnement avec tables_env\Scripts\activate à la place de la ligne source. pandas effectue la lecture du tableau, lxml est l'analyseur qu'il utilise en arrière-plan, beautifulsoup4 est le repli pour les balisages désordonnés, et crawlbase est le client officiel pour la Crawling API.

Pour une page publique rendue côté serveur, la version la plus simple est réellement un seul appel. Passez l'URL à read_html et indexez dans la liste qu'elle retourne.

import pandas as pd

url = "https://en.wikipedia.org/wiki/List_of_largest_cities"

# read_html returns a list of every table it finds on the page
tables = pd.read_html(url)
print(f"Found {len(tables)} tables")

# pick the one you want by index, then work with it as a DataFrame
df = tables[0]
print(df.head())
df.to_csv("cities.csv", index=False)

C'est tout le travail quand la page coopère : read_html scanne le HTML, construit un data frame pour chaque <table>, et vous gardez celui que vous voulez et l'écrivez en CSV. Tout comme l'index de Sheets, vous devrez peut-être essayer quelques indices pour trouver le tableau principal plutôt qu'une barre latérale ou un bloc de navigation.

Quand la source bloque les requêtes simples ou construit son tableau avec JavaScript, récupérez d'abord le HTML via la Crawling API, puis passez ce HTML à read_html. Le seul changement est l'origine du balisage.

import pandas as pd
from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

def fetch_html(url, render=False):
    options = {"country": "US"}
    if render:
        # use the JS token for JavaScript-built tables
        options["ajax_wait"] = "true"
    response = api.get(url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

url = "https://en.wikipedia.org/wiki/List_of_largest_cities"
html = fetch_html(url)

if html:
    tables = pd.read_html(html)
    df = tables[0]
    print(df.head())
    df.to_csv("cities.csv", index=False)

L'option country fixe la requête sur une adresse IP de sortie aux États-Unis, et passer render=True indique à l'appel d'utiliser un token JavaScript (ici via ajax_wait) pour que la page soit rendue avant que vous ne receviez le HTML. Le balisage en main, read_html se comporte exactement comme avant. C'est la version à utiliser dès que la voie simple retourne une page de blocage ou une liste de tableaux vide.

Repli sur BeautifulSoup pour les tableaux désordonnés

Parfois read_html échoue : un tableau avec des cellules fusionnées, pas de vraie balise <table>, ou des lignes dispersées dans un balisage imbriqué inhabituel. Dans ce cas, descendez sur BeautifulSoup et construisez les lignes vous-même en lisant chaque cellule. C'est la même approche champ par champ que notre guide sur les sélecteurs CSS, appliquée aux cellules de tableau.

import pandas as pd
from bs4 import BeautifulSoup

def table_to_rows(html, index=0):
    soup = BeautifulSoup(html, "html.parser")
    table = soup.find_all("table")[index]
    rows = []
    for tr in table.find_all("tr"):
        cells = tr.find_all(["th", "td"])
        row = [cell.get_text(strip=True) for cell in cells]
        if row:
            rows.append(row)
    return rows

rows = table_to_rows(html)
df = pd.DataFrame(rows[1:], columns=rows[0])
print(df.head())

L'aide parcourt chaque <tr>, lit chaque <th> et <td> comme texte épuré et ignore les lignes vides. Traiter la première ligne comme l'en-tête et le reste comme des données vous donne un data frame propre même quand read_html ne pouvait pas analyser le tableau seul. Passez le même HTML de la Crawling API à cet aide quand le tableau désordonné est aussi bloqué ou rendu.

Méthode 3 : R avec rvest

Si votre analyse se trouve déjà dans R, vous n'avez pas besoin de le quitter. Le paquet rvest lit le HTML et sa fonction html_table transforme chaque tableau d'une page en data frame, un peu comme pandas. Installez le paquet une fois depuis votre console R.

install.packages("rvest")

Avec rvest chargé, lisez la page, extrayez ses tableaux et choisissez celui que vous voulez. Le modèle reflète celui de Python : lire le HTML, obtenir une liste de tableaux, indexer dans celle-ci.

library(rvest)

url <- "https://en.wikipedia.org/wiki/List_of_largest_cities"

# read the page, then pull every table into a list of data frames
page <- read_html(url)
tables <- page %>% html_elements("table") %>% html_table()

# keep the first table and inspect it
df <- tables[[1]]
head(df)

# write it out for analysis elsewhere
write.csv(df, "cities.csv", row.names = FALSE)

R utilise des doubles crochets, tables[[1]], pour extraire un seul élément de la liste, là où Python utilise des crochets simples. À part cela, le flux est identique : lire la page, collecter les tableaux, garder celui dont vous avez besoin et l'exporter. À partir de là, le data frame se comporte comme n'importe quel autre dans R, prêt pour dplyr, ggplot2 ou un export CSV. Si la source bloque la lecture directe, récupérez le HTML rendu via la Crawling API comme dans la section Python et passez cette chaîne à read_html à la place de l'URL.

À quoi ressemble le résultat

Quelle que soit la méthode utilisée, le résultat a la même forme : une grille propre avec une ligne d'en-tête et une ligne par enregistrement. Exporté en CSV, le tableau des plus grandes villes ressemble à ceci.

Rank,City,Country,Population,Year
1,Tokyo,Japan,37468000,2018
2,Delhi,India,28514000,2018
3,Shanghai,China,25582000,2018
4,Sao Paulo,Brazil,21650000,2018
5,Mexico City,Mexico,21581000,2018

Les colonnes exactes dépendent du tableau source, mais la structure est cohérente : l'en-tête devient vos noms de colonnes et chaque ligne suivante est un enregistrement. Depuis un CSV comme celui-ci, vous pouvez charger directement dans une feuille de calcul, un notebook ou une base de données sans aucun nettoyage supplémentaire au-delà de l'occasionnelle conversion de type.

Scraper des tableaux de façon responsable

Les méthodes ci-dessus sont faciles à exécuter, ce qui rend utile d'être délibéré sur les endroits où vous les pointez. Vérifiez les conditions d'utilisation de chaque source et son fichier robots.txt avant de collecter quoi que ce soit à volume, et préférez les données véritablement publiques, le genre qu'un visiteur voit sans se connecter, plutôt que tout ce qui se trouve derrière un compte ou un paywall. Espacez vos requêtes pour ne pas marteler un serveur dans une boucle serrée, et appuyez-vous sur une API officielle ou un jeu de données publié quand la source en propose un, car c'est presque toujours la voie plus légère et plus fiable.

Si vous republiez un tableau que vous avez scrapé, citez la source et respectez sa licence. Les jeux de données ouverts comme Wikipedia comportent des conditions de réutilisation claires (attribution sous licence Creative Commons, dans ce cas), et de nombreux autres sites ne permettent pas du tout la redistribution. Collecter des chiffres publics pour votre propre analyse est un usage bien plus léger que republier les données compilées de quelqu'un d'autre comme si elles étaient les vôtres, donc en cas de doute, faites un lien vers la source plutôt que de la copier intégralement.

Foire aux questions

Quelle est la façon la plus simple de scraper un tableau depuis un site web ?

Pour une page publique rendue côté serveur, Google Sheets est la plus simple. Tapez =IMPORTHTML(url, "table", 1) dans une cellule et Sheets récupère la page et dépose le premier tableau dans votre feuille de calcul sous forme de cellules actives, sans aucun code. Cela fonctionne pour toute page dont le tableau est présent dans le HTML brut, et cela se rafraîchit tout seul.

Pourquoi IMPORTHTML retourne-t-il #N/A ou un résultat vide ?

IMPORTHTML lit le HTML brut et n'exécute pas JavaScript, donc il ne peut pas voir les tableaux qu'une page construit avec des scripts après le chargement. Il échoue également quand le site bloque la requête. Dans les deux cas, passez à la méthode Python et récupérez la page via la Crawling API, qui peut rendre la page dans un vrai navigateur et la demander depuis une adresse IP de confiance avant d'analyser.

Comment scraper un tableau avec Python ?

La voie la plus courte est pandas.read_html(url), qui retourne une liste de data frames, un par tableau sur la page. Indexez dans la liste pour garder celui que vous voulez et exportez-le avec to_csv. Pour les sources qui bloquent les requêtes simples ou rendent les tableaux avec JavaScript, récupérez d'abord le HTML via la Crawling API et passez ce balisage à read_html à la place de l'URL.

Comment scraper un tableau dans R ?

Installez rvest, lisez la page avec read_html, puis exécutez html_elements("table") %>% html_table() pour obtenir une liste de tableaux sous forme de data frames. Choisissez-en un avec l'indexation à double crochets, comme tables[[1]], et exportez-le avec write.csv. Le flux reflète presque exactement l'approche pandas.

Que faire si pandas read_html ne peut pas analyser le tableau ?

Certains tableaux ont des cellules fusionnées, des balises <table> manquantes ou des lignes imbriquées dans un balisage inhabituel que read_html ne peut pas gérer. Repliez-vous sur BeautifulSoup : parcourez chaque <tr>, lisez chaque <th> et <td> comme texte et construisez les lignes vous-même dans un data frame. Cela vous donne un contrôle total sur la façon dont chaque cellule est interprétée.

Comment scraper des tableaux depuis un site qui me bloque ?

Les sites qui limitent le débit ou challengent le trafic automatisé ont besoin d'une requête qui ressemble à un vrai visiteur. Acheminez la récupération via des adresses IP résidentielles rotatives pour qu'aucune adresse unique ne déclenche une limite, et rendez JavaScript quand le tableau est construit côté client. La Crawling API gère les deux en un seul appel ; une fois que vous avez le HTML retourné, analysez-le avec pandas, BeautifulSoup ou rvest exactement comme vous le feriez avec n'importe quelle autre page.

HR

Hassan Rehan

Ingénieur logiciel · Crawlbase

Ingénieur logiciel chez Crawlbase, il rédige des guides pratiques sur les proxys rotatifs, le scraping et les détails concrets de l'intégration de proxys dans du vrai code.