Paginación y recopilación de grandes conjuntos de datos
Gestión de la paginación, patrones next_cursor, limitación de tasa con time.sleep y barras de progreso.
Paginación y recopilación de grandes conjuntos de datos es una lección gratuita de Learn AI with Python en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn AI with Python, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn AI with Python incluye 4 lecciones en total.
Por qué existe la paginación
Las API rara vez devuelven millones de registros en una sola respuesta. Dividen los resultados en páginas para que cada respuesta sea pequeña y rápida.
Para recopilar un conjunto de datos completo, debe recorrer todas las páginas y combinar los resultados. En esta lección se explican los estilos habituales de paginación, además de la limitación de solicitudes y el seguimiento del progreso.
Paginación por número de página
El esquema más sencillo utiliza un parámetro page. Se incrementa hasta que la API devuelve una página vacía.
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")Paginación mediante cursor o URL siguiente
Muchas API modernas devuelven una URL siguiente o un token de cursor que apunta a la página siguiente. Se repite el proceso mientras exista un enlace siguiente.
Este método es robusto porque el servidor controla dónde comienza la página siguiente.
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))Respeto de los límites de solicitudes con time.sleep
Las API limitan el número de solicitudes que puede enviar por segundo o por minuto. Si realiza demasiadas solicitudes, recibirá 429 Too Many Requests o se bloqueará su acceso.
Inserte un pequeño time.sleep entre las solicitudes para actuar correctamente y mantenerse por debajo del límite.
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 secondLectura de las cabeceras de límite de solicitudes
Las API bien diseñadas informan de la cuota restante mediante cabeceras como X-RateLimit-Remaining y X-RateLimit-Reset.
Puede leerlas para ralentizar las solicitudes solo cuando se acerque al límite, en lugar de esperar siempre.
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)Gestión de 429 con backoff
Si recibe un 429, la respuesta suele incluir una cabecera Retry-After que indica cuánto tiempo debe esperar. Respete ese tiempo antes de volver a intentarlo.
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 onceBarras de progreso con tqdm
Las tareas de recopilación largas parecen bloqueadas si no ofrecen información sobre su avance. tqdm envuelve cualquier iterable y muestra una barra de progreso en tiempo real con la velocidad y el tiempo estimado de finalización.
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 con totales desconocidos
En la paginación mediante cursor, no se conoce de antemano el número total de elementos. Utilice tqdm como contador manual y llame a update() en cada iteración.
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()Recopilación incremental
Para conjuntos de datos enormes, no mantenga todo en memoria. La recopilación incremental escribe cada página en el disco a medida que llega, de modo que un fallo no haga perder todo el progreso.
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")Recopilación reanudable
Guarde el último cursor o número de página para que una nueva ejecución pueda reanudar el proceso en lugar de comenzar de nuevo. Esto hace que las tareas largas sean tolerantes a fallos.
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))Integración de todos los elementos
Un bucle de recopilación preparado para producción combina todas las piezas: paginar, esperar para respetar los límites de solicitudes, mostrar el progreso, escribir de forma incremental y guardar puntos de control.
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)Comprobación rápida: paginación mediante cursor
Una API devuelve un campo "next" que contiene una URL, o None en la última página.
Resumen: recopilación de conjuntos de datos grandes
Ya puede recopilar conjuntos de datos que abarcan muchas páginas:
- Paginación por número de página y mediante cursor (
while next_url) time.sleepy cabeceras de límite de solicitudes para evitar respuestas 429- Backoff mediante
Retry-Aftercuando se aplica una limitación - Barras de progreso de
tqdmpara tareas largas - Escritura incremental y reanudable para tolerar fallos
A continuación: almacenamiento eficiente de los datos recopilados.
Preguntas frecuentes
¿La lección «Paginación y recopilación de grandes conjuntos de datos» es gratis?
Sí — el texto completo de «Paginación y recopilación de grandes conjuntos de datos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn AI with Python, actualiza a CoddyKit PRO. El curso de Learn AI with Python incluye 4 lecciones en total.
¿Qué aprenderé en «Paginación y recopilación de grandes conjuntos de datos»?
Gestión de la paginación, patrones next_cursor, limitación de tasa con time.sleep y barras de progreso. Practicas Learn AI with Python con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Learn AI with Python?
No se requiere experiencia previa. Learn AI with Python en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Paginación y recopilación de grandes conjuntos de datos»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Learn AI with Python?
Sí. Cada lección de Learn AI with Python incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Fundamentos de las API REST para recopilar datos
- Paginación y recopilación de grandes conjuntos de datos
- Almacenamiento eficiente de datos recopilados
- Uso de API de datos públicos