Como fazer web scraping em Python com BeautifulSoup?

Queres mergulhar no mundo do raspagem da web mas sem ficar atolado em códigos complicados?

Com Python e a biblioteca Bela Sopa, você pode facilmente extrair e organizar dados de um site em apenas algumas linhas.

Web scraping em Python com BeautifulSoup. Cristina para Alucare.fr

Pré-requisitos para raspagem em Python com BeautifulSoup

✅ Antes de começar, é importante ter algumas noções básicas de programação. Isto dar-lhe-á uma melhor compreensão do funcionamento do código. Não é preciso ser especialista, mas saber ler e executar um script Python ajudará bastante.

Em seguida, eis o que tem de fazer primeiro para fazer recolha de dados em Python com BeautifulSoup :

✔ Instalar Python bem como um ambiente de desenvolvimento.
✔ Instalar tubagem, a ferramenta que permite adicionar facilmente bibliotecas Python.
✔ Instalar Bela Sopa com o comando :

pip install beautifulsoup4

✔ Instalar Pedidos para obter páginas Web com o comando :

pip install pedidos

Como fazer web scraping com Python e BeautifulSoup?

Siga o nosso tutorial para um projeto simples de raspagem da Web.

Imagem que mostra como funciona o web scraping em Python com BeautifulSoup. Cristina para Alucare.fr

Projeto : recuperar o título de uma página e todos os links que ela contém.

Passo 1: Recuperar o conteúdo da página com Pedidos

Para efetuar uma Pedido HTTP GET para um URL, utilize o Pedidos.

Quando envia um pedido HTTP com Requests, o servidor devolve sempre um código de estado. Estes códigos indicam se o pedido foi bem sucedido ou não.

200 sucesso.
301 / 302 redireccionamento.
404 Página não encontrada.
500 erro interno do servidor.

Com Pedidos, pode verificar o resultado de uma consulta através do atributo .código_de_estado. Aqui está um exemplo de código que envia um pedido para bonjour.comque verifica o código de estado e apresenta um extrato do conteúdo HTML se tudo estiver bem:

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 recupera o conteúdo de uma página com Pedidos (resposta.texto), obtém-se uma cadeia de caracteres que contém todo o código HTML da página. Para manipular esse HTML facilmente, usamos Bela Sopa para criar um objeto Bela Sopa.

Quando passa o HTML em bruto para a BeautifulSoup, tem de especificar um analisador (exemplo: "html.parser). Isso permite que o BeautifulSoup interprete corretamente o HTML e evite avisos.

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

Depois de ter transformado o HTML num Bela Sopapode começar a procurar e a obter os dados em que está interessado (etiquetas HTML).

Utilização encontrar() e find_all()

# 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

É possível refinar a pesquisa por atributos como aula, eu ia ou qualquer outro atributo HTML.

⚠️ Observação Em Python, escrevemos classe_ ao invés de aula para evitar conflitos com a palavra reservada aula.

# Recuperar uma div com um id específico
contentor = soup.find("div", id="main")

# Recuperar todos os links com uma classe específica
nav_links = soup.find_all("a", class_="nav-link")

Utilizar selectores CSS com selecionar()

Para pesquisas mais precisas, utilize selecionar() com selectores CSS.

# 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"]')

o Seletores CSS são muito poderosos se quiser direcionar exatamente certas partes de uma página sem percorrer todo o HTML manualmente.

Como extrair dados de uma tabela HTML com o BeautifulSoup?

Extrair dados de uma tabela HTML utilizando BeautifulSoup. — Extrair dados de uma tabela HTML com BeautifulSoup. ©Christina para Alucare.fr

Até agora, vimos como recuperar títulos, links ou texto de uma página web.

⚠ Mas, muitas vezes, os casos reais de utilização são mais complexos: extração de dados estruturados como tabelas ou listas, gestão de paginação ou ainda resolução de erros frequentes relacionados com scraping. É exatamente isso que vamos ver juntos.

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, é necessário aprender a percorrê-las linha a linha ou elemento a elemento.

Sempre que quiser extrair uma tabela HTMLO princípio é simples:

✅ Recuperar cabeçalhos (<th>) para identificar os títulos das colunas.
✅ Navegar em cada linha (<tr>) e procurar células (<td>) que contêm os dados reais.
Armazenar informações numa lista ou num dicionário.

Para um Lista HTML (

) :

Localizar todas as etiquetas
com encontrar_todos.
Recuperar o seu conteúdo (texto ou ligação) e adicioná-lo a uma lista Python.

Resumindo :

As etiquetas <table>, <tr>, <th>, <td> são utilizados para reconstruir uma tabela.
As etiquetas

são usadas para transformar uma lista HTML numa lista 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 cabeçalhos e find_all("td") recupera as células de cada linha. Fazemos um loop sobre as <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"]

Aqui, cada

é transformado diretamente num item de lista Python, dando 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 por várias páginas utilizando “próxima página” ou um paginação numerada (?page=1, ?page=2, ...).

Em ambos os casos, é necessário enrolar (navegar num ciclo) para ir buscar todas as páginas e fundir os dados.

Exemplo com um parâmetro de página :

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:

Prepare o URL com um espaço {} para inserir o número da página.

BASE_URL = "https://bonjour.com/articles?page={}

Alguns sites bloqueiam pedidos sem «identidade do navegador». Adicionar um User-Agent evita que seja confundido com um bot.

headers = {"User-Agent": "Mozilla/5.0"}
requests.get(url, headers=headers)

Repetir da página 1 à 5.

para página em range(1, 6):

Recupera o HTML da página.

requests.get(url)

Limitar o tempo de espera se o sítio não responder.

requests.get(url, timeout=20)

Analisar a página.

BeautifulSoup(response.text, "html.parser")

Recuperar todos os títulos dos artigos.

find_all("h2", class_="title")

Adicionar itens encontrados a uma lista global.

all_articles.extend(articles)

Introduzir 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 nem sempre é tão simples quanto clicar num botão e pronto. Poderá encontrar obstáculos frequentes, tais como:

Erros HTTP

404 página não encontrada
403 sem acesso
500 erro do lado do servidor

Exemplo :

resposta = requests.get(url)
se response.status_code == 200:
    # Página OK
    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 detectam as solicitações automáticas e bloqueiam o acesso.

Páginas dinâmicas (JavaScript)

BeautifulSoup só lê HTML estático. Se a página carregar seu conteúdo com JavaScriptnão verá nada.

Neste caso, utilize ferramentas como Selénio Onde Dramaturgo.

No entanto, se quiser fazer scraping eficazmente sem ser bloqueado ou danificar o sítio, eis as melhores práticas:

Respeitar a ficheiro robots.txt de um site.
Configuração prazos entre pedidos para não sobrecarregar o servidor (utilizando time.sleep()).
✔ Utilização proxies e rodá-los.
Mudar regularmente a sua Agente de usuário.

Como é que posso fazer scrap na Web com o Selenium e o BeautifulSoup?

Web scraping com Selenium e BeautifulSoup no Chrome. Cristina para Alucare.fr

⚠ Um lembrete : BeautifulSoup é um excelente analisador HTML, mas não consegue executar JavaScript de uma página web. É aí que o Selenium se torna seu aliado!

Basicamente, o Selénio controlar um navegador realEle executa o JavaScript e exibe a página como se um ser humano estivesse navegando. O BeautifulSoup analisará o código HTML quando a página estiver totalmente renderizada. Assim, pode extrair o que quiser.

Passo 1: Instalar o Selenium e o BeautifulSoup

Aqui, em vez de usar a biblioteca Request, vamos usar Selénio. Para instalá-lo, é necessário passar por tubagem.

pip install selenium beautifulsoup4

Em seguida, é necessário descarregar e instalar um WebDriver que corresponde à versão do seu navegador (por exemplo, ChromeDrive para Google Chrome).

✅ Pode colocá-lo na mesma pasta que o seu script Python ouadicionar à variável de ambiente PATH do seu sistema.

Passo 2: Configurar o Selenium

Antes de mais, é necessário importar piloto web do Selenium para controlar um navegador.

from selenium import webdriver
from selenium.webdriver.common.by import By

Em seguida, iniciamos um navegador. É ele que abrirá a página web e executará o JavaScript (Exemplo: Chrome).

driver = webdriver.Chrome()

O utilizador diz ao browser qual a página a visitar.

driver.get("https://www.exemple.com")

Se a página demorar a exibir determinados elementos, pode indicar ao Selenium para aguardar um pouco.

driver.implicitly_wait(10)

Passo 3: Recuperar o conteúdo da página

Depois de a página ter sido carregada, pode obter o DOM completo (código fonte HTML após a execução do JS).

html_content = driver.page_source

Passo 4: Análise HTML com BeautifulSoup

Agora passe esse código-fonte para o BeautifulSoup para poder explorá-lo:

from bs4 import BeautifulSoup # Criar um objeto BeautifulSoup soup = BeautifulSoup(html_content, 'html.parser') # Exemplo: obter todos os títulos da página titles = soup.find_all('h2') for title in titles: print(title.get_text())

O BeautifulSoup oferece métodos poderosos, como find(), find_all() e selectores CSS para objetivo e extrair elementos Código HTML.

Passo 5: Fechar o browser

Muito importante: feche sempre o seu navegador após a execução para liberar recursos!

driver.quit()

✅ E já está! Agora pode combinar o poder do Selenium para simular a navegação humana (cliques, rolagens, etc.) com a eficácia do BeautifulSoup para a análise do código HTML.

Perguntas frequentes

Qual é a melhor ferramenta para a recolha de dados da Web em Python?

Não existe realmente uma ferramenta universal melhor, mas sim soluções adaptadas ao seu projeto.

🔥 Bela Sopa Analisador HTML: simples e eficaz para analisar HTML e extrair conteúdos rapidamente. É ideal se estiver a começar ou se tiver pequenos projectos.

🔥 Sucata : é uma estrutura completa, concebida para gerir grandes volumes de dados com funcionalidades avançadas.

🔥 Dramaturgo : perfeito para sites complexos gerados por JavaScript, pois simula um navegador real e permite interagir com a página como um humano.

Como utilizar o BeautifulSoup para extrair conteúdo de uma etiqueta <div> ?

Com o BeautifulSoup, pode direcionar um beacon específico utilizando um Seletor CSS. Para extrair conteúdo de um <div>Eis os passos a seguir:

Recuperar a página com Requests e, em seguida, analisar com BeautifulSoup

from bs4 import BeautifulSoup
importar pedidos

url = "URL_DO SEU_SITE" # Substituir pelo URL real
resposta = requests.get(url)
html_content = response.text

soup = BeautifulSoup(html_content, "html.parser")

Utilizar o selecionar() passando-lhe o seu seletor CSS para direcionar o <div>

Para obter o primeiro item, utilize sopa.select_onePara obter todos os itens, utilize sopa.selecionar

Exemplo HTML:

<div class="article">
  <h2>Título do artigo</h2>
  <p>Eis o que diz o parágrafo.</p>
</div>

Exemplo com CSS :

# Recuperar a primeira div com a classe "article
div_article = soup.select_one("div.article")

# Mostrar o seu conteúdo de texto
if div_article:
print(div_article.get_text(strip=True))

Aqui, o seletor CSS é div.article.

Extrair elementos dentro da <div>

# Recuperar o título dentro da div
title = soup.select_one("div.article h2").get_text()

# Recuperar o parágrafo de dentro da div
parágrafo = soup.select_one("div.item p").get_text()

print("Título:", título)
print("Parágrafo:", parágrafo)

Como é que o Requests e o BeautifulSoup podem ser utilizados em conjunto?

Estas duas bibliotecas complementam-se mutuamente.

Requests recupera o conteúdo de uma página web com uma solicitação HTTP.

Envia um pedido HTTP para o sítio alvo e descarrega o código HTML em bruto da página.

pedidos de importação

url = "https://sitecible.com"
response = requests.get(url) # Pedido HTTP
print(response.text) # apresenta o HTML em bruto

Nesta fase, tudo o que tem é um texto enorme cheio de etiquetas (<html>,<div><p>etc.).

A BeautifulSoup analisa este conteúdo HTML para extrair o que lhe interessa.

Ele pega o HTML bruto e transforma-o numa estrutura organizada. Graças a isso, pode navegar facilmente dentro do HTML: localizar, extrair e recuperar os dados.

from bs4 import BeautifulSoup

soup = BeautifulSoup(response.text, "html.parser") # analisa o HTML
title = soup.find("h1").get_text() # extrai o conteúdo de um <h1>
imprimir(título)

Porque é que o meu código de recolha de dados da Web não funciona em alguns sítios?

O seu script pode não obter nada, porque alguns sítios não fornecem todo o conteúdo diretamente em HTML.

Esses sites utilizam JavaScript para carregar dados dinamicamente. No entanto, o BeautifulSoup não permiteanalisar dados apresentados por JavaScript.

Neste caso, deve recorrer a ferramentas como Dramaturgo Onde Selénio.

Que papel desempenha a BeautifulSoup na recolha de dados da Web?

O BeautifulSoup desempenha o papel deAnalisador HTML.

Ele pega o código-fonte de uma página na forma de texto bruto e transforma-o num objeto estruturado que pode ser facilmente navegado.

Sem esta biblioteca, verá um enorme bloco de texto ilegível. Simplificando, BeautifulSoup é o tradutor entre o HTML simples e o seu Código Python.

Raspagem da Web: BeautifulSoup vs Scrapy?

Bela Sopa e Sucata são muito diferentes, embora ambos sejam utilizados para a raspagem da Web.

Bela Sopa	Sucata
Uma biblioteca simples utilizada apenas para analisar HTML e extrair dados.	Uma estrutura completa que gere todo o processo de raspagem (consultas, seguimento de ligações, paginação, exportação de dados, gestão de erros).

Em resumo, o BeautifulSoup facilita aExtração de dados HTML em Python. Esta biblioteca é perfeita para principiantes, uma vez que torna o scraping rápido e fácil.

Caso contrário, se não quiser sem codificação, a ferramenta completa Dados brilhantes é também uma excelente solução para a recolha de dados da Web.

👉 Agora diz-nos nos comentários o que conseguiste raspar!