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 d’un site web en quelques lignes seulement.

Pré-requisitos para raspagem em Python com BeautifulSoup

✅ Avant de vous lancer, il est important d’avoir quelques noções básicas de programação. Isto dar-lhe-á uma melhor compreensão do funcionamento do código. Pas besoin d’être expert, mais savoir lire et exécuter un script Python vous aidera beaucoup.

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

pip install beautifulsoup4

pip install pedidos

Como fazer web scraping com Python e BeautifulSoup?

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

Projeto : récupérer le titre d’une page et tous les liens qu’elle contient.

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.

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

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

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

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

# 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 sont très puissants si vous voulez cibler exactement certaines parties d’une page sans parcourir tout le HTML manuellement.

Comment extraire des données d’un tableau HTML avec BeautifulSoup ?

Jusqu’ici, nous avons vu comment récupérer des titres, des liens ou encore du texte dans une page web.

⚠ Mais souvent, les vrais cas d’utilisation sont plus complexes : extração de dados estruturados comme des tableaux ou des listes, la gestion de la pagination ou encore la résolution d’erreurs fréquentes liées au scraping. C’est exactement ce que nous allons voir ensemble.

Extrair tabelas e listas

Os sítios Web apresentam frequentemente os seus dados em Tabelas HTML (<table>, <tr>, <th>, <td>) ou listas (

/
,
1. ). 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 (

   ou
   com
   1. ) :
      • 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

      /
      ,
      1. 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

      2. é 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 “page suivante” 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:

         • Préparer l’URL avec un emplacement {} pour insérer le numéro de la page.

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

         • Certains sites bloquent les requêtes sans “identité de navigateur”. Ajouter un User-Agent évite d’être pris pour un 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")

         • Récupérer tous les titres d’articles.

         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

         ❗ Le scraping, ce n’est pas toujours appuyer sur un bouton et tout est bon. Vous pourrez rencontrer des obstacles fréquents comme :

         • 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

         Certains détectent les requêtes automatiques et bloquent l’accès.

         • 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 d’un site web.
         • 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?

         

         ⚠ Um lembrete : BeautifulSoup est un excellent analyseur HTML, mais il ne peut pas exécuter JavaScript d’une page web. C’est là que Selenium devient votre allié !

         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

         Ici, au lieu d’utiliser la bibliothèque Request, on va utiliser Selénio. Pour l’installer, il faut passer par 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).

         ✅ Vous pouvez soit le placer dans le même dossier que votre script Python, soit l’ajouter à la variable d’environnement 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 

         On lance ensuite un navigateur. C’est lui qui ouvrira la page web et 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") 

         Si la page met du temps à afficher certains éléments, vous pouvez dire à Selenium d’attendre un peu.

         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

         Passez maintenant ce code source à BeautifulSoup pour pouvoir l’exploiter :

         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

         Très important : fermez toujours votre navigateur après l’exécution pour libérer les ressources !

         driver.quit() 

         ✅ E já está! Agora pode combinar o poder do Selenium para simular a navegação humana (clics, défilements, etc.) avec l’efficacité de BeautifulSoup pour l’analyse du code HTML.

         Perguntas frequentes

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

         Il n’y a pas vraiment de meilleur outil universel, mais plutôt des solutions adaptées selon votre projet.

         🔥 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 : c’est un framework complet, pensé pour gérer de gros volumes de données avec des fonctionnalités avancées.

         🔥 Dramaturgo : parfait pour les sites complexes générés par JavaScript, car il simule un vrai navigateur et permet d’interagir avec la page comme un humain.

         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:

         1. 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")

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

         Para obter o primeiro item, utilize sopa.select_one
Para 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.

         3. Extraire des éléments à l’intérieur de la <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.

         1. Requests récupère le contenu d’une page web avec une requête 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.).

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

         Elle prend le HTML brut et le transforme en une structure organisée. Grâce à ça, vous pouvez naviguer facilement à l’intérieur du HTML : faire du repérage, extraire et récupérer les données.

         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.

         Ces sites utilisent JavaScript pour charger dynamiquement les données. Or, BeautifulSoup ne permet pas d’analisar 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?

         BeautifulSoup joue le rôle d’Analisador HTML.

         Il prend le code source d’une page sous forme de texte brut et le transforme en un objet structuré que vous pouvez parcourir facilement.

         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).

         Pour tout résumé, BeautifulSoup facilite l’Extraçã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, l’outil complet 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!