Para fazer raspagem da web em Python com BeautifulSoup, precisas de duas bibliotecas: requests para descarregar a página web, e beautifulsoup4 para extrair os dados do código HTML.
Instala-os com o comando pip install requests beautifulsoup4, e depois segue o guia abaixo para extrair dados de um site, passo a passo.
Pré-requisitos para raspagem em Python com BeautifulSoup
Antes de começares, não precisas de ser um especialista. Basta saberes ler e executar um script Python é mais do que suficiente para começar.
Eis o que é necessário instalar para começar:
- Instalar Python bem como um ambiente de desenvolvimento.
- Instalar pip, a ferramenta que permite adicionar bibliotecas Python com um único comando.
- Instalar BeautifulSoup :
pip install beautifulsoup4Preste atenção ao nome do pacote: em PyPI, está certo beautifulsoup4 que é preciso escrever. O módulo que vais importar para o teu código chama-se bs4.
- Instalar Requests para descarregar as páginas da Web:
pip install pedidos- Instalar lxml (opcional), um analisador mais rápido que o BeautifulSoup utiliza para analisar o HTML:
pip install lxmlComo fazer web scraping com Python e BeautifulSoup?
Aqui está um projeto completo para recuperar o título de uma página web e todos os ligações que contém.
Passo 1: Recuperar o conteúdo da página com Pedidos
Para descarregar uma página da Web, envias um Pedido HTTP GET para um URL. É essa a função da biblioteca Requests.
A cada pedido, o servidor devolve um código de estado que te indica se tudo correu bem. Os principais que deves conhecer:
- 200 sucesso.
- 301 / 302 redireccionamento.
- 404 Página não encontrada.
- 500 erro interno do servidor.
Com Requests, verifica esse resultado através do atributo .código_de_estado. Eis um exemplo concreto: este código envia um pedido para um site, verifica o código de estado e, se tudo correr bem, apresenta um excerto do conteúdo HTML.
pedidos de importação
# URL de destino
url = "https://bonjour.com"
# Enviar um pedido GET
response = requests.get(url)
# Verificar o código de estado
se response.status_code == 200:
print("Sucesso: a página foi recuperada!")
html = response.text # Conteúdo HTML da página
print("Extrato do conteúdo HTML:")
print(html[:500]) # apresenta apenas os primeiros 500 caracteres
else:
print(f "Erro: código de estado {response.status_code}")
Passo 2: Analisar o código HTML com BeautifulSoup
Quando recuperas o conteúdo de uma página com resposta.texto, obtém-se uma simples cadeia de caracteres: todo o código HTML da página, mas que não pode ser utilizado tal como está. Para o manipular facilmente, cria um objeto BeautifulSoup, que transforma este HTML bruto numa estrutura que podes percorrer e analisar.
Indica sempre um analisador, por exemplo "html.parser. O BeautifulSoup interpreta então corretamente o HTML, sem apresentar qualquer aviso. Também podes utilizar lxml, mais rápido, a instalar separadamente.
from bs4 import BeautifulSoup
importar pedidos
url = "https://bonjour.com"
resposta = requests.get(url)
html = response.text
# Recomenda-se a especificação do analisador
soup = BeautifulSoup(html, "html.parser")
Passo 3: Encontrar e extrair elementos
O HTML é agora um objeto BeautifulSoup. Podes procurar e recuperar os dados que te interessam, tag a tag. Três métodos cobrem a maioria das necessidades.
Utilizar as funções find() e find_all()
encontrar() devolve o primeiro elemento encontrado. find_all() remete a lista completa os elementos correspondentes.
# Recuperar título <h1>
h1 = soup.find("h1")
print(h1.get_text())
# Recuperar todas as ligações <a>
liens = soup.find_all("a")
for lien in liens:
print(lien.get_text(), lien.get("href"))
Seleção de elementos por atributo
Podes refinar a pesquisa com base num atributo HTML, como aula, eu ia ou qualquer outro. Anotar : em Python, escreve-se classe_ e não aula, para evitar conflitos com a palavra reservada da linguagem.
# Recuperar um div com um id específico
contêiner = soup.find("div",)
# Obter todos os links com uma classe específica
links_nav = soup.find_all("a", class_="nav-link")
Utilizar seletores CSS com a função select()
Para pesquisas mais precisas, o método selecionar() aceita Seletores CSS. Podes selecionar exatamente determinadas partes de uma página, sem teres de percorrer todo o código HTML manualmente.
# Todas as ligações nos títulos dos artigos
links_do_artigo = soup.select("artigo h2 a")
# Todos <a> cujo atributo href começa por "http".
links_http = soup.select('a[href^="http"]')
Como extrair dados de uma tabela HTML com o BeautifulSoup?
Os casos de utilização reais são frequentemente mais complexos do que apenas recuperar um título ou um link. Vais ter de gerir o’extração de dados estruturados tal como as tabelas e as listas, a paginação, e os erros mais comuns no scraping.
Extrair tabelas e listas
Os sítios Web apresentam frequentemente os seus dados em Tabelas HTML (<table>, <tr>, <th>, <td>) ou listas (). Para transformar estas estruturas em dados utilizáveis, tens de as percorrer linha a linha ou elemento a elemento.
Para extrair um tabela HTMLO princípio é simples:
- Recuperar os cabeçalhos (
<th>) para identificar os títulos das colunas. - Percorrer cada linha (
<tr>) e procurar células (<td>) que contêm os dados. - Armazenar as informações numa lista ou num dicionário.
Para um Lista HTML (
- Identificar todas as balizas
com find_all. - Recuperar o seu conteúdo (texto ou ligação) e adicioná-lo a uma lista em Python.
Eis um exemplo com uma tabela:
html = """
<table>
<tr>
<th>Sobrenome</th>
<th>Idade</th>
<th>Cidade</th>
</tr>
<tr>
<td>Alice</td>
<td>25</td>
<td>Paris</td>
</tr>
<tr>
<td>Prumo</td>
<td>30</td>
<td>Lyon</td>
</tr>
</table>
"""
# Criar o objeto BeautifulSoup
soup = BeautifulSoup(html, "html.parser")
# Extrair os cabeçalhos da matriz
cabeçalhos = [th.get_text(strip=True) for th in soup.find_all("th")]
print("Cabeçalhos:", cabeçalhos)
# Extrair as linhas de dados (ignorar a 1ª linha, uma vez que são os cabeçalhos)
linhas = []
for tr in soup.find_all("tr")[1:]:
células = [td.get_text(strip=True) for td in tr.find_all("td")]
if cells:
rows.append(cells)
print("Linhas :", linhas)
Aqui, find_all("th") recupera os cabeçalhos e find_all("td") recupera as células de cada linha. Fazes um ciclo pelas <tr> para reconstruir a tabela linha a linha.
Eis um exemplo baseado numa lista:
from bs4 import BeautifulSoup
html_list = """
- Apple
- Banana
- Laranja
"""
soup = BeautifulSoup(html_list, "html.parser")
# Recuperar itens da lista
itens = [li.get_text(strip=True) for li in soup.find_all("li")]
print("Lista extraída:", items) # ["Maçã", "Banana", "Laranja"]
Cada é transformado diretamente em elemento de lista em Python, o que dá o resultado ["Maçã", "Banana", "Laranja"]..
Gerir a paginação e as ligações
Muitas vezes, os dados não cabem numa única página. São distribuídos através de ligações de “próxima página” ou um paginação numerada (?página=1, ?página=2, etc.). Em ambos os casos, tens de enrolar para recuperar todas as páginas e combinar os dados.
Exemplo com um parâmetro «page»:
tempo de importação
importar pedidos
from bs4 import BeautifulSoup
# Exemplo de URL com paginação
BASE_URL = "https://bonjour.com/articles?page={}"
HEADERS = {"User-Agent": "Mozilla/5.0"}
todos_artigos = []
# Suponha que há 5 páginas para navegar
for page in range(1, 6):
url = BASE_URL.format(page)
r = requests.get(url, headers=HEADERS, timeout=20)
se r.status_code == 200:
soup = BeautifulSoup(r.text, "html.parser")
# Extrair títulos de artigos
artigos = [h2.get_text(strip=True) for h2 in soup.find_all("h2", class_="title")]
todos_artigos.extend(artigos)
else:
print(f "Erro na página {page} (código : {r.status_code})")
time.sleep(1.0) # polidez
print("Artigos recuperados:", todos_artigos)Uma breve explicação passo a passo:
- Prepara o’URL com um local
{}para inserir o número da página.
BASE_URL = "https://bonjour.com/articles?page={}- Alguns sites bloqueiam os pedidos que não incluem a identificação do navegador. Adicionar um User-Agent evita que o considerem um bot.
headers = {"User-Agent": "Mozilla/5.0"}
requests.get(url, headers=headers) - Loop da página 1 a 5.
para página em range(1, 6):- Recupera o código HTML da página com requests.
requests.get(url)- Limita o tempo de espera caso o site não responda (timeout de 20 segundos).
requests.get(url, timeout=20)- Analisa a página com BeautifulSoup.
BeautifulSoup(response.text, "html.parser")- Recupera todos os títulos de artigos.
find_all("h2", class_="title")- Adiciona os artigos encontrados a uma lista global.
all_articles.extend(articles)- Introduz uma pausa entre cada pedido, para não sobrecarregar o servidor e evitar ser banido.
time.sleep(1.0)Depois do loop, todos_artigos contém todos os títulos das 5 páginas.
Erros e desafios comuns
O scraping não se resume a carregar num botão. Vais deparar-te com obstáculos frequentes:
- Erros HTTP : 404 (página não encontrada), 403 (acesso proibido) e 500 (erro do lado do servidor).
Exemplo de gestão:
response = requests.get(url)
if response.status_code == 200:
print("Página recuperada com sucesso")
elif response.status_code == 404:
print("Erro: página não encontrada")
else:
print("Código devolvido:", response.status_code)
- Sites que bloqueiam o scraping : alguns detetam os pedidos automáticos e bloqueiam o acesso.
- Páginas dinâmicas (JavaScript) : BeautifulSoup só lê o HTML estático. Se a página carregar o seu conteúdo com JavaScript, não verás nada. Nesse caso, deves utilizar uma ferramenta como Selenium Onde Playwright.
Para fazer scraping de forma eficaz, sem seres bloqueado nem danificares o site, eis as melhores práticas:
- Respeita o ficheiro robots.txt do site que queres analisar.
- Implementa prazos entre as consultas com
time.sleep()para não sobrecarregar o servidor. - Utiliza proxies e faz com que girem.
- Muda regularmente o teu User-Agent.
Como é que posso fazer scrap na Web com o Selenium e o BeautifulSoup?
Selenium controlar um navegador real, executa o JavaScript e apresenta a página como se fosse um utilizador a navegar nela. BeautifulSoup Em seguida, analisa o HTML assim que a página estiver totalmente carregada e extrai todos os dados que desejares.
Passo 1: Instalar o Selenium e o BeautifulSoup
Aqui, em vez de requests, usas Selenium para recuperar o conteúdo da página. Instala as duas bibliotecas com este comando:
pip install selenium beautifulsoup4Em seguida, tens de descarregar um WebDriver adaptado à versão do teu navegador. No caso do Google Chrome, é ChromeDriver. Tens duas opções: colocá-lo na mesma pasta que o teu script Python, ou o’adicionar à variável de ambiente PATH do teu sistema.
Passo 2: Configurar o Selenium
Começa por importar webdriver através do Selenium para controlar o navegador.
from selenium import webdriver
from selenium.webdriver.common.by import ByEm seguida, abre um navegador. É ele que abre a página e executa o JavaScript, neste caso o Chrome.
driver = webdriver.Chrome()Indica ao navegador qual URL visitar.
driver.get("https://www.exemple.com")Se a página demorar a apresentar determinados elementos, podes pedir ao Selenium para esperar até 10 segundos.
driver.implicitly_wait(10)Passo 3: Recuperar o conteúdo da página
Assim que a página estiver carregada, obténs o DOM completo : o código-fonte HTML obtido após a execução do JavaScript.
html_content = driver.page_sourcePasso 4: Análise HTML com BeautifulSoup
Envia agora este código-fonte para Bela Sopa para o utilizar:
from bs4 import BeautifulSoup
# Criar um objeto BeautifulSoup
soup = BeautifulSoup(html_content, 'html.parser')
# Exemplo: recuperar todos os títulos da página
títulos = soup.find_all('h2')
for título in títulos:
print(título.get_text())O BeautifulSoup oferece métodos poderosos como find(), find_all() e os seletores CSS para identificar e extrair elementos específicos do HTML.
Passo 5: Fechar o browser
Muito importante: fecha sempre o teu navegador após a execução para libertar recursos.
driver.quit()Desta forma, combinas o poder de Selenium por simular a navegação humana (cliques, deslocamentos) com a eficiência do BeautifulSoup na análise de HTML. É o método ideal para extrair dados de um site que carrega os seus dados em JavaScript.
Perguntas frequentes
Qual é a melhor ferramenta para a recolha de dados da Web em Python?
Não há nenhum’ferramenta de raspagem soluções universais, mas sim soluções adaptadas ao teu projeto. Aqui estão as três mais utilizadas:
- BeautifulSoup : simples e eficaz para analisar HTML e extrair conteúdo rapidamente. Ideal se estás a começar ou se tens projetos pequenos.
- Scrapy : um framework completo, concebido para gerir grandes volumes de dados com funcionalidades avançadas.
- Playwright : ideal para sites complexos gerados por JavaScript. Simula um navegador real e interage com a página tal como um ser humano.
Como utilizar o BeautifulSoup para extrair o conteúdo de uma tag div?
Com BeautifulSoup, selecionas uma baliza específica através de um Seletor CSS. Para extrair o conteúdo de uma baliza <div>, segue estes passos.
1. Obter a página web com requests, e depois analisar o HTML com BeautifulSoup.
from bs4 import BeautifulSoup
import requests
url = "URL_DE_TON_SITE" # Remplace par l'URL réelle
reponse = requests.get(url)
html_content = reponse.text
soup = BeautifulSoup(html_content, "html.parser")2. Utilizar o método selecionar() com o teu seletor CSS para selecionar a baliza <div>.
Para recuperar o primeiro elemento, utiliza sopa.select_one. Para recuperar todos os elementos, utiliza sopa.selecionar. Aqui está um exemplo de código HTML:
<div>
<h2>Titre de l'article</h2>
<p>Voici le contenu du paragraphe.</p>
</div>E aqui está o exemplo com o seletor CSS div.article :
# Récupérer le premier div avec la classe "article"
div_article = soup.select_one("div.article")
# Afficher son contenu texte
if div_article:
print(div_article.get_text(strip=True))3. Retirar os elementos que se encontram no interior da <div>.
# Récupérer le titre à l'intérieur du div
titre = soup.select_one("div.article h2").get_text()
# Récupérer le paragraphe à l'intérieur du div
paragraphe = soup.select_one("div.article p").get_text()
print("Titre :", titre)
print("Paragraphe :", paragraphe)Como é que o Requests e o BeautifulSoup podem ser utilizados em conjunto?
Estas duas bibliotecas são adicionais : uma carrega a página, a outra analisa-a.
1. requests envia um pedido HTTP e descarrega o código HTML sem formatação da página.
import requests
url = "https://sitecible.com"
response = requests.get(url) # requête HTTP
print(response.text) # affiche le HTML brutNesta fase, só tens um texto enorme cheio de marcadores (<html>, <div>, <p>etc.).
2. BeautifulSoup analisa este HTML bruto e transforma-o numa estrutura organizada. Podes, então, navegar pela página, localizar as etiquetas e extrair os dados.
from bs4 import BeautifulSoup
soup = BeautifulSoup(response.text, "html.parser") # analyse le HTML
titre = soup.find("h1").get_text() # extrait le contenu d'un <h1>
print(titre)Porque é que o meu código de recolha de dados da Web não funciona em alguns sítios?
Pode acontecer que o teu script não recupere nada. Alguns sites não disponibilizam todo o seu conteúdo diretamente em HTML: utilizam JavaScript para carregar os dados dinamicamente. No entanto, BeautifulSoup não consegue analisar os dados gerados pelo JavaScript. Nesse caso, deves recorrer a ferramentas como Playwright Onde Selenium.
Que papel desempenha a BeautifulSoup na recolha de dados da Web?
BeautifulSoup desempenha o papel de’Analisador HTML. Transforma o código de uma página num objeto estruturado que podes percorrer facilmente. Em suma, é o tradutor entre o HTML bruto e o teu código Python.
Web scraping: BeautifulSoup ou Scrapy?
BeautifulSoup e Scrapy são realmente diferentes, embora ambos sirvam para raspagem da web.
| BeautifulSoup | Scrapy |
|---|---|
| Uma biblioteca simples utilizada apenas para analisar HTML e extrair dados. | Um framework completo que gere todo o processo de scraping: pedidos, rastreio de links, paginação, exportação de dados e gestão de erros. |
BeautifulSoup é a escolha perfeita para quem está a começar: torna o’Extração de dados HTML em Python simples e rápido.
Se preferires reduzir ao mínimo a parte do código, a ferramenta Dados brilhantes oferece conjuntos de dados prontos a utilizar para reduzir a parte do código.
Português