escuro proxyscrape logótipo

Extrair sites estáticos e dinâmicos com Python e ProxyScrape API

Guias, Python, As diferenças, May-02-20245 minutos de leitura

Num mundo que está a tornar-se cada vez mais dependente de dados, a capacidade de reunir e analisar grandes quantidades de informação pode dar às empresas e aos profissionais uma vantagem competitiva significativa. O Web scraping, o processo de extração de dados de sítios Web, é uma ferramenta poderosa no arsenal de analistas de dados, programadores Web, profissionais de marketing digital e programadores Python. Este guia apresenta técnicas básicas e avançadas de raspagem da Web, destaca as práticas recomendadas e apresenta a API de raspagem da Web do ProxyScrape como uma solução flexível para sites estáticos e dinâmicos.

Identificar se um site é estático ou dinâmico

Para determinar se um sítio Web é estático ou dinâmico:

  • Inspecionar o código-fonte da página: Clique com o botão direito do rato e seleccione "Ver origem da página". Se todo o conteúdo estiver visível e corresponder ao que é apresentado na página, é provável que seja estático.
  • Utilizar as ferramentas de desenvolvimento do navegador: Abra as ferramentas do programador clicando com o botão direito do rato na página e seleccionando "Inspecionar" e, em seguida, observe o separador "Rede" à medida que interage com a página. Se forem efectuados novos pedidos de rede em resposta a interacções, é provável que se trate de um site dinâmico.
  • Desativar o JavaScript: Tente desativar o JavaScript nas definições do seu browser e volte a carregar a página. Se a página deixar de funcionar corretamente ou mostrar muito pouco conteúdo, é provável que esteja a depender do JavaScript para obter e processar dados, o que indica uma natureza dinâmica.

Estes métodos representam apenas algumas formas de determinar se um sítio Web é estático ou dinâmico. Embora existam estratégias adicionais, analisámos e identificámos estas técnicas, que consideramos serem amplamente utilizadas e eficazes.

Raspagem de sites estáticos com Requests e BeautifulSoup

Para extrair conteúdo estático, Python oferece bibliotecas robustas como `requests` para fazer requisições HTTP e `BeautifulSoup` para analisar documentos HTML e XML. Aqui está um exemplo simples:

  • Fazendo uma requisição: Utilize `requests` para obter o conteúdo HTML da página.
  • Analisando com BeautifulSoup: Uma vez que você tenha o conteúdo da página, o `BeautifulSoup` pode analisar e extrair informações específicas.
importar pedidos
from bs4 import BeautifulSoup

resposta = requests.get('http://example.com')

soup = BeautifulSoup(response.text, 'html.parser')

# Extrair os dados desejados
dados = soup.find_all('p')

Este método é perfeito para quem está a iniciar a sua viagem na recolha de dados da Web. É eficaz para sítios Web com conteúdo estático, exigindo uma configuração mínima.

Recolha de dados de sítios Web dinâmicos

Os sítios Web dinâmicos apresentam um desafio diferente. Estes sítios web carregam o seu conteúdo de forma assíncrona com JavaScript, o que significa que a raspagem simples de HTML não funciona porque os dados não estão presentes no carregamento inicial da página.

Há duas formas de abordar a raspagem dinâmica de sítios Web:

  • A primeira abordagem é usar uma biblioteca de automação de navegador como Playwright/Selenium para obter o conteúdo e depois analisá-lo com Beautifulsoup.
  • A segunda abordagem é como brincar aos detectives com o separador da rede para identificar o endpoint que o site usa para ir buscar os seus dados. Depois, basta usar o módulo 'request' do Python para obter esses dados.

Navegar em sítios Web dinâmicos com o Playwright

Para recolher conteúdo dinâmico, ferramentas como o Playwright imitam a interação de um utilizador real com o browser, permitindo-lhe recolher dados carregados dinamicamente. Aqui está uma breve visão sobre como usar o Playwright com Python:

  • Instalando o Playwright: Instale o pacote Playwright e a ferramenta de linha de comando.
    - "pip install playwright"
    - "playwright install"
  • Usando o Playwright para simular interações: Escreva um script que navegue no site e interaja com ele conforme necessário para acionar o carregamento de conteúdo dinâmico
from playwright.sync_api import sync_playwright


se __name__ == '__main__':

   with sync_playwright() as p:

       browser = p.chromium.launch(headless=True)

      página = browser.new_page()

      página.goto('https://www.scrapethissite.com/pages/ajax-javascript/')

      # Simular interacções aqui

      page.click('//*[@id="2014"]')

      # Extrair o conteúdo dinâmico

       content = page.inner_text('//*[@id="oscars"]/div/div[5]/div/table')

      print(content)

       browser.close()

Analisar o Painel de Rede para obter pontos finais da API:

  • Abrir ferramentas de desenvolvedor
    a. Abra o site em que está interessado no seu browser.
    b. Clique com o botão direito do rato em qualquer parte da página e seleccione Inspecionar ou prima Ctrl+Shift+I (Cmd+Option+I no Mac) para abrir as ferramentas de programador.
  • Inspecionar o separador Rede
    a. Clique na guia Rede nas ferramentas do desenvolvedor. Este separador é onde verá todos os pedidos de rede que o site faz.
    b. Actualize a página para começar a capturar o tráfego desde o início.
  • Filtrar e identificar solicitações AJAX
    a. Pode filtrar os pedidos por tipos como XHR (XMLHttpRequest), que são normalmente utilizados para pedidos AJAX.
    b. Interaja com a página - como clicar em botões, preencher formulários ou fazer scroll - para acionar o carregamento dinâmico de conteúdo.
    c. Observe os pedidos de rede que aparecem quando executa estas acções. Procure pedidos que obtenham dados em que esteja interessado.
  • Analisar a solicitação
    a. Clique em uma solicitação na guia Rede que pareça estar recuperando os dados de que você precisa.
    b. Verifique a seção Cabeçalhos para ver o método de solicitação (GET, POST, etc.), o URL e outros cabeçalhos.
  • Replicar a solicitação usando Python
    a. Use as informações da guia Cabeçalhos para replicar a solicitação usando a biblioteca de solicitações do Python. Aqui está um exemplo básico de como você pode fazer isso:
import requests

# URL from the AJAX request
url = 'https://example.com/api/data'

# Any headers you observed that are necessary, like user-agent, authorization tokens, etc.
headers = {
    'User-Agent': 'Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Mobile Safari/537.36,gzip(gfe)',
    'Authorization': 'Bearer token_if_needed'
}

# If it's a POST request, you might also need to send data
data = {
    'example_key': 'example_value'
}

# Replace 'get' with 'post' if the request type is POST
response = requests.get(url, headers=headers, data=data if 'post' in locals() else None)

# To view the response
print(response.json())

Utilização de uma API de Web Scraping para ambos os cenários

Embora o domínio dos pedidos e do Playwright ou de qualquer outra biblioteca de cliente Http possa ser gratificante, é necessário tempo e esforço para os tratar corretamente. Uma abordagem alternativa é utilizar uma API de raspagem da Web que abstrai a complexidade das tarefas de raspagem. Não só trata do envio de pedidos HTTP por si, como também fornece assistência com técnicas anti-ban para evitar ser bloqueado por determinados sítios Web.

Apresentando a API de raspagem da Web do ProxyScrape

ProxyScrape oferece uma API de Web Scraping que simplifica a extração de dados de sítios Web estáticos e dinâmicos.

As características da API incluem:

  • Fácil integração com sítios dinâmicos e estáticos.
  • Suporte abrangente para diferentes tipos de actividades de raspagem da Web.
  • Vasto conjunto de endereços IP
  • Oferece até 100.000 pedidos gratuitos, permitindo aos utilizadores explorar e realizar todo o potencial da API sem investimento imediato.
  • Tecnologia anti-ban sofisticada, adaptada a sítios Web conhecidos pelas suas dificuldades de raspagem.
  • As acções permitem um controlo preciso do tempo de receção dos resultados do sítio Web. Isto inclui esperar por um determinado pedido de URL, antecipar o aparecimento de um elemento no site, actividades pós-rolagem e muito mais. Utilizando

ProxyScrape Web Scraping API com um sítio Web estático:

Esta é uma ilustração de como pode incorporar a nossa API de recolha de dados da Web nos seus scripts Python para sítios Web estáticos ou para chamar um ponto de extremidade da API que tenha extraído do painel de inspeção no seu navegador: 

import requests
import base64
import json

data = {
    "url": "https://books.toscrape.com/",
    "httpResponseBody": True
}

headers = {
    'Content-Type': 'application/json',
    'X-Api-Key': 'YOUR_API_KEY'
}

response = requests.post('https://api.proxyscrape.com/v3/accounts/freebies/scraperapi/request', headers=headers, json=data)

if response.status_code == 200:
    json_response = response.json()
    if 'browserHtml' in json_response['data']:
        print(json_response['data']['browserHtml'])
    else:
        print(base64.b64decode(json_response['data']['httpResponseBody']).decode())
else:
    print("Error:", response.status_code)

ProxyScrape Web Scraping API com um sítio Web dinâmico:

Aqui está um exemplo em que esperamos que o favicon comece a carregar. Normalmente, esse é o último pedido a ser iniciado no site de teste que estamos a utilizar. 

import requests
import json

url = 'https://api.proxyscrape.com/v3/accounts/freebies/scraperapi/request'

headers = {
    'Content-Type': 'application/json',
    'X-Api-Key': '<your api key>'  # Make sure to replace <your api key> with your actual API key
}

payload = {
    "url": "https://books.toscrape.com/",
    "browserHtml": True,
    "actions": [
        {
            "action": "waitForRequest",
            "urlPattern": "https://books.toscrape.com/static/oscar/favicon.ico",
            "urlMatchingOptions": "exact"
        }
    ]
}

response = requests.post(url, headers=headers, json=payload)

# Print the response from the server
print(response.text)  # Prints the response body as text

Melhores práticas em Web Scraping

Independentemente das ferramentas ou APIs que escolher, respeitar os termos de utilização dos sítios Web, limitar as taxas de pedidos para evitar proibições de IP e utilizar proxies para a recolha anónima de dados são práticas recomendadas fundamentais. ProxyScrape O serviço de proxies da Web da Web, o qual não só fornece proxies premium, residenciais, móveis e dedicados para essas necessidades, como também incentiva a raspagem ética da Web.

Conclusão

  • Quer esteja a começar a fazer scraping da Web como passatempo ou a integrá-lo no seu conjunto de ferramentas profissionais, é essencial compreender a distinção entre sítios Web estáticos e dinâmicos e saber como fazer scraping eficazmente de ambos. Combinando bibliotecas Python como Requests e Playwright/Selenium com Beautifulsoup, está equipado para lidar com os seus desafios de web scraping.
  • Se os seus scripts de raspagem da Web estiverem a ser detectados como bots e subsequentemente bloqueados, ou se pretender otimizar e simplificar o seu processo de envio de pedidos, considere explorar a nossa API de raspagem da Web. Foi concebida para gerir estes problemas de forma eficiente em seu nome.
  • Lembre-se de que o futuro da raspagem da Web é brilhante e que, ao seguir as melhores práticas e utilizar ferramentas de ponta, pode desbloquear um mundo de dados à espera de serem descobertos.

Pronto para começar a sua aventura de raspagem da Web? Registe-se em ProxyScrape hoje mesmo e explore as infinitas possibilidades da Web com os nossos proxies dedicados, proxies residenciais e uma API de Web Scraping abrangente.

Por: ProxyScrape

Publicações recentes