0Pricing
Learn AI with Python · Lekcja

Stronicowanie i gromadzenie dużych zbiorów danych

Obsługa stronicowania, wzorców next_cursor, limitowania liczby żądań z time.sleep i pasków postępu.

Stronicowanie i gromadzenie dużych zbiorów danych to bezpłatna lekcja Learn AI with Python na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn AI with Python, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn AI with Python zawiera 4 lekcji w sumie.

Dlaczego stosuje się stronicowanie

Interfejsy API rzadko zwracają miliony rekordów w jednej odpowiedzi. Dzielą wyniki na strony, aby każda odpowiedź pozostała niewielka i szybka.

Aby zebrać cały zbiór danych, musisz przejść przez każdą stronę w pętli i połączyć wyniki. W tej lekcji omówiono typowe style stronicowania, a także ograniczanie liczby żądań i śledzenie postępu.

Stronicowanie według numeru strony

Najprostszy schemat używa parametru page. Zwiększasz jego wartość, dopóki interfejs API nie zwróci pustej strony.

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")

Stronicowanie za pomocą kursora lub adresu następnej strony

Wiele nowoczesnych interfejsów API zwraca adres URL następnej strony albo token kursora wskazujący kolejną stronę. Wykonujesz pętlę, dopóki istnieje odnośnik do następnej strony.

To rozwiązanie jest niezawodne, ponieważ serwer określa, od którego miejsca zaczyna się następna strona.

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))

Przestrzeganie limitów żądań za pomocą time.sleep

Interfejsy API ograniczają liczbę żądań, które możesz wysłać w ciągu sekundy lub minuty. Zbyt intensywne wysyłanie żądań skutkuje odpowiedzią 429 Too Many Requests albo zablokowaniem dostępu.

Wstaw krótkie time.sleep między żądaniami, aby korzystać z interfejsu w odpowiedzialny sposób i nie przekraczać limitu.

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

Odczytywanie nagłówków limitu żądań

Dobrze zaprojektowane interfejsy API informują w nagłówkach, takich jak X-RateLimit-Remaining i X-RateLimit-Reset, o pozostałym limicie żądań.

Możesz je odczytywać, aby spowalniać wysyłanie żądań tylko wtedy, gdy zbliżasz się do limitu, zamiast zawsze wstrzymywać działanie.

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)

Obsługa błędu 429 za pomocą mechanizmu backoff

Jeśli otrzymasz odpowiedź 429, często zawiera ona nagłówek Retry-After informujący, jak długo należy czekać. Przed ponowieniem żądania zastosuj się do tej wartości.

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

Paski postępu za pomocą tqdm

Długotrwałe zadania zbierania danych sprawiają wrażenie zawieszonych, jeśli nie wyświetlają informacji zwrotnej. tqdm opakowuje dowolny obiekt iterowalny i wyświetla na bieżąco pasek postępu wraz z tempem i przewidywanym czasem zakończenia.

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 przy nieznanej liczbie elementów

W przypadku stronicowania za pomocą kursora z góry nie znasz całkowitej liczby elementów. Użyj tqdm jako ręcznie aktualizowanego licznika i wywołuj update() w każdej iteracji.

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()

Przyrostowe zbieranie danych

W przypadku ogromnych zbiorów danych nie przechowuj wszystkiego w pamięci. Przyrostowe zbieranie danych zapisuje każdą stronę na dysku po jej otrzymaniu, dzięki czemu awaria nie powoduje utraty całego postępu.

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")

Wznawialne zbieranie danych

Zapisuj ostatni kursor lub numer strony, aby po ponownym uruchomieniu można było wznowić działanie zamiast zaczynać od początku. Dzięki temu długotrwałe zadania są odporne na błędy.

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))

Połączenie wszystkich elementów

Produkcyjna pętla zbierająca dane łączy wszystkie elementy: stronicowanie, przerwy wymagane przez limity żądań, wyświetlanie postępu, przyrostowy zapis i tworzenie punktów kontrolnych.

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)

Szybkie sprawdzenie: stronicowanie za pomocą kursora

Interfejs API zwraca pole "next" zawierające adres URL albo wartość None na ostatniej stronie.

Podsumowanie: zbieranie dużych zbiorów danych

Potrafisz już zbierać zbiory danych obejmujące wiele stron:

  • stronicowanie według numeru strony i za pomocą kursora (while next_url)
  • time.sleep i nagłówki limitu żądań, aby unikać błędów 429
  • mechanizm backoff z użyciem Retry-After w przypadku ograniczania ruchu
  • paski postępu tqdm dla długotrwałych zadań
  • przyrostowy i wznawialny zapis zapewniający odporność na błędy

Następny temat: wydajne przechowywanie zebranych danych.

Często zadawane pytania

Czy lekcja „Stronicowanie i gromadzenie dużych zbiorów danych” jest bezpłatna?

Tak — pełny tekst „Stronicowanie i gromadzenie dużych zbiorów danych” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn AI with Python, przejdź na CoddyKit PRO. Kurs Learn AI with Python zawiera 4 lekcji w sumie.

Co nauczysz się w „Stronicowanie i gromadzenie dużych zbiorów danych”?

Obsługa stronicowania, wzorców next_cursor, limitowania liczby żądań z time.sleep i pasków postępu. Ćwiczysz Learn AI with Python z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn AI with Python?

Nie wymagamy żadnego doświadczenia. Learn AI with Python w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Stronicowanie i gromadzenie dużych zbiorów danych”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn AI with Python?

Tak. Każda lekcja Learn AI with Python zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Podstawy REST API do gromadzenia danych
  2. Stronicowanie i gromadzenie dużych zbiorów danych
  3. Efektywne przechowywanie zebranych danych
  4. Praca z publicznymi interfejsami API danych
← Powrót do Learn AI with Python