dark proxyscrape logotipo

Scrape Sites estáticos e dinâmicos com Python e ProxyScrape API

Guias, Python, As diferenças, Maio-10-20245 minutos de leitura

Em um mundo que está se tornando cada vez mais dependente de dados, a capacidade de coletar e analisar grandes quantidades de informações pode proporcionar às empresas e aos profissionais uma vantagem competitiva significativa. A Web scraping, o processo de extração de dados de sites, é uma ferramenta poderosa no arsenal de analistas de dados, desenvolvedores da Web, profissionais de marketing digital e programadores Python. Este guia o conduz pelas técnicas básicas e avançadas da Web scraping , destaca as práticas recomendadas e apresenta a API Web Scraping da ProxyScrape como uma solução flexível para sites estáticos e dinâmicos.

Como identificar se um site é estático ou dinâmico

Para determinar se um site é estático ou dinâmico:

  • Inspecione o código-fonte da página: Clique com o botão direito do mouse e selecione "View Page Source". Se todo o conteúdo estiver visível e corresponder ao que está sendo exibido na página, é provável que seja estático.
  • Use as ferramentas de desenvolvedor do navegador: Abra as ferramentas do desenvolvedor clicando com o botão direito do mouse na página e selecionando "Inspecionar" e, em seguida, observe a guia "Rede" à medida que interage com a página. Se novas solicitações de rede forem feitas em resposta às interações, é provável que seja um site dinâmico.
  • Desativar o JavaScript: Tente desativar o JavaScript nas configurações do navegador e recarregue a página. Se a página parar de funcionar corretamente ou mostrar muito pouco conteúdo, é provável que ela esteja dependendo do JavaScript para buscar e renderizar dados, o que indica uma natureza dinâmica.

Esses métodos representam apenas algumas maneiras de determinar se um site é estático ou dinâmico. Embora existam outras estratégias, analisamos e identificamos essas técnicas, que acreditamos serem amplamente utilizadas e eficazes.

Scraping Sites estáticos com Requests e BeautifulSoup

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

  • Fazendo uma solicitação: Use `requests` para recuperar o conteúdo HTML da página.
  • Análise com a BeautifulSoup: Quando você tiver o conteúdo da página, o `BeautifulSoup` poderá analisar e extrair informações específicas.
importar solicitações
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')

Esse método é perfeito para quem está começando sua jornada na Web scraping . É eficaz para sites com conteúdo estático, exigindo configuração mínima.

Scraping Sites dinâmicos

Os sites dinâmicos apresentam um desafio diferente. Esses sites carregam seu conteúdo de forma assíncrona com JavaScript, o que significa que o HTML scraping simples não funcionará porque os dados não estão presentes no carregamento inicial da página.

Há duas maneiras de abordar o site dinâmico scraping:

  • A primeira abordagem é usar uma biblioteca de automação de navegador, como Playwright/Selenium, para obter o conteúdo e, em seguida, analisá-lo com o Beautifulsoup.
  • A segunda abordagem é como brincar de detetive com a guia de rede para identificar o endpoint que o site usa para buscar seus dados. Em seguida, basta usar o módulo "request" do Python para obter esses dados.

Navegando em sites dinâmicos com o Playwright

Para scrape conteúdo dinâmico, ferramentas como o Playwright imitam a interação de um usuário real com o navegador, permitindo que você scrape dados que são carregados dinamicamente. Aqui está uma breve visão sobre o uso do Playwright com Python:

  • Instalação do Playwright: Instale o pacote Playwright e a ferramenta de linha de comando.
    - "pip install playwright"
    - "playwright install"
  • Uso do Playwright para simular interações: Escreva um script que navegue pelo 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)

      page = browser.new_page()

      page.goto('https://www.scrapethissite.com/pages/ajax-javascript/')

      # Simular interaçõ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 de extremidade da API:

  • Abra as ferramentas de desenvolvedor
    a. Abra o site de seu interesse em seu navegador.
    b. Clique com o botão direito do mouse em qualquer lugar da página e selecione Inspecionar ou pressione Ctrl+Shift+I (Cmd+Option+I no Mac) para abrir as ferramentas do desenvolvedor.
  • Inspecione a guia Rede
    a. Clique na guia Network (Rede) nas ferramentas do desenvolvedor. É nessa guia que você verá todas as solicitações de rede feitas pelo site.
    b. Atualize a página para começar a capturar o tráfego desde o início.
  • Filtrar e identificar solicitações AJAX
    a. Você pode filtrar as solicitações por tipos como XHR (XMLHttpRequest), que são comumente usados para solicitações AJAX.
    b. Interaja com a página - como clicar em botões, preencher formulários ou rolar a tela - para acionar o carregamento dinâmico do conteúdo.
    c. Observe as solicitações de rede que aparecem quando você executa essas ações. Procure por solicitações que busquem dados de seu interesse.
  • Analise a solicitação
    a. Clique em uma solicitação na guia Network que pareça estar recuperando os dados de que você precisa.
    b. Verifique a seção Headers (Cabeçalhos) para ver o método de solicitação (GET, POST, etc.), o URL e outros cabeçalhos.
  • Replicar a solicitação usando o Python
    a. Use as informações da guia Headers 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 da Web Scraping para ambos os cenários

Embora o domínio das solicitações e do Playwright ou de qualquer outra biblioteca de cliente Http possa ser gratificante, é necessário tempo e esforço para lidar com elas corretamente. Uma abordagem alternativa é aproveitar uma API Scraping da Web que abstrai a complexidade das tarefas scraping . Ela não só lida com o envio de solicitações HTTP para você, mas também fornece assistência com técnicas antibanimento para evitar o bloqueio de determinados sites.

Apresentando a API ProxyScrape's Web Scraping

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

Os recursos da API incluem:

  • Fácil integração com sites dinâmicos e estáticos.
  • Suporte abrangente para diferentes tipos de atividades na Web scraping .
  • Amplo pool de endereços IP
  • Oferece até 100.000 solicitações gratuitas, permitindo que os usuários explorem e percebam todo o potencial da API sem investimento imediato.
  • Tecnologia antiban sofisticada, adaptada para sites conhecidos por suas dificuldades scraping .
  • As ações permitem um controle preciso sobre o tempo de recebimento de resultados do site. Isso inclui a espera de uma solicitação de URL específica, a antecipação da aparência de um elemento no site, atividades pós-rolagem e muito mais. Utilização de

ProxyScrape Web Scraping API com um site estático:

Esta é uma ilustração de como você pode incorporar nossa API scraping da Web em seus scripts Python para sites estáticos ou para chamar um endpoint de API que você extraiu 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 site dinâmico:

Aqui está um exemplo em que esperamos que o favicon comece a carregar. Normalmente, essa é a última solicitação a ser iniciada no site de teste que estamos usando. 

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

Práticas recomendadas na Web Scraping

Independentemente das ferramentas ou APIs que você escolher, respeitar os termos de uso do site, limitar as taxas de solicitação para evitar proibições de IP e usar proxies para scraping anônimo são práticas recomendadas essenciais. ProxyScrape A Web Inc. não apenas fornece proxies premium, residencial, móvel e dedicado para essas necessidades, mas também incentiva a ética na Web scraping.

Conclusão

  • scraping Independentemente de você estar usando a Web como um hobby ou integrando-a ao seu kit de ferramentas profissionais, é essencial compreender a distinção entre sites estáticos e dinâmicos e saber como scrape ambos de forma eficaz. scraping Ao combinar bibliotecas Python, como Requests e Playwright/Selenium, com o Beautifulsoup, você estará preparado para lidar com seus desafios na Web.
  • Se os seus scripts da Web scraping estiverem sendo detectados como bots e, posteriormente, bloqueados, ou se você quiser otimizar e simplificar o processo de envio de solicitações, considere explorar a nossa API Web Scraping . Ela foi projetada para gerenciar esses problemas de forma eficiente em seu nome.
  • Lembre-se de que o futuro da Web scraping é brilhante e, ao aderir às práticas recomendadas e aproveitar as ferramentas de ponta, você pode desbloquear um mundo de dados que está esperando para ser descoberto.

Pronto para começar sua aventura na Web scraping ? Inscreva-se no ProxyScrape hoje mesmo e explore as infinitas possibilidades da Web com nossa API dedicada proxies, residencial proxies e abrangente da Web Scraping .

Por: ProxyScrape

Publicações recentes