Come fare web scraping su Python con BeautifulSoup?

Volete immergervi nel mondo di scraping del web ma senza impantanarsi in codici complicati?

Insieme a Pitone e la biblioteca Bella Zuppa, puoi facilmente estrarre e organizzare i dati di un sito web in poche righe.

Web scraping su Python con BeautifulSoup. Cristina per Alucare.fr

Prerequisiti per lo scraping su Python con BeautifulSoup

✅ Prima di iniziare, è importante avere alcune basi di programmazione. Questo vi permetterà di capire meglio il funzionamento del codice. Non è necessario essere esperti, ma saper leggere ed eseguire uno script Python sarà di grande aiuto.

Quindi, ecco cosa bisogna fare per prima cosa per fare scraping su Python con BeautifulSoup :

Installare Pitone nonché un ambiente di sviluppo.
Installare pip, lo strumento che consente di aggiungere facilmente librerie Python.
Installare Bella Zuppa con il comando :

pip installare beautifulsoup4

Installare Richieste per recuperare le pagine web con il comando :

pip installa le richieste

Come fare web scraping con Python e BeautifulSoup?

Seguite la nostra guida per un semplice progetto di web scraping.

Immagine che mostra come funziona il web scraping su Python con BeautifulSoup. Cristina per Alucare.fr

Progetto : recuperare il titolo di una pagina e tutti i link in essa contenuti.

Passo 1: Recuperare il contenuto della pagina con le richieste

Eseguire un Richiesta HTTP GET a un URL, utilizzare l'opzione Richieste.

📌 Quando si invia una richiesta HTTP con Requests, il server restituisce sempre un codice di stato. Questi codici indicano se la richiesta ha avuto successo o meno.

200 successo.
301 / 302 reindirizzamento.
404 Pagina non trovata.
500 errore interno del server.

Insieme a Richieste, è possibile verificare il risultato di una query grazie all'attributo .codice_stato. Ecco un esempio di codice che invia una richiesta a bonjour.comche controlla il codice di stato e visualizza un estratto del contenuto HTML se tutto è a posto:

richieste di importazione

# URL di destinazione
url = "https://bonjour.com"

# Inviare una richiesta GET
response = requests.get(url)

# Controllare il codice di stato
se response.status_code == 200:
    print("Successo: la pagina è stata recuperata!")
    html = response.text # Contenuto HTML della pagina
    print("Estratto del contenuto HTML:")
    print(html[:500]) # visualizza solo i primi 500 caratteri
altrimenti:
    print(f "Errore: codice di stato {response.status_code}")

Passo 2: Analizzare il codice HTML con BeautifulSoup

Quando recuperi il contenuto di una pagina con Richieste (risposta.testo), si ottiene una stringa di caratteri contenente tutto il codice HTML della pagina. Per manipolare facilmente questo codice HTML, si usa Bella Zuppa per creare un oggetto Bella Zuppa.

📌 Quando si passa l'HTML grezzo a BeautifulSoup, è necessario specificare un elemento di tipo parser (esempio: "html.parser). Ciò consente a BeautifulSoup di interpretare correttamente l'HTML ed evitare avvisi.

da bs4 importa BeautifulSoup
importare richieste

url = "https://bonjour.com"
response = requests.get(url)
html = response.text

# Si consiglia di specificare il parser
soup = BeautifulSoup(html, "html.parser")

Fase 3: Trovare ed estrarre gli elementi

Una volta trasformato l'HTML in un file Bella Zuppaè possibile iniziare a cercare e recuperare i dati che interessano (tag HTML).

Utilizzo trovare() e find_all()

# Recupera il titolo <h1>
h1 = soup.find("h1")
print(h1.get_text())

# Recuperare tutti i collegamenti <a>
pegni = soup.find_all("a")
per lien in liens:
    print(lien.get_text(), lien.get("href"))

Individuazione degli elementi in base agli attributi

È possibile affinare la ricerca in base ad attributi quali classe, id o qualsiasi altro attributo HTML.

⚠️ Nota In Python, si scrive classe_ invece di classe per evitare conflitti con la parola riservata classe.

# Recuperare un div con un id specifico
container = soup.find("div", id="main")

# Recuperare tutti i collegamenti con una classe specifica
nav_links = soup.find_all("a", class_="nav-link")

Utilizzare i selettori CSS con selezionare()

Per ricerche più precise, utilizzare selezionare() con i selettori CSS.

# Tutti i collegamenti nei titoli degli articoli
article_links = soup.select("article h2 a")

# Tutti <a> il cui attributo href inizia con "http".
links_http = soup.select('a[href^="http"]]')

Il Selettori CSS sono molto potenti se desideri selezionare con precisione determinate parti di una pagina senza dover scorrere manualmente tutto il codice HTML.

Come estrarre dati da una tabella HTML con BeautifulSoup?

Estrarre dati da una tabella HTML usando BeautifulSoup. — Estrazione di dati da una tabella HTML con BeautifulSoup. ©Christina per Alucare.fr

Finora abbiamo visto come recuperare titoli, link o testo da una pagina web.

⚠ Tuttavia, spesso i casi d'uso reali sono più complessi: estrazione di dati strutturati come tabelle o elenchi, la gestione dell'impaginazione o la risoluzione di errori frequenti legati allo scraping. È proprio quello che vedremo insieme.

Estrarre tabelle ed elenchi

I siti web spesso presentano i loro dati in Tabelle HTML (<table>, <tr>, <th>, <td>) o elenchi (

). Per trasformare queste strutture in dati utilizzabili, è necessario imparare a esaminarle riga per riga o elemento per elemento.

Ogni volta che si vuole estrarre una tabella HTMLIl principio è semplice:

Recuperare le intestazioni (<th>) per identificare le intestazioni delle colonne.
✅ Sfogliare ogni riga (<tr>) e la ricerca di celle (<td>) che contengono i dati reali.
Memorizzare le informazioni in un elenco o in un dizionario.

Per un Elenco HTML (

) :

Individuare tutti i tag
insieme a trova_tutti.
Recuperare il loro contenuto (testo o link) e aggiungerlo a un elenco Python.

In sintesi :

Le etichette <table>, <tr>, <th>, <td> vengono utilizzati per ricostruire una tabella.
Le etichette

sono usati per trasformare un elenco HTML in un elenco Python.

Ecco un esempio con una tabella:

html = """
<table>
  <tr>
    <th>Nome</th>
    <th>Età</th>
    <th>città</th>
  </tr>
  <tr>
    <td>Alice</td>
    <td>25</td>
    <td>Parigi</td>
  </tr>
  <tr>
    <td>Bob</td>
    <td>30</td>
    <td>Lione</td>
  </tr>
</table>
"""

# Creare l'oggetto BeautifulSoup
soup = BeautifulSoup(html, "html.parser")

# Estrarre le intestazioni dall'array
headers = [th.get_text(strip=True) for th in soup.find_all("th")]
print("Intestazioni:", intestazioni)

# Estrarre le righe di dati (saltare la prima riga perché si tratta delle intestazioni)
righe = []
per tr in soup.find_all("tr")[1:]:
    cells = [td.get_text(strip=True) for td in tr.find_all("td")]
    if celle:
        rows.append(cells)

print("Righe :", righe)

Qui, find_all("th") recupera le intestazioni e find_all("td") recupera le celle di ogni riga. Eseguiamo un ciclo sulle <tr> per ricostruire la tabella riga per riga.

Ecco un esempio basato su un elenco:

da bs4 importa BeautifulSoup

html_list = """

  Mela
  Banana
  Arancia

"""

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

# Recuperare gli elementi dall'elenco
items = [li.get_text(strip=True) for li in soup.find_all("li")]
print("Elenco estratto:", items) # ["Mela", "Banana", "Arancia"]

Qui, ogni

viene trasformato direttamente in un elemento di un elenco Python, dando come risultato ["Mela", "Banana", "Arancia"]..

Gestione della paginazione e dei collegamenti

Spesso i dati non stanno in una sola pagina. Vengono distribuiti su più pagine utilizzando “pagina successiva” o a paginazione numerata (?page=1, ?page=2, ...).

📌 In entrambi i casi, occorre ricciolo (browse in a loop) per recuperare tutte le pagine e unire i dati.

Esempio con un parametro di pagina :

tempo di importazione
importare le richieste
da bs4 importa BeautifulSoup

# Esempio di URL con paginazione
BASE_URL = "https://bonjour.com/articles?page={}"
HEADERS = {"User-Agent": "Mozilla/5.0"}

all_articles = []

# Supponiamo che ci siano 5 pagine da sfogliare
per pagina in range(1, 6):
    url = BASE_URL.format(pagina)
    r = requests.get(url, headers=HEADERS, timeout=20)
    se r.status_code == 200:
        soup = BeautifulSoup(r.text, "html.parser")
        # Estrarre i titoli degli articoli
        articoli = [h2.get_text(strip=True) for h2 in soup.find_all("h2", class_="title")]
        all_articles.extend(articles)
    altrimenti:
        print(f "Errore sulla pagina {pagina} (codice : {r.status_code})")
    time.sleep(1.0) # cortesia

print("Articoli recuperati:", all_articles)

Una breve spiegazione:

Preparare l'URL con uno spazio {} per inserire il numero della pagina.

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

Alcuni siti bloccano le richieste senza “identità del browser”. Aggiungere un User-Agent evita di essere scambiati per un bot.

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

Loop da pagina 1 a 5.

per pagina nell'intervallo(1, 6):

Recupera l'HTML dalla pagina.

requests.get(url)

Limitare il tempo di attesa se il sito non risponde.

requests.get(url, timeout=20)

Parser la pagina.

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

Recuperare tutti i titoli degli articoli.

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

Aggiungere gli elementi trovati a un elenco globale.

tutti_gli_articoli.extend(articoli)

Introdurre una pausa tra ogni richiesta per non sovraccaricare il server ed evitare di essere bannati.

time.sleep(1.0)

Dopo il loop, tutti_gli_articoli contiene tutti e 5 i titoli delle pagine.

Errori e sfide comuni

❗ Lo scraping non consiste semplicemente nel premere un pulsante e il gioco è fatto. Potresti incontrare ostacoli frequenti come:

Errori HTTP

404 pagina non trovata
403 nessun accesso
500 errore lato server

Esempio :

response = requests.get(url)
se response.status_code == 200:
    # Pagina OK
    print("Pagina recuperata con successo")
elif response.status_code == 404:
    print("Errore: pagina non trovata")
altrimenti:
    print("Codice restituito:", response.status_code)

Siti che bloccano lo scraping

Alcuni rilevano le richieste automatiche e bloccano l'accesso.

Pagine dinamiche (JavaScript)

BeautifulSoup legge solo HTML statico. Se la pagina carica il suo contenuto con JavaScriptnon vedrete nulla.

✅ In questo caso, utilizzare strumenti come Selenio Dove Drammaturgo.

Tuttavia, se volete effettuare lo scraping in modo efficiente senza essere bloccati o danneggiare il sito, ecco le migliori pratiche:

Rispettare il file robots.txt di un sito web.
Impostazione scadenze tra una richiesta e l'altra, in modo da non sovraccaricare il server (usando time.sleep()).
Utilizzo deleghe e ruotarli.
✔ Cambiare regolarmente il vostro Agente utente.

Come posso eseguire lo scraping del web con Selenium e BeautifulSoup?

Web scraping con Selenium e BeautifulSoup su Chrome. Cristina per Alucare.fr

⚠ Un promemoria : BeautifulSoup è un ottimo analizzatore HTML, ma non è in grado di eseguire JavaScript da una pagina web. È qui che Selenium diventa il tuo alleato!

In sostanza, il selenio controllare un vero browserEsegue JavaScript e visualizza la pagina come se un essere umano stesse navigando. BeautifulSoup analizza il codice HTML una volta che la pagina è stata completamente resa. In questo modo è possibile estrarre ciò che si desidera.

Passo 1: Installare Selenium e BeautifulSoup

Qui, invece di usare la libreria Request, useremo Selenio. Per installarlo, è necessario passare attraverso pip.

pip installare selenium beautifulsoup4

Successivamente, è necessario scaricare e installare un file WebDriver che corrisponde alla versione del vostro browser (ad esempio, ChromeDrive per Google Chrome).

✅ Puoi metterlo nella stessa cartella del tuo script Python o nell’aggiungere alla variabile di ambiente PATH del sistema.

Passo 2: Configurazione di Selenium

Innanzitutto, è necessario importare webdriver di Selenium per controllare un browser.

da selenium import webdriver
da selenium.webdriver.common.by import By

Quindi si avvia un browser. Sarà lui ad aprire la pagina web e eseguirà il codice JavaScript (Esempio: Chrome).

driver = webdriver.Chrome()

L'utente indica al browser la pagina da visitare.

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

Se la pagina impiega molto tempo a visualizzare alcuni elementi, puoi dire a Selenium di aspettare un po'.

driver.implicitly_wait(10)

Passo 3: Recupero del contenuto della pagina

Una volta caricata la pagina, è possibile recuperare il file DOM completo (codice sorgente HTML dopo l'esecuzione del JS).

html_content = driver.page_source

Passo 4: Analisi HTML con BeautifulSoup

Ora passa questo codice sorgente a BeautifulSoup per poterlo utilizzare:

from bs4 import BeautifulSoup # Creare un oggetto BeautifulSoup soup = BeautifulSoup(html_content, 'html.parser') # Esempio: recuperare tutti i titoli della pagina titles = soup.find_all('h2') for title in titles: print(title.get_text())

👉 BeautifulSoup offre metodi potenti come find(), find_all(), e selettori CSS per obiettivo e estrarre gli elementi Codice HTML.

Passo 5: chiusura del browser

Molto importante: chiudete sempre il browser dopo l'esecuzione per liberare le risorse!

driver.quit()

Ed ecco fatto! Ora è possibile combinare la potenza di Selenium per simulare la navigazione umana (clic, scorrimento, ecc.) con l'efficienza di BeautifulSoup per l'analisi del codice HTML.

Domande frequenti

Qual è il miglior strumento per il web scraping in Python?

Non esiste un unico strumento universale migliore, ma piuttosto soluzioni adeguate al vostro progetto.

🔥 Bella Zuppa Parser HTML: semplice ed efficace per analizzare l'HTML ed estrarre rapidamente i contenuti. È l'ideale se siete agli inizi o se avete piccoli progetti.

🔥 Scarti : è un framework completo, progettato per gestire grandi volumi di dati con funzionalità avanzate.

🔥 Drammaturgo : perfetto per siti complessi generati da JavaScript, poiché simula un vero browser e consente di interagire con la pagina come un essere umano.

Come utilizzare BeautifulSoup per estrarre il contenuto da un tag <div> ?

Con BeautifulSoup, è possibile puntare a un beacon specifico utilizzando un Selettore CSS. Per estrarre il contenuto da un file <div>Ecco i passaggi:

Recuperare la pagina con Requests, quindi analizzarla con BeautifulSoup

da bs4 importa BeautifulSoup
importare richieste

url = "URL_del_tuo_sito" # Sostituire con il vero URL
response = requests.get(url)
html_content = response.text

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

Utilizzare il selezionare() passandogli il selettore CSS per indirizzare il tag <div>

Per recuperare il primo elemento, utilizzare soup.select_onePer recuperare tutti gli elementi, utilizzare soup.select

Esempio di HTML:

<div class="article">
  <h2>Titolo dell'articolo</h2>
  <p>Ecco cosa dice il paragrafo.</p>
</div>

Esempio con i CSS :

# Recuperare il primo div con la classe "articolo".
div_article = soup.select_one("div.article")

# Visualizzare il suo contenuto testuale
if div_articolo:
print(div_article.get_text(strip=True))

Qui il selettore CSS è div.articolo.

Estrarre elementi all'interno della <div>

# Recuperare il titolo all'interno del div
title = soup.select_one("div.article h2").get_text()

# Recuperare il paragrafo all'interno del div
paragrafo = soup.select_one("div.item p").get_text()

print("Titolo:", titolo)
print("Paragrafo:", paragrafo)

Come si possono usare insieme Requests e BeautifulSoup?

Queste due biblioteche si completano a vicenda.

Requests recupera il contenuto di una pagina web con una richiesta HTTP.

Invia una richiesta HTTP al sito di destinazione e scarica il codice HTML grezzo della pagina.

richieste di importazione

url = "https://sitecible.com"
response = requests.get(url) # Richiesta HTTP
print(response.text) # visualizza l'HTML grezzo

A questo punto, tutto ciò che si ha è un enorme testo pieno di tag (<html>,<div><p>ecc.).

BeautifulSoup analizza questo contenuto HTML per estrarre ciò che interessa all'utente.

Prende l'HTML grezzo e lo trasforma in una struttura organizzata. Grazie a ciò, è possibile navigare facilmente all'interno dell'HTML: individuare, estrarre e recuperare i dati.

da bs4 importa BeautifulSoup

soup = BeautifulSoup(response.text, "html.parser") # analizza il codice HTML
title = soup.find("h1").get_text() # estrae il contenuto di un file <h1>
stampa(titolo)

Perché il mio codice di web scraping non funziona su alcuni siti?

Il vostro script potrebbe non recuperare nulla, perché alcuni siti non forniscono tutti i contenuti direttamente in HTML.

Questi siti utilizzano JavaScript per caricare dinamicamente i dati. Tuttavia, BeautifulSoup non consente di’analizzare i dati resi da JavaScript.

In questo caso, è necessario rivolgersi a strumenti come Drammaturgo Dove Selenio.

Che ruolo ha BeautifulSoup nel web scraping?

BeautifulSoup svolge il ruolo di’Parser HTML.

Prende il codice sorgente di una pagina in formato testo e lo trasforma in un oggetto strutturato che puoi sfogliare facilmente.

Senza questa libreria, si vedrà un enorme blocco di testo illeggibile. In parole povere, BeautifulSoup è il traduttore tra il file HTML semplice e il tuo Codice Python.

Web scraping: BeautifulSoup vs Scrapy?

Bella Zuppa e Scarti sono molto diversi, anche se entrambi vengono utilizzati per lo scraping del web.

Bella Zuppa	Scarti
Una semplice libreria utilizzata esclusivamente per analizzare l'HTML ed estrarre dati.	Un framework completo che gestisce l'intero processo di scraping (query, tracciamento dei link, paginazione, esportazione dei dati, gestione degli errori).

In sintesi, BeautifulSoup facilita l’Estrazione di dati HTML in Python. Questa libreria è perfetta per i principianti, perché rende lo scraping semplice e veloce.

Altrimenti, se non si vuole nessuna codifica, lo strumento completo Dati luminosi è anche un'ottima soluzione per lo scraping del web.

👉 Ora diteci nei commenti cosa siete riusciti a racimolare!