Große Datensätze paginieren und erfassen
Pagination und next_cursor-Muster handhaben, Rate Limiting mit time.sleep und Fortschrittsbalken einsetzen.
Große Datensätze paginieren und erfassen ist eine kostenlose Learn AI with Python-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn AI with Python-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn AI with Python-Kurs umfasst insgesamt 4 Lektionen.
Warum es Paginierung gibt
APIs geben selten Millionen von Datensätzen in einer einzigen Antwort zurück. Sie teilen die Ergebnisse in Seiten auf, damit jede Antwort klein und schnell bleibt.
Um einen vollständigen Datensatz zu sammeln, müssen Sie jede Seite durchlaufen und die Ergebnisse zusammenführen. In dieser Lektion geht es um die gängigen Arten der Paginierung sowie um Rate-Limiting und Fortschrittsanzeige.
Paginierung mit Seitennummern
Beim einfachsten Verfahren wird ein page-Parameter verwendet. Sie erhöhen ihn so lange, bis die API eine leere Seite zurückgibt.
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")Paginierung mit Cursor bzw. nächster URL
Viele moderne APIs geben eine nächste URL oder ein Cursor-Token zurück, das auf die folgende Seite verweist. Sie führen die Schleife aus, solange ein Link zur nächsten Seite vorhanden ist.
Das ist robust, weil der Server festlegt, wo die nächste Seite beginnt.
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))Rate-Limits mit time.sleep einhalten
APIs begrenzen, wie viele Anfragen Sie pro Sekunde oder Minute senden dürfen. Wenn Sie sie mit Anfragen überlasten, erhalten Sie 429 Too Many Requests oder werden blockiert.
Fügen Sie zwischen den Anfragen ein kurzes time.sleep ein, um die API schonend zu nutzen und das Limit einzuhalten.
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 secondRate-Limit-Header auslesen
Gut implementierte APIs melden Ihr verbleibendes Kontingent in Headern wie X-RateLimit-Remaining und X-RateLimit-Reset.
Sie können diese auslesen und nur dann langsamer werden, wenn Sie sich dem Limit nähern, statt immer zu warten.
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)429 mit Backoff behandeln
Wenn Sie tatsächlich eine 429-Antwort erhalten, enthält die Antwort häufig einen Retry-After-Header, der angibt, wie lange Sie warten sollen. Halten Sie diese Wartezeit ein, bevor Sie es erneut versuchen.
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 onceFortschrittsbalken mit tqdm
Ohne Rückmeldung wirken lange Sammelvorgänge, als wären sie stecken geblieben. tqdm kann jedes Iterable umschließen und einen laufenden Fortschrittsbalken mit Rate und voraussichtlicher Restzeit anzeigen.
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 bei unbekannter Gesamtzahl
Bei der Cursor-Paginierung kennen Sie die Gesamtzahl anfangs nicht. Verwenden Sie tqdm als manuellen Zähler und rufen Sie in jeder Schleifeniteration update() auf.
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()Inkrementelles Sammeln
Bei sehr großen Datensätzen sollten Sie nicht alles im Speicher halten. Beim inkrementellen Sammeln wird jede Seite direkt nach dem Eintreffen auf die Festplatte geschrieben, sodass ein Absturz nicht den gesamten Fortschritt zunichtemacht.
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")Fortsetzbares Sammeln
Speichern Sie den letzten Cursor oder die letzte Seitennummer, damit ein erneuter Lauf fortgesetzt werden kann, statt von vorn zu beginnen. Dadurch werden lange Jobs fehlertolerant.
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))Alles zusammenführen
Eine produktionsreife Sammelschleife kombiniert alle Bestandteile: Paginierung, Wartezeiten für Rate-Limits, Fortschrittsanzeige, inkrementelles Schreiben und Checkpoints.
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)Schnelltest: Cursor-Paginierung
Eine API gibt ein Feld "next" zurück, das eine URL enthält, oder None auf der letzten Seite.
Zusammenfassung: Große Datensätze sammeln
Sie können jetzt Datensätze sammeln, die sich über viele Seiten erstrecken:
- Paginierung mit Seitennummern und Cursor (
while next_url) time.sleepund Rate-Limit-Header, um 429-Fehler zu vermeiden- Backoff mit
Retry-Afterbei Drosselung tqdm-Fortschrittsbalken für lange Jobs- Inkrementelles und fortsetzbares Schreiben für Fehlertoleranz
Als Nächstes speichern Sie die gesammelten Daten effizient.
Häufig gestellte Fragen
Ist die Lektion „Große Datensätze paginieren und erfassen“ kostenlos?
Ja — der vollständige Text von „Große Datensätze paginieren und erfassen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn AI with Python-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn AI with Python-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Große Datensätze paginieren und erfassen“?
Pagination und next_cursor-Muster handhaben, Rate Limiting mit time.sleep und Fortschrittsbalken einsetzen. Du übst Learn AI with Python mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Learn AI with Python zu starten?
Keine Vorkenntnisse erforderlich. Learn AI with Python auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Große Datensätze paginieren und erfassen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Learn AI with Python-Lektion Code schreiben und ausführen?
Ja. Jede Learn AI with Python-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Grundlagen von REST-APIs für die Datenerfassung
- Große Datensätze paginieren und erfassen
- Erfasste Daten effizient speichern
- Mit öffentlichen Daten-APIs arbeiten