0Pricing
Learn AI with Python · Leçon

Paginer et collecter de grands jeux de données

Gérer la pagination et les schémas next_cursor, limiter le débit avec time.sleep et afficher des barres de progression.

Paginer et collecter de grands jeux de données est une leçon Learn AI with Python gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn AI with Python, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn AI with Python comprend 4 leçons au total.

Pourquoi la pagination existe

Les API renvoient rarement des millions d'enregistrements en une seule réponse. Elles répartissent les résultats sur des pages afin que chaque réponse reste petite et rapide.

Pour collecter un jeu de données complet, vous devez parcourir chaque page et combiner les résultats. Cette leçon présente les styles de pagination courants, ainsi que la limitation du débit et le suivi de la progression.

Pagination par numéro de page

Le schéma le plus simple utilise un paramètre page. Vous l'incrémentez jusqu'à ce que l'API renvoie une page vide.

import requests

all_items = []
page = 1
while True:
    resp = requests.get(url, params={"page": page, "per_page": 100}, timeout=10)
    resp.raise_for_status()
    items = resp.json()
    if not items:
        break
    all_items.extend(items)
    page += 1
print(len(all_items), "items collected")

Pagination par curseur ou URL suivante

De nombreuses API modernes renvoient une URL suivante ou un jeton de curseur indiquant la page suivante. Vous effectuez la boucle tant qu'un lien suivant existe.

Cette méthode est robuste, car le serveur contrôle le point de départ de la page suivante.

all_items = []
next_url = "https://api.example.com/items?limit=100"
while next_url:
    resp = requests.get(next_url, timeout=10)
    resp.raise_for_status()
    data = resp.json()
    all_items.extend(data["results"])
    next_url = data.get("next")   # None when no more pages
print(len(all_items))

Respecter les limites de débit avec time.sleep

Les API limitent le nombre de requêtes que vous pouvez envoyer par seconde ou par minute. Les interroger de manière excessive renvoie 429 Too Many Requests ou entraîne votre blocage.

Insérez un petit time.sleep entre les requêtes pour rester courtois et respecter la limite.

import time

while next_url:
    resp = requests.get(next_url, timeout=10)
    resp.raise_for_status()
    data = resp.json()
    all_items.extend(data["results"])
    next_url = data.get("next")
    time.sleep(0.5)   # 2 requests per second

Lire les en-têtes de limitation du débit

Les API bien conçues indiquent le quota restant dans des en-têtes tels que X-RateLimit-Remaining et X-RateLimit-Reset.

Vous pouvez les lire pour ralentir uniquement lorsque vous approchez de la limite, au lieu de toujours faire une pause.

remaining = int(resp.headers.get("X-RateLimit-Remaining", 1))
if remaining < 5:
    reset = int(resp.headers.get("X-RateLimit-Reset", 1))
    print("Near limit, sleeping", reset, "s")
    time.sleep(reset)

Gérer le code 429 avec une temporisation

Si vous recevez effectivement un 429, la réponse contient souvent un en-tête Retry-After qui vous indique combien de temps attendre. Respectez ce délai avant de réessayer.

resp = requests.get(url, timeout=10)
if resp.status_code == 429:
    wait = int(resp.headers.get("Retry-After", 5))
    time.sleep(wait)
    resp = requests.get(url, timeout=10)   # retry once

Barres de progression avec tqdm

Les longues tâches de collecte semblent bloquées sans indication. tqdm encapsule tout objet itérable et affiche une barre de progression en direct avec le débit et l'ETA.

from tqdm import tqdm

for page in tqdm(range(1, 101), desc="Fetching"):
    resp = requests.get(url, params={"page": page}, timeout=10)
    all_items.extend(resp.json())
    time.sleep(0.2)

tqdm avec un nombre total inconnu

Avec la pagination par curseur, vous ne connaissez pas le nombre total à l'avance. Utilisez tqdm comme compteur manuel et appelez update() à chaque boucle.

from tqdm import tqdm

pbar = tqdm(desc="Pages")
while next_url:
    resp = requests.get(next_url, timeout=10)
    data = resp.json()
    all_items.extend(data["results"])
    next_url = data.get("next")
    pbar.update(1)
pbar.close()

Collecte incrémentielle

Pour les jeux de données volumineux, ne conservez pas tout en mémoire. La collecte incrémentielle écrit chaque page sur le disque dès sa réception, afin qu'une panne ne fasse pas perdre toute la progression.

import json

with open("items.jsonl", "w") as f:
    while next_url:
        resp = requests.get(next_url, timeout=10)
        data = resp.json()
        for item in data["results"]:
            f.write(json.dumps(item) + "\n")
        next_url = data.get("next")

Collecte reprenable

Enregistrez le dernier curseur ou numéro de page afin qu'une nouvelle exécution puisse reprendre au lieu de recommencer. Cela rend les longues tâches tolérantes aux pannes.

import os

start_page = 1
if os.path.exists("checkpoint.txt"):
    start_page = int(open("checkpoint.txt").read()) + 1

for page in range(start_page, 1000):
    # ... fetch and store ...
    open("checkpoint.txt", "w").write(str(page))

Assembler tous les éléments

Une boucle de collecte destinée à la production combine tous les éléments : paginer, respecter les limites de débit avec des pauses, afficher la progression, écrire progressivement et créer des points de contrôle.

from tqdm import tqdm
import time, json

with open("out.jsonl", "a") as f:
    next_url = "https://api.example.com/items?limit=100"
    pbar = tqdm(desc="Pages")
    while next_url:
        r = requests.get(next_url, timeout=10)
        r.raise_for_status()
        d = r.json()
        for it in d["results"]:
            f.write(json.dumps(it) + "\n")
        next_url = d.get("next")
        pbar.update(1)
        time.sleep(0.3)

Vérification rapide : pagination par curseur

Une API renvoie un champ "next" qui contient une URL, ou None sur la dernière page.

Récapitulatif : collecter de grands jeux de données

Vous pouvez maintenant rassembler des jeux de données répartis sur de nombreuses pages :

  • Pagination par numéro de page et par curseur (while next_url)
  • time.sleep et en-têtes de limitation du débit pour éviter les codes 429
  • Temporisation Retry-After en cas de limitation
  • Barres de progression tqdm pour les longues tâches
  • Écriture incrémentielle et reprenable pour tolérer les pannes

Ensuite : stocker efficacement les données collectées.

Questions Fréquemment Posées

La leçon « Paginer et collecter de grands jeux de données » est-elle gratuite ?

Oui — le texte complet de « Paginer et collecter de grands jeux de données » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn AI with Python, passe à CoddyKit PRO. Le cours Learn AI with Python comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Paginer et collecter de grands jeux de données » ?

Gérer la pagination et les schémas next_cursor, limiter le débit avec time.sleep et afficher des barres de progression. Tu pratiques Learn AI with Python avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn AI with Python ?

Aucune expérience préalable n'est requise. Learn AI with Python sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Paginer et collecter de grands jeux de données » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn AI with Python ?

Oui. Chaque leçon Learn AI with Python inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Principes fondamentaux des API REST pour la collecte de données
  2. Paginer et collecter de grands jeux de données
  3. Stocker efficacement les données collectées
  4. Utiliser les API de données publiques
← Retour à Learn AI with Python