pt 
English 
Español 
中國人 
Tiếng Việt 
Deutsch 
Українська 
Français 
भारतीय 
Türkçe 
한국인 
Italiano 
Gaeilge 
اردو 
Indonesia 
Polski O Python destaca-se como uma das principais opções para raspagem da Web devido às suas bibliotecas robustas e sintaxe simples. Neste artigo, exploraremos os fundamentos da raspagem da Web e o orientaremos na configuração do ambiente Python para criar seu primeiro raspador da Web. Apresentaremos as principais bibliotecas Python adequadas para tarefas de raspagem, incluindo Beautiful Soup, Playwright e lxml.
O Python fornece várias bibliotecas para facilitar a raspagem da Web. Aqui estão algumas das mais usadas:
O HTTP (HyperText Transfer Protocol) é um protocolo da camada de aplicação para a transferência de dados através da Web. O utilizador escreve um URL no browser, que gera um pedido HTTP e o envia para o servidor Web. Em seguida, o servidor Web envia a resposta HTTP para o navegador, que a apresenta como uma página HTML. Para a raspagem da Web, é necessário imitar esse processo e gerar solicitações HTTP a partir do seu script para obter o conteúdo HTTP das páginas da Web de forma programática.
Primeiro, certifique-se de ter o Python instalado no seu sistema. Você pode baixá-lo do site oficial do Python.
Um ambiente virtual ajuda a gerenciar dependências. Use esses comandos para criar e ativar um ambiente virtual:
PHP
Node.js
Python
Java
Golang
python -m venv scraping_env
source scraping_env/bin/activate
De seguida, instale os pacotes necessários utilizando os seguintes comandos:
pip install requests
pip install beautifulsoup4
pip install lxml
Vamos começar com um simples web scraper usando a requisição para raspar conteúdo HTML estático.
O tipo mais comum de solicitação HTTP é a solicitação GET, que é usada para recuperar dados de um URL especificado. Aqui está um exemplo básico de como executar uma solicitação GET para http://example.com.
import requests
url = 'http://example.com'
response = requests.get(url)
A biblioteca requests fornece várias maneiras de lidar e processar a resposta:
Verificar código de status: garante que a solicitação foi bem-sucedida.
if response.status_code == 200:
print('Request was successful!')
else:
print('Request failed with status code:', response.status_code)
Extração de conteúdo: extrair o texto ou conteúdo JSON da resposta.
# Obter o conteúdo da resposta como texto
page_content = response.text
print(page_content)
# Obter o conteúdo da resposta como JSON (se a resposta estiver no formato JSON)
json_content = response.json()
print(json_content)
Os erros de HTTP e de rede podem ocorrer quando um recurso não está acessível, uma solicitação expirou ou o servidor retorna um status HTTP de erro (por exemplo, 404 Not Found, 500 Internal Server Error). Podemos usar os objetos de exceção levantados por solicitações para lidar com essas situações.
import requests
url = 'http://example.com'
try:
response = requests.get(url, timeout=10) # Set a timeout for the request
response.raise_for_status() # Raises an HTTPError for bad responses
except requests.exceptions.HTTPError as http_err:
print(f'HTTP error occurred: {http_err}')
except requests.exceptions.ConnectionError:
print('Failed to connect to the server.')
except requests.exceptions.Timeout:
print('The request timed out.')
except requests.exceptions.RequestException as req_err:
print(f'Request error: {req_err}')
else:
print('Request was successful!')
Para o web scraping, muitas vezes precisamos de extrair dados do conteúdo HTML. Esta parte vai falar sobre como localizar e extrair dados de elementos HTML com algumas bibliotecas como Beautiful Soup ou lxml.
HTML (HyperText Markup Language) é a linguagem de marcação padrão para a criação de páginas web. Ela consiste em elementos aninhados representados por tags, como <div>, <p>, <a>, etc. Cada tag pode ter atributos e conter texto, outras tags, ou ambos.
Os seletores XPath e CSS fornecem uma maneira versátil de selecionar elementos HTML com base em seus atributos ou em sua posição no documento.
Ao fazer web scraping, a extração de dados específicos de páginas da Web geralmente requer a identificação dos seletores XPath ou CSS corretos para direcionar elementos HTML. Veja como encontrar esses seletores de forma eficiente:
A maioria dos navegadores Web modernos vem com ferramentas de desenvolvimento incorporadas que permitem inspecionar a estrutura HTML das páginas Web. Aqui está um guia passo a passo sobre como usar essas ferramentas:
XPath: /html/body/div/h1
CSS Selector: body > div > h1
Beautiful Soup é uma biblioteca Python para analisar documentos HTML e XML. Ela fornece métodos e atributos simples para navegar e pesquisar na estrutura HTML.
from bs4 import BeautifulSoup
import requests
# URL da página Web a extrair
url = 'https://example.com'
# Enviar um pedido HTTP GET para o URL
response = requests.get(url)
# Analisar o conteúdo HTML da resposta usando Beautiful Soup
soup = BeautifulSoup(response.content, 'html.parser')
# Utilize o seletor CSS para encontrar todas as etiquetas <h1> que estão dentro de etiquetas <div>
# Que são filhos diretos da etiqueta <body>
h1_tags = soup.select('body > div > h1')
# Iterar sobre a lista de etiquetas <h1> encontradas e imprimir o seu conteúdo de texto
for tag in h1_tags:
print(tag.text)
Os erros de análise ocorrem quando a estrutura HTML ou XML não é a esperada, causando problemas na extração de dados. Estes podem ser geridos através do tratamento de excepções como AttributeError.
from bs4 import BeautifulSoup
import requests
# URL da página Web a extrair
url = 'https://example.com'
# Enviar um pedido HTTP GET para o URL
response = requests.get(url)
try:
# Analisar o conteúdo HTML da resposta usando Beautiful Soup
soup = BeautifulSoup(response.content, 'html.parser')
# Utilize o seletor CSS para encontrar todas as etiquetas <h1> que estão dentro de etiquetas <div>
# Que são filhos diretos da etiqueta <body>
h1_tags = soup.select('body > div > h1')
# Iterar sobre a lista de etiquetas <h1> encontradas e imprimir o seu conteúdo de texto
for tag in h1_tags:
print(tag.text)
except AttributeError as attr_err:
# Trata dos casos em que pode ocorrer um AttributeError (por exemplo, se o response.content for None)
print(f'Attribute error occurred: {attr_err}')
except Exception as parse_err:
# Tratar quaisquer outras excepções que possam ocorrer durante a análise
print(f'Error while parsing HTML: {parse_err}')
Além da Beautiful Soup, outra biblioteca popular para analisar documentos HTML e XML em Python é a lxml. Enquanto o BeautifulSoup se concentra em fornecer uma interface conveniente para navegar e manipular dados analisados, o lxml é conhecido por sua velocidade e flexibilidade, tornando-o uma escolha preferida para tarefas críticas de desempenho.
from lxml.html import fromstring
import requests
# URL da página Web a extrair
url = 'https://example.com'
# Enviar um pedido HTTP GET para o URL
response = requests.get(url)
# Analisa o conteúdo HTML da resposta utilizando o método fromstring do lxml
parser = fromstring(response.text)
# Utilize XPath para encontrar o conteúdo de texto da primeira etiqueta <h1>
# que está dentro de uma etiqueta <div>, que é uma filha direta da etiqueta <body>
title = parser.xpath('/html/body/div/h1/text()')[0]
# Imprimir o título
print(title)
Semelhante ao Beautiful Soup, lxml permite que você lide com erros de análise graciosamente pegando exceções como lxml.etree.XMLSyntaxError.
from lxml.html import fromstring
from lxml import etree
import requests
# URL da página Web a extrair
url = 'https://example.com'
# Enviar um pedido HTTP GET para o URL
response = requests.get(url)
try:
# Analisa o conteúdo HTML da resposta utilizando o método fromstring do lxml
parser = fromstring(response.text)
# Utilize XPath para encontrar o conteúdo de texto da primeira etiqueta <h1>
# que está dentro de uma etiqueta <div>, que é uma filha direta da etiqueta <body>
title = parser.xpath('/html/body/div/h1/text()')[0]
# Imprimir o título
print(title)
except IndexError:
# Tratar o caso em que a consulta XPath não devolve quaisquer resultados
print('No <h1> tag found in the specified location.')
except etree.XMLSyntaxError as parse_err:
# Tratar erros de sintaxe XML durante a análise
print(f'Error while parsing HTML: {parse_err}')
except Exception as e:
# Tratar quaisquer outras excepções
print(f'An unexpected error occurred: {e}')
Depois de ter extraído com sucesso os dados dos elementos HTML, o próximo passo é salvar esses dados. O Python fornece várias opções para salvar dados extraídos, incluindo salvar em arquivos CSV, arquivos JSON e bancos de dados. Aqui está uma visão geral de como salvar dados extraídos usando diferentes formatos:
CSV (Comma-Separated Values) é um formato simples e amplamente usado para armazenar dados tabulares. O módulo CSV em Python facilita a gravação de dados em arquivos CSV.
import csv
# Dados de amostra
data = {
'title': 'Example Title',
'paragraphs': ['Paragraph 1', 'Paragraph 2', 'Paragraph 3']
}
# Guardar dados num ficheiro CSV
with open('scraped_data.csv', mode='w', newline='', encoding='utf-8') as file:
writer = csv.writer(file)
writer.writerow(['Title', 'Paragraph'])
for paragraph in data['paragraphs']:
writer.writerow([data['title'], paragraph])
print('Data saved to scraped_data.csv')
JSON (JavaScript Object Notation) é um formato leve de troca de dados que é fácil de ler e escrever. O módulo JSON em Python fornece métodos para salvar dados no formato JSON.
import json
# Dados de amostra
data = {
'title': 'Example Title',
'paragraphs': ['Paragraph 1', 'Paragraph 2', 'Paragraph 3']
}
# Guardar dados num ficheiro JSON
with open('scraped_data.json', mode='w', encoding='utf-8') as file:
json.dump(data, file, ensure_ascii=False, indent=4)
print('Data saved to scraped_data.json')
O Playwright é uma ferramenta poderosa para raspar conteúdo dinâmico e interagir com elementos da Web. Ele pode lidar com sites com muito JavaScript que os analisadores HTML estáticos não conseguem.
Instale o Playwright e configure-o:
pip install playwright
playwright install
O Playwright permite-lhe interagir com elementos da Web, como preencher formulários e clicar em botões. Ele pode aguardar que as solicitações AJAX sejam concluídas antes de prosseguir, tornando-o ideal para raspar conteúdo dinâmico.
O código fornecido executa a raspagem da Web em uma página de produto da Amazon usando o Playwright e o lxml. Inicialmente, os módulos necessários são importados. Uma função de execução é definida para encapsular a lógica de raspagem. A função começa por configurar um servidor proxy e lançar uma nova instância do browser com o proxy e em modo sem cabeça, permitindo-nos observar as acções do browser. No contexto do navegador, uma nova página é aberta e navegada para o URL do produto Amazon especificado, com um tempo limite de 60 segundos para garantir que a página seja totalmente carregada.
O script interage então com a página para selecionar um estilo de produto específico a partir de um menu pendente e uma opção de produto utilizando localizadores e correspondência de texto. Depois de garantir que essas interações sejam concluídas e que a página seja totalmente carregada novamente, o conteúdo HTML da página é capturado.
O conteúdo HTML é então analisado usando o método fromstring do lxml para criar uma árvore de elementos. Uma consulta XPath é usada para extrair o conteúdo de texto do título do produto de um elemento específico com o ID productTitle. O script inclui tratamento de erros para gerir os casos em que a consulta XPath não devolve resultados, em que existem erros de sintaxe XML durante a análise ou quaisquer outras excepções inesperadas. Finalmente, o título do produto extraído do tlxml é impresso e o contexto do navegador e o navegador são fechados para encerrar a sessão.
A função run é executada em uma sessão do Playwright iniciada por sync_playwright, garantindo que todo o processo seja gerenciado e executado em um ambiente controlado. Essa estrutura garante robustez e resiliência a erros durante a execução da tarefa de raspagem da Web.
from playwright.sync_api import Playwright, sync_playwright
from lxml.html import fromstring, etree
def run(playwright: Playwright) -> None:
# Definir o servidor proxy
proxy = {"server": "https://IP:PORT", "username": "LOGIN", "password": "PASSWORD"}
# Lançar uma nova instância do browser com o proxy especificado e em modo sem cabeça
browser = playwright.chromium.launch(
headless=False,
proxy=proxy,
slow_mo=50,
args=['--ignore-certificate-errors'],
)
# Criar um novo contexto de browser
context = browser.new_context(ignore_https_errors=True)
# Abrir uma nova página no contexto do browser
page = context.new_page()
# Navegar para a página de produto Amazon especificada
page.goto(
"https://www.amazon.com/A315-24P-R7VH-Display-Quad-Core-Processor-Graphics/dp/B0BS4BP8FB/",
timeout=10000,
)
# Aguardar que a página seja totalmente carregada
page.wait_for_load_state("load")
# Selecione um estilo de produto específico no menu pendente
page.locator("#dropdown_selected_style_name").click()
# Selecionar uma opção de produto específica
page.click('//*[@id="native_dropdown_selected_style_name_1"]')
page.wait_for_load_state("load")
# Get the HTML content of the loaded page
html_content = page.content()
try:
# Analisar o conteúdo HTML utilizando o método fromstring do lxml
parser = fromstring(html_content)
# Utilizar XPath para extrair o conteúdo de texto do título do produto
product_title = parser.xpath('//span[@id="productTitle"]/text()')[0].strip()
# Imprimir o título do produto extraído
print({"Product Title": product_title})
except IndexError:
# Tratar o caso em que a consulta XPath não devolve quaisquer resultados
print('Product title not found in the specified location.')
except etree.XMLSyntaxError as parse_err:
# Tratar erros de sintaxe XML durante a análise
print(f'Error while parsing HTML: {parse_err}')
except Exception as e:
# Tratar quaisquer outras excepções
print(f'An unexpected error occurred: {e}')
# Fechar o contexto do browser e o browser
context.close()
browser.close()
# Utilize sync_playwright para iniciar a sessão do Playwright e executar o script
with sync_playwright() as playwright:
run(playwright)
O Web scraping com Python é um método poderoso de recolha de dados de sítios Web. As ferramentas discutidas facilitam a extração, o processamento e o armazenamento de dados da Web para vários fins. Neste processo, a utilização de servidores proxy para alternar endereços IP e a implementação de atrasos entre pedidos são cruciais para contornar bloqueios. O Beautiful Soup é de fácil utilização para principiantes, enquanto o lxml é adequado para lidar com grandes conjuntos de dados graças à sua eficiência. Para necessidades de raspagem mais avançadas, especialmente com sítios Web JavaScript carregados dinamicamente, o Playwright revela-se altamente eficaz.
Comentários: 0