Dominando a Paginação de APIs com Requests em Python

O tratamento eficiente de grandes conjuntos de dados é crucial ao trabalhar com APIs. Buscar todos os dados de uma vez pode sobrecarregar tanto o servidor quanto seu aplicativo. A paginação resolve isso recuperando dados em partes menores e gerenciáveis. Este artigo explora várias estratégias de paginação usando a biblioteca requests do Python, focando na lógica do lado do servidor.

Sumário

• O que é Paginação?
• Paginação com um Botão “Próximo”
• Paginação com Offset e Limite
• Paginação Baseada em Cursor

O que é Paginação?

Paginação é a técnica de recuperar dados de uma API em páginas menores e sequenciais, em vez de uma única resposta massiva. Cada página contém um subconjunto dos dados, identificado por um número de página, offset, cursor ou outro identificador único. Isso melhora o desempenho, reduz o uso de memória e aprimora a experiência do usuário, especialmente com grandes conjuntos de dados.

Paginação com um Botão “Próximo”

Muitas APIs usam uma abordagem simples de botão “próximo”. A resposta da API inclui uma URL (frequentemente dentro de uma resposta JSON) apontando para a próxima página. Isso continua até que a URL “próxima” seja nula ou ausente.

import requests

def paginate_next_button(base_url):
    all_data = []
    url = base_url
    while url:
        response = requests.get(url)
        response.raise_for_status()
        data = response.json()
        all_data.extend(data.get('results', [])) #Trata casos onde a chave 'results' pode estar faltando
        url = data.get('next')
    return all_data

# Exemplo (substitua pelo seu endpoint da API)
base_url = "https://api.example.com/data?page=1"
all_data = paginate_next_button(base_url)
print(all_data)

Paginação com Offset e Limite

Algumas APIs usam parâmetros como offset e limit. offset especifica o ponto de partida, e limit define o número de itens por página. Você pode precisar determinar o número total de itens separadamente (por exemplo, a partir de uma chamada de API dedicada ou de um cabeçalho como X-Total-Count).

import requests

def paginate_offset_limit(base_url, limit=10):
    all_data = []
    offset = 0
    while True:
        url = f"{base_url}&offset={offset}&limit={limit}"
        response = requests.get(url)
        response.raise_for_status()
        data = response.json()
        results = data.get('results', [])
        if not results:  #Verifica se a página está vazia
            break
        all_data.extend(results)
        offset += limit
    return all_data

# Exemplo (substitua pelo seu endpoint da API)
base_url = "https://api.example.com/data"
all_data = paginate_offset_limit(base_url, limit=20)
print(all_data)

Paginação Baseada em Cursor

A paginação baseada em cursor usa um valor de cursor único para identificar a próxima página. Isso costuma ser mais eficiente do que a paginação baseada em offset para grandes conjuntos de dados, pois evita a necessidade de recalcular offsets. A resposta da API fornece o cursor para a próxima página.

import requests

def paginate_cursor(base_url):
    all_data = []
    url = base_url
    while url:
        response = requests.get(url)
        response.raise_for_status()
        data = response.json()
        all_data.extend(data.get('results', []))
        url = data.get('next_cursor') # Adapte para o nome real da chave na resposta
    return all_data

# Exemplo (substitua pelo seu endpoint da API)
base_url = "https://api.example.com/data?cursor=" #O cursor inicial pode estar vazio ou ter um valor específico
all_data = paginate_cursor(base_url)
print(all_data)

Lembre-se de adaptar esses trechos de código à estrutura e ao formato de resposta específicos da sua API. Sempre consulte a documentação da API para os parâmetros de paginação e a estrutura de resposta corretos. O tratamento de erros completo é essencial para aplicativos robustos.