Comment scraper des tableaux Wikipediades tableaux aux DataFrames avec Python

Wikipedia contient une grande partie de ses données les plus utiles dans des tableaux : listes de pays par superficie, chiffres de population, classements sportifs, chronologies historiques, et des milliers d'autres grilles triables. Ces données tabulaires sont publiques et bien structurées, ce qui en fait une excellente matière première pour la recherche et l'analyse, mais copier cellule par cellule dans un tableur ne passe pas à l'échelle au-delà d'un ou deux tableaux.

Ce guide vous montre comment scraper des tableaux Wikipedia avec Python de façon propre. Vous construisez un petit script exécutable qui récupère un article via la Crawling API, localise le tableau souhaité, l'analyse directement dans un DataFrame pandas, le nettoie, et exporte un CSV ordonné. Le tutoriel reste limité aux données tabulaires publiques, et la section légalité vers la fin couvre la licence CC-BY-SA de Wikipedia et les chemins d'accès en masse sanctionnés, donc lisez-la avant de pointer ceci vers de nombreux articles. Cet article porte spécifiquement sur les tableaux ; pour les titres de pages, les images, et les champs d'infobox, voir le guide complémentaire sur comment scraper Wikipedia.

Ce que vous allez construire

Un script Python qui prend l'URL d'un article Wikipedia public, récupère le HTML rendu via la Crawling API, sélectionne un tableau spécifique par sa classe CSS, le lit dans un DataFrame pandas, nettoie les colonnes, et écrit le résultat en CSV. L'exemple en cours est l'article « Liste des pays et dépendances par superficie ». L'enregistrement de sortie contient ces champs par ligne :

• Rank la position de la ligne dans le tableau source quand elle est présente.
• Country / dependency le nom tel qu'il apparaît dans la cellule du tableau.
• Total area le chiffre de superficie en kilomètres carrés et miles carrés.
• Land area la superficie terrestre uniquement quand le tableau la distingue.
• Water area la superficie en eau et son pourcentage du total.
• Notes toute colonne de note ou d'annotation que le tableau comporte.

Comprendre la structure des tableaux Wikipedia

Les tableaux Wikipedia sont écrits dans un mélange de HTML et de wikitext, mais au moment où la page atteint votre scraper ils ont été rendus en éléments ordinaires <table>, <tr>, <th>, et <td> avec des lignes d'en-tête et des cellules de données.

Le détail qui compte le plus pour le scraping est la classe CSS. La plupart des tableaux de données portent la classe wikitable, qui applique le style bordé standard que vous voyez dans les articles. Cette classe partagée est votre ancre : elle vous permet de sélectionner les tableaux de données et d'ignorer les tableaux de mise en page ou de navigation sur la même page, et les tableaux triables ajoutent une classe sortable comme indice supplémentaire de données en colonnes propres. Un article contient souvent plusieurs tableaux, donc vous réduirez généralement par classe, par texte de légende, ou par index une fois que vous savez lequel vous voulez.

Pourquoi une requête simple peut être insuffisante

Pour un article, une simple requête HTTP retourne du HTML utilisable, car Wikipedia sert le contenu des articles côté serveur. Le problème apparaît en volume : récupérez des dizaines ou des centaines d'articles dans une boucle serrée depuis une seule IP de datacenter et vous ne ressemblez en rien à un lecteur normal, ce qui est exactement le schéma de trafic que les limites de débit et les défenses bot sont conçues pour ralentir. Vous pouvez aussi rencontrer des blocages transitoires ou des réponses partielles qui cassent silencieusement une exécution sans surveillance.

Router les requêtes via la Crawling API lisse les deux. Elle récupère chaque page derrière un pool rotatif d'IPs de confiance, de sorte qu'un crawl plus large se répartit sur de nombreuses adresses plutôt que de marteler une seule, et retourne du HTML fini que vous pouvez directement passer à un analyseur. Pour la vue d'ensemble, voir comment scraper des sites sans se faire bloquer.

Prérequis

Quelques éléments doivent être en place avant d'écrire du code. Aucun ne prend longtemps.

Python de base. Vous devez être à l'aise pour écrire et exécuter un script Python et installer des packages avec pip. Si vous êtes nouveau du côté de l'analyse, le guide BeautifulSoup se marie bien avec ce tutoriel.

Python 3.8 ou supérieur. Confirmez votre version avec python --version. Si vous ne l'avez pas, installez-le depuis python.org ou via une distribution comme Anaconda, et assurez-vous que Python est dans votre PATH.

Un compte et un token Crawlbase. Inscrivez-vous, ouvrez votre tableau de bord, et copiez votre token normal depuis la page de documentation du compte. Crawlbase inclut jusqu'à 20 000 requêtes gratuites pour commencer, ce qui est largement suffisant pour parcourir ce guide. Traitez le token comme un mot de passe : il authentifie vos requêtes, donc gardez-le hors du contrôle de version.

Configurer le projet

Créez un environnement virtuel pour que les dépendances du projet restent isolées, puis installez les bibliothèques dont le scraper a besoin.

python --version

python -m venv wiki_env
source wiki_env/bin/activate

pip install crawlbase beautifulsoup4 pandas lxml

Sur Windows, activez l'environnement avec wiki_env\Scripts\activate au lieu de la ligne source. Quatre dépendances font le travail : crawlbase est le client officiel pour la Crawling API, beautifulsoup4 isole le tableau exact que vous voulez, pandas lit ce tableau dans un DataFrame et exporte le CSV, et lxml est l'analyseur HTML rapide que pandas utilise en coulisses pour read_html. Le module csv est livré avec la bibliothèque standard, donc rien de plus à installer pour l'étape d'export.

Étape 1 : Récupérer un article Wikipedia rendu

Commencez par obtenir le HTML de l'article. Importez la classe CrawlingAPI, initialisez-la avec votre token, demandez l'URL de l'article, et vérifiez le statut de la réponse avant d'analyser. Vérifier le status_code de Crawlbase en premier garde les échecs visibles plutôt que silencieux.

from crawlbase import CrawlingAPI

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

def crawl(page_url):
    response = api.get(page_url)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    article_url = "https://en.wikipedia.org/wiki/List_of_countries_and_dependencies_by_area"
    html = crawl(article_url)
    print(html[:500] if html else "No HTML returned")

Exécutez le script avec python wikipedia_scraper.py et vous devriez voir le vrai balisage de l'article dans les 500 premiers caractères, ce qui confirme que la récupération fonctionne avant d'écrire un sélecteur. La fonction crawl retourne du HTML décodé sur un statut 200 et None sinon, de sorte que le reste du script peut se protéger sur un retour faux plutôt que de planter sur une mauvaise réponse.

Étape 2 : Localiser le tableau souhaité

Un article contient généralement plusieurs tableaux, donc l'étape suivante consiste à sélectionner le bon. Chargez le HTML dans BeautifulSoup et utilisez select_one avec la classe wikitable pour obtenir le premier tableau de données. Quand une page a de nombreux wikitables, passez à select et indexez celui que vous voulez, ou filtrez par le texte de légende du tableau.

from bs4 import BeautifulSoup

def find_table(html, index=0):
    soup = BeautifulSoup(html, "html.parser")
    tables = soup.select("table.wikitable")
    if not tables:
        print("No wikitable found on this page.")
        return None
    print(f"Found {len(tables)} wikitable(s); using index {index}.")
    return tables[index]

Le helper find_table retourne un élément <table> rendu, ou None avec un message clair si la page n'a pas de wikitable. L'argument index vous permet de cibler le deuxième ou troisième tableau de données sur les articles plus chargés sans réécrire le sélecteur. Afficher le compte des tableaux est un petit détail qui vous dit, dès la première exécution, si vous visez le tableau attendu.

Étape 3 : Analyser le tableau dans un DataFrame

Avec l'élément tableau en main, pandas fait le travail lourd. Passez le HTML du tableau à pandas.read_html, qui retourne une liste de DataFrames ; comme vous avez isolé un seul tableau, vous prenez le premier élément. C'est le cœur du scraping de tableaux : une fonction transforme les lignes et cellules HTML rendues en un DataFrame typé et en colonnes.

import pandas as pd
from io import StringIO

def table_to_df(table):
    frames = pd.read_html(StringIO(str(table)))
    if not frames:
        return None
    df = frames[0]
    print(f"Parsed table with {df.shape[0]} rows and {df.shape[1]} columns.")
    return df

Envelopper str(table) dans StringIO correspond à la façon dont pandas actuel s'attend à recevoir du HTML passé à read_html, et cela garde la fonction sans avertissements de dépréciation. La forme affichée est votre vérification de sanité : si les comptes de lignes et de colonnes correspondent à ce que vous voyez dans l'article, l'analyse a atterri sur le bon tableau. Si vous préférez parcourir les lignes vous-même, vous pouvez boucler sur table.select("tr") avec BeautifulSoup et lire chaque cellule th et td à la main, mais read_html est plus rapide et gère la détection des en-têtes pour vous.

Étape 4 : Nettoyer le DataFrame

Les tableaux Wikipedia bruts viennent avec des particularités : en-têtes de colonnes multi-niveaux, marqueurs de notes de bas de page dans les cellules, colonnes vides, et artefacts de cellules fusionnées. Une courte passe de nettoyage transforme le frame analysé en quelque chose prêt pour l'analyse avant de l'exporter.

def clean_df(df):
    # Flatten multi-level headers into single strings.
    if isinstance(df.columns, pd.MultiIndex):
        df.columns = [" ".join(str(p) for p in col if "Unnamed" not in str(p)).strip()
                      for col in df.columns]

    # Strip footnote markers like [1] and [a] from string cells.
    df = df.replace(r"\[.*?\]", "", regex=True)

    # Drop fully empty rows and columns.
    df = df.dropna(axis=0, how="all").dropna(axis=1, how="all")

    # Trim surrounding whitespace on string cells.
    for col in df.select_dtypes(include="object").columns:
        df[col] = df[col].astype(str).str.strip()

    return df.reset_index(drop=True)

Chaque étape cible un problème réel. Aplatir un MultiIndex transforme les lignes d'en-têtes imbriqués en noms de colonnes lisibles uniques et supprime les espaces réservés Unnamed que pandas insère pour les cellules d'en-tête vides. Le remplacement par regex supprime les marqueurs de notes de bas de page entre crochets que Wikipedia saupoudre dans les cellules, comme [1] ou [a], qui pollueraient sinon les colonnes numériques. Supprimer les lignes et colonnes entièrement vides élimine les artefacts de cellules fusionnées, et le strip final supprime les espaces blancs parasites. Adaptez les étapes au tableau devant vous ; tous les tableaux n'ont pas besoin de toutes les passes.

Étape 5 : Assembler le script complet

Assemblez maintenant les pièces en un seul script exécutable : récupérer l'article, isoler le tableau, l'analyser, le nettoyer, et exporter en CSV.

from io import StringIO

import pandas as pd
from bs4 import BeautifulSoup
from crawlbase import CrawlingAPI

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

def crawl(page_url):
    response = api.get(page_url)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

def find_table(html, index=0):
    soup = BeautifulSoup(html, "html.parser")
    tables = soup.select("table.wikitable")
    if not tables:
        return None
    return tables[index]

def table_to_df(table):
    frames = pd.read_html(StringIO(str(table)))
    return frames[0] if frames else None

def clean_df(df):
    if isinstance(df.columns, pd.MultiIndex):
        df.columns = [" ".join(str(p) for p in col if "Unnamed" not in str(p)).strip()
                      for col in df.columns]
    df = df.replace(r"\[.*?\]", "", regex=True)
    df = df.dropna(axis=0, how="all").dropna(axis=1, how="all")
    for col in df.select_dtypes(include="object").columns:
        df[col] = df[col].astype(str).str.strip()
    return df.reset_index(drop=True)

def main():
    article_url = "https://en.wikipedia.org/wiki/List_of_countries_and_dependencies_by_area"
    html = crawl(article_url)
    if not html:
        return

    table = find_table(html, index=0)
    if table is None:
        print("No table found.")
        return

    df = table_to_df(table)
    if df is None:
        print("Table could not be parsed.")
        return

    df = clean_df(df)
    df.to_csv("wikipedia_table.csv", index=False)
    print(f"Saved {df.shape[0]} rows to wikipedia_table.csv")
    print(df.head())

if __name__ == "__main__":
    main()

Le script récupère l'article, isole le premier wikitable, l'analyse dans un DataFrame, effectue la passe de nettoyage, et écrit wikipedia_table.csv avec une ligne d'en-tête et sans colonne d'index. Afficher df.head() à la fin vous donne un aperçu instantané dans le terminal. Pour cibler un article différent ou un tableau différent sur la même page, changez article_url et l'argument index de find_table.

À quoi ressemble le résultat

Exécutez le script complet avec python wikipedia_scraper.py et vous obtenez un CSV propre, une ligne par ligne de tableau, prêt pour pandas, une base de données, ou un tableur.

Rank,Country / dependency,Total area (km2),Total area (mi2),Land,Water,Notes
,World,510072000,196940000,148940000,361132000,
1,Russia,17098246,6601665,16376870,721391,
2,Antarctica,14200000,5500000,14200000,0,
3,Canada,9984670,3855100,9093507,891163,
4,China,9596961,3705407,9326410,270550,
5,United States,9525067,3677649,9147593,377424,

Les colonnes s'alignent avec le tableau source, les marqueurs de notes de bas de page sont supprimés, et les chiffres sont assez propres pour être chargés directement dans pandas pour le filtrage, le tri, ou la jointure avec d'autres jeux de données. Substituez n'importe quel article avec un wikitable et les cinq mêmes fonctions produisent le même résultat ordonné.

Passer à l'échelle sur de nombreux articles

Extraire un tableau est le bloc de construction. Pour collecter le même tableau sur de nombreux articles, enveloppez les cinq fonctions dans une boucle sur une liste d'URLs, espacez avec un court délai, et concaténez les frames nettoyés. Quelques habitudes maintiennent une exécution plus longue en bonne santé.

• Espacez vos requêtes. Ajoutez un court délai entre les requêtes et gardez le volume raisonnable, surtout envers une ressource gérée par une communauté comme Wikipedia.
• Appuyez-vous sur la rotation. Router chaque récupération via la Crawling API répartit les requêtes sur de nombreuses IPs, de sorte qu'un crawl plus large ne se concentre pas sur une adresse.
• Préférez les chemins en masse sanctionnés. Pour les grands volumes, l'API Wikipedia et les dumps de base de données officiels sont la route prévue et chargent bien moins le site en direct que le scraping, comme couvert dans la section suivante.

Pour les crawls plus importants, le Crawler async met les requêtes en file d'attente et livre les résultats vers un webhook, ce qui convient à l'exécution de nombreux articles sans maintenir des connexions ouvertes. Pour pousser les tableaux nettoyés dans un entrepôt, l'approche de web scraping vers SQL s'applique directement depuis les DataFrames que vous construisez ici.

Est-il légal de scraper Wikipedia ?

Scraper des tableaux Wikipedia publics à des fins de recherche ou d'analyse est généralement acceptable, mais la partie importante est la licence, pas seulement l'accès. Le contenu textuel de Wikipedia est publié sous la licence Creative Commons Attribution-ShareAlike (CC-BY-SA) : vous êtes libre de le réutiliser et l'adapter à condition d'attribuer la source et de partager tout travail dérivé sous la même licence. Si vous publiez ou redistribuez un tableau que vous avez extrait, créditez Wikipedia et liez l'article dont vous l'avez tiré, et gardez la condition de même licence en tête pour tout ce que vous construisez dessus. Le scraping ne supprime pas ces termes ; il déplace seulement les données.

Restez dans quelques lignes sensées. Respectez les Conditions d'utilisation de Wikipedia et son robots.txt, gardez votre taux de requêtes bas pour ne pas surcharger les serveurs d'une organisation à but non lucratif, et limitez-vous aux tableaux et autres contenus publics plutôt que de republier des articles entiers. Ce guide est limité aux données tabulaires pour exactement cette raison : c'est la tranche la plus utile à réutiliser et la plus facile à attribuer proprement.

Quand vous avez besoin de données en volume, le scraping est généralement le mauvais outil. La Wikimedia Foundation fournit des chemins sanctionnés conçus pour cela : l'API MediaWiki officielle pour les requêtes structurées, et les dumps de base de données périodiques pour le téléchargement en masse de wikis entiers. Ceux-ci chargent bien moins le site en direct, vous donnent des données plus propres, et sont la route que le projet invite explicitement pour un usage intensif. Utilisez-les en premier, et traitez le scraping en direct comme l'option pour les travaux ponctuels ou de petite taille où un dump serait excessif.

Foire aux questions

Comment extraire un tableau spécifique d'une page Wikipedia ?

Sélectionnez-le par classe CSS avec BeautifulSoup. La plupart des tableaux de données portent la classe wikitable, donc soup.select("table.wikitable") retourne chaque tableau de données sur la page ; indexez celui que vous voulez et passez son HTML à pandas.read_html. Quand plusieurs tableaux partagent la classe, réduisez par index ou par le texte de légende du tableau, comme le montre le helper find_table dans ce guide.

Devrais-je utiliser pandas read_html ou BeautifulSoup pour analyser le tableau ?

Les deux, en séquence. Utilisez BeautifulSoup pour isoler le <table> exact que vous voulez par classe, puis passez cet élément unique à pandas.read_html pour le transformer en DataFrame. Passer toute la page à read_html fonctionne aussi, mais retourne une liste avec chaque tableau de la page, y compris les barres latérales, ce qui vous laisse à deviner les index.

Pourquoi router les requêtes Wikipedia via la Crawling API ?

Pour un seul article, vous n'en avez peut-être pas besoin, car Wikipedia sert le contenu côté serveur. La valeur apparaît en volume : récupérer de nombreux articles depuis une seule IP de datacenter ressemble à un bot et invite à une limitation et des blocages transitoires. La Crawling API fait tourner des IPs de confiance et retourne du HTML fini, de sorte qu'un crawl plus large se répartit sur de nombreuses adresses.

Est-il légal de scraper des tableaux Wikipedia ?

Scraper des tableaux publics à des fins de recherche est généralement acceptable, mais le contenu Wikipedia est sous licence CC-BY-SA, donc si vous republiez un tableau vous devez attribuer la source et partager le travail dérivé sous la même licence. Respectez les Conditions d'utilisation et robots.txt, gardez votre taux bas, et limitez-vous aux tableaux plutôt que de redistribuer des articles entiers. Pour les besoins en masse, l'API Wikipedia et les dumps de base de données sont le chemin sanctionné.

Comment sauvegarder le tableau scrapé en CSV ?

Une fois que le tableau est un DataFrame, appelez df.to_csv("wikipedia_table.csv", index=False). L'argument index=False empêche pandas d'écrire son index de ligne comme colonne supplémentaire, de sorte que vous obtenez une ligne d'en-tête propre et une ligne par ligne de tableau. À partir de là, le CSV se recharge directement dans pandas ou n'importe quel tableur.

En quoi cela diffère-t-il du guide général de scraping Wikipedia ?

Ce tutoriel est limité aux tableaux : sélectionner un wikitable, l'analyser avec pandas, nettoyer les colonnes, et exporter en CSV. Le guide complémentaire sur comment scraper Wikipedia couvre la page plus large, comme le titre, les images, et les champs d'infobox. Utilisez celui-ci quand votre cible est des données en colonnes et l'autre quand vous avez besoin d'autres parties d'un article.

FA

Farwa Anees

Rédactrice technique · Crawlbase

Rédactrice technique ayant couvert les proxys, le web scraping et l'infrastructure de données sur le blog Crawlbase, transformant des sujets réseau denses en guides que les ingénieurs terminent vraiment.

IK

Ian Kalvin

Ingénieur support technique · Crawlbase

Ingénieur support technique chez Crawlbase, il écrit depuis la première ligne de ce qui casse réellement en production, sur les configurations de scraping et de proxys.

MA

Muhammad Atif

Développeur full stack senior · Crawlbase

Développeur full stack senior chez Crawlbase, il construit la plateforme et écrit sur l'architecture de scraping, les proxys et les pipelines de données.