Recolha de dados de produtos da Amazon com Python

O acesso a dados de gigantes do comércio eletrónico como a Amazon é crucial para a análise do mercado, estratégias de preços e investigação de produtos. Estes dados podem ser recolhidos através de web scraping, um método que envolve a extração de grandes quantidades de informação de websites. No entanto, a Amazon protege rigorosamente os seus dados, tornando as técnicas tradicionais de scraping muitas vezes ineficazes. Neste guia abrangente, vamos aprofundar os métodos de recolha de dados de produtos da Amazon e discutir estratégias para contornar os robustos sistemas anti-raspagem da plataforma. Exploraremos o uso de Python, proxies e técnicas avançadas de raspagem que podem ajudar a superar esses desafios e coletar com eficiência os dados necessários para seus negócios ou fins de pesquisa.

Criando um script Python para raspar dados da Amazon

Para extrair dados da Amazon com sucesso, pode seguir o algoritmo estruturado descrito abaixo. Esse método garante que você recupere as informações necessárias com eficiência e precisão.

Passo 1: Enviando solicitações HTTP para as páginas de produtos da Amazon:

• Utilize a biblioteca de solicitações para iniciar solicitações HTTP GET direcionadas às páginas de produtos da Amazon;
• Capture o conteúdo HTML bruto da resposta HTTP para preparar a análise.

Passo 2: Analisando o conteúdo HTML:

• Empregar a biblioteca lxml para analisar o conteúdo HTML bruto recebido;
• Analisar o HTML para localizar os pontos de dados específicos que deseja extrair;
• Executar consultas XPath para direcionar e extrair com precisão esses pontos de dados da estrutura HTML.

Etapa 3: armazenando os dados:

• Depois de extrair os dados necessários, salve-os em formatos acessíveis, como CSV ou JSON, que facilitam a análise e a integração com outros aplicativos.

Lidar com possíveis obstáculos

A Amazon emprega várias medidas para impedir os esforços de raspagem, incluindo limitações de velocidade de conexão, integração CAPTCHA e bloqueio de IP. Os usuários podem adotar contramedidas para contornar esses obstáculos, como a utilização de proxies de alta qualidade.

Para actividades de scraping extensas, podem ser utilizadas técnicas Python avançadas para recolher quantidades substanciais de dados de produtos. Estas técnicas incluem o enchimento de cabeçalhos e a impressão digital TLS, que ajudam a evitar a deteção e a garantir uma extração de dados bem sucedida.

Essas etapas são explicadas nas próximas seções do artigo, onde veremos sua implementação prática usando o Python 3.12.2

Pré-requisitos

Para iniciar um projeto de web scraping, vamos começar configurando um scraper básico usando a biblioteca lxml para parsing de HTML e a biblioteca requests para gerenciar requisições HTTP direcionadas ao servidor web da Amazon.

Nosso foco será a extração de informações essenciais, como nomes de produtos, preços e classificações das páginas de produtos da Amazon. Também mostraremos técnicas para analisar HTML e gerenciar solicitações de forma eficiente, garantindo uma extração precisa e organizada dos dados.

Para manter as dependências do projeto e evitar conflitos, é aconselhável criar um ambiente virtual separado para esse esforço de raspagem da Web. Recomenda-se o uso de ferramentas como "venv" ou "pyenv" para configurar ambientes virtuais.

Instalar bibliotecas de terceiros

Você precisará das seguintes bibliotecas Python de terceiros:

1. requests

Usada para enviar solicitações HTTP e recuperar conteúdo da Web. É frequentemente usada para raspagem da web e interação com APIs da web.

Instalação:

 pip install requests

2. lxml

Uma biblioteca para analisar e manipular documentos XML e HTML. É frequentemente utilizada para raspar a Web e trabalhar com dados estruturados de páginas Web.

Instalação:

 pip install lxml

Importando as bibliotecas necessárias

Aqui precisamos de importar as bibliotecas necessárias para que o nosso raspador funcione. Isso inclui uma biblioteca de solicitação para lidar com solicitações HTTP, a biblioteca CSV para lidar com a operação de arquivos CSV, a biblioteca aleatória para gerar valores aleatórios e fazer escolhas aleatórias, a biblioteca lxml para analisar o conteúdo HTML bruto e Dict e List para dicas de tipo.

 import requests
import csv
import random
from lxml import html
from typing import Dict, List

Leitura de entradas do ficheiro CSV

O seguinte trecho de código lê um arquivo CSV chamado amazon_product_urls.csv onde cada linha contém o URL de uma página de produto da Amazon. O código itera sobre as linhas, extraindo os URLs de cada linha e anexando-os a uma lista chamada URL.

 with open('amazon_product_urls.csv', 'r') as file:
    reader = csv.DictReader(file)
    for row in reader:
        urls.append(row['url'])

Cabeçalhos de pedidos HTTP e proxies

Os cabeçalhos de pedido desempenham um papel importante nos pedidos HTTP, fornecendo informações complexas sobre o cliente e o pedido. Ao fazer scraping, é importante copiar os títulos de utilizadores autorizados para evitar a deteção e aceder facilmente às informações pretendidas. Ao imitar os cabeçalhos normalmente utilizados, os scrapers podem evitar técnicas de deteção, garantindo que os dados são extraídos de forma consistente, mantendo os padrões éticos.

Os proxies actuam como intermediários na raspagem da Web, mascarando o endereço IP do raspador para evitar a deteção e o bloqueio do servidor. Um proxy rotativo permite-lhe enviar cada pedido com um novo endereço IP, evitando potenciais bloqueios. A utilização de proxies residenciais ou móveis reforça a resistência às medidas anti-raspagem devido à deteção do verdadeiro anfitrião e do fornecedor.

Código para integrar cabeçalhos de solicitação e servidores proxy com autorização de endereço IP:

 headers = {
    'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
    'accept-language': 'en-IN,en;q=0.9',
    'dnt': '1',
    'sec-ch-ua': '"Google Chrome";v="123", "Not:A-Brand";v="8", "Chromium";v="123"',
    'sec-ch-ua-mobile': '?0',
    'sec-ch-ua-platform': '"Windows"',
    'sec-fetch-dest': 'document',
    'sec-fetch-mode': 'navigate',
    'sec-fetch-site': 'same-origin',
    'sec-fetch-user': '?1',
    'upgrade-insecure-requests': '1',
   }
proxies = {'http': '', 'https': ''}

Rotação do agente de utilizador

Aqui, vamos criar uma lista de colecções de agentes de utilizador, a partir da qual será escolhido um agente de utilizador aleatório para cada pedido. A implementação de um mecanismo de rotação de cabeçalho, como a rotação do User-Agent após cada solicitação, pode ajudar ainda mais a contornar as medidas de deteção de bots.

 useragents = [
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4591.54 Safari/537.36",
        "Mozilla/5.0 (Windows NT 7_0_2; Win64; x64) AppleWebKit/541.38 (KHTML, like Gecko) Chrome/105.0.1585 Safari/537.36",
        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36",
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.7863.44 Safari/537.36"
    ]
headers['user-agent'] = random.choice(useragnets)

Faça solicitações HTTP para a página de produtos da Amazon junto com cabeçalhos e proxy

Envia uma solicitação HTTP GET para um URL especificado com cabeçalhos personalizados, um tempo limite de 30 segundos e proxies especificados para a solicitação.

response = requests.get(url=url, headers=headers, proxies=proxies, timeout=30)

Identificação de XPath/Selectores de pontos de dados necessários

Pontos de dados necessários: título, preço e classificações. Agora, vamos inspecionar e identificar o XPath correspondente para os elementos mostrados nas capturas de tela junto com seus respectivos pontos de dados.

A captura de tela abaixo mostra o recurso "Inspecionar" do Chrome DevTools sendo usado para encontrar o XPath `//span[@id="productTitle"]/text()` para extrair o título do produto de uma página de produto da Amazon.

A captura de tela a seguir mostra a localização do respetivo XPath `//div[@id="corePrice_feature_div"]/div/div/span/span/text()` para extrair o preço do produto de uma página de produto da Amazon.

A captura de ecrã mostra a respectiva localização do XPath `//span[@id="acrPopover"]/@title'` para extrair as classificações de produtos de uma página de produtos da Amazon.

Crie um dicionário que forneça expressões XPath para extrair informações específicas de uma página da Web: o título, as classificações e o preço de um produto.

xpath_queries = {'title': '//span[@id="productTitle"]/text()', 'ratings': '//span[@id="acrPopover"]/@title', 'price': '//span[@class="a-offscreen"]/text()'}

Criando o analisador lxml a partir da resposta HTML

O código abaixo analisa o conteúdo HTML obtido a partir da requisição GET ao servidor da Amazon em um formato estruturado do tipo árvore, permitindo uma navegação e manipulação mais fácil de seus elementos e atributos.

tree = html.fromstring(response.text)

Extração dos dados necessários

O seguinte trecho de código extrai dados da árvore HTML analisada usando uma consulta XPath e os atribui a um dicionário com uma chave especificada. strip() é usado para remover espaços em branco no início e no final, se houver. Ele recupera o primeiro resultado da consulta XPath e o armazena sob a chave fornecida no dicionário extracted_data.

data = tree.xpath(xpath_query)[0].strip()
extracted_data[key] = data

Guardar os dados extraídos em CSV

O código a seguir grava dados do dicionário extracted_data em um arquivo CSV chamado product_data.csv. Certifique-se de que a linha de cabeçalho seja gravada somente se o arquivo estiver vazio. Se o ficheiro não estiver vazio, adiciona os dados como uma linha adicional ao ficheiro CSV. Esta função permite que o ficheiro CSV seja continuamente atualizado com novos dados extraídos sem substituir o texto existente.

 csv_file_path = 'product_data.csv'
fieldnames = ['title', 'ratings', 'price']
with open(csv_file_path, 'a', newline='') as csvfile:
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    if csvfile.tell() == 0:
        writer.writeheader()
    writer.writerow(extracted_data)

Implementação do código

Consulte o nosso código completo, que o ajudará a começar rapidamente. O código é bem estruturado e documentado, tornando-o amigável para iniciantes. Para executar este código, o usuário deve ter um arquivo CSV chamado "amazon_product_urls" no mesmo diretório. Abaixo está a estrutura do arquivo CSV:

import requests
import csv
import random
from lxml import html
from typing import Dict, List


def send_requests(
    url: str, headers: Dict[str, str], proxies: Dict[str, str]
) -> List[Dict[str, str]]:
    """
    Envia pedidos HTTP GET para vários URLs com cabeçalhos e proxies.

    Args:
        urls (str): URL para enviar pedidos.
        headers (Dict[str, str]): Dicionário que contém os cabeçalhos dos pedidos.
        proxies (Dict[str, str]): Dicionário que contém definições de proxy.

    Returns:
        Response: Objeto de resposta que contém dados de resposta para cada URL.
    """
    try:
        response = requests.get(url, headers=headers, proxies=proxies, timeout=30)
        # Validação da resposta
        if len(response.text)> 10000:
            return response
        return None
    except Exception as e:
        print(f"Error occurred while fetching URL {url}: {str(e)}")


def extract_data_from_html(
    response, xpath_queries: Dict[str, str]
) -> Dict[str, List[str]]:
    """
    Extrai dados do conteúdo HTML utilizando consultas XPath.

    Args:
        response (Response): Objeto de resposta.
        xpath_queries (Dict[str, str]): Dicionário que contém consultas XPath para extração de dados.

    Returns:
        Dict[str, str]: Dicionário que contém dados extraídos para cada consulta XPath.
    """
    extracted_data = {}
    tree = html.fromstring(response.text)
    for key, xpath_query in xpath_queries.items():
        data = tree.xpath(xpath_query)[0].strip()
        extracted_data[key] = data
    return extracted_data


def save_to_csv(extracted_data: Dict[str, any]):
    """
    Salva um dicionário como uma linha em um arquivo CSV usando DictWriter.

    Args:
        extracted_data (Dict[str, any]): Dicionário que representa uma linha de dados.
    """
    csv_file_path = "product_data.csv"
    fieldnames = ["title", "ratings", "price"]
    with open(csv_file_path, "a", newline="") as csvfile:
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
        if csvfile.tell() == 0:
            writer.writeheader()  # Escrever o cabeçalho apenas se o ficheiro estiver vazio
        writer.writerow(extracted_data)


def main():
    # Ler URLs de um ficheiro CSV
    urls = []
    with open("amazon_product_urls.csv", "r") as file:
        reader = csv.DictReader(file)
        for row in reader:
            urls.append(row["url"])

    # Definição dos cabeçalhos do pedido
    headers = {
        "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
        "accept-language": "en-IN,en;q=0.9",
        "dnt": "1",
        "sec-ch-ua": '"Google Chrome";v="123", "Not:A-Brand";v="8", "Chromium";v="123"',
        "sec-ch-ua-mobile": "?0",
        "sec-ch-ua-platform": '"Windows"',
        "sec-fetch-dest": "document",
        "sec-fetch-mode": "navigate",
        "sec-fetch-site": "same-origin",
        "sec-fetch-user": "?1",
        "upgrade-insecure-requests": "1",
        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
    }

    useragents = [
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4591.54 Safari/537.36",
        "Mozilla/5.0 (Windows NT 7_0_2; Win64; x64) AppleWebKit/541.38 (KHTML, like Gecko) Chrome/105.0.1585 Safari/537.36",
        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36",
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.7863.44 Safari/537.36"
        ]

    # Definição de proxies
    proxies = {"http": "IP:Port", "https": "IP:Port"}

    # Envio de pedidos para URLs
    for url in urls:
        # Rotação de Useragent nos cabeçalhos
        headers["user-agent"] = random.choice(useragnets)
        response = send_requests(url, headers, proxies)
        if response:
            # Extrair dados do conteúdo HTML
            xpath_queries = {
                "title": '//span[@id="productTitle"]/text()',
                "ratings": '//span[@id="acrPopover"]/@title',
                "price": '//span[@class="a-offscreen"]/text()',
            }
            extracted_data = extract_data_from_html(response, xpath_queries)

            # Guardar os dados extraídos num ficheiro CSV
            save_to_csv(extracted_data)


if __name__ == "__main__":
    main()

Sugestões de proxy para a recolha de dados da Amazon através de Python

Estão disponíveis diferentes soluções de proxy, incluindo Datacenter IPv4, proxies móveis rotativos, ISP e residenciais, para uma extração de dados sem interrupções. A lógica de rotação adequada e os agentes do utilizador são utilizados para simular o comportamento real do utilizador, enquanto os proxies especiais suportam a recolha de dados em grande escala com rotação interna e conjuntos de IP extensos. Compreender os prós e os contras de cada opção de proxy é crucial para a extração ininterrupta de dados.

A raspagem de dados de produtos da Amazon envolve uma preparação meticulosa para navegar nos mecanismos anti-raspagem da plataforma de forma eficaz. A utilização de servidores proxy juntamente com Python permite um processamento de dados eficiente e uma extração orientada das informações necessárias. Ao selecionar proxies para raspagem da Web, é crucial considerar factores como o desempenho, o custo, a fiabilidade do servidor e os requisitos específicos do seu projeto. A utilização de proxies dinâmicos e a implementação de estratégias para contrariar as medidas de segurança podem minimizar o risco de bloqueio e melhorar a eficiência global do processo de recolha de dados.