Per fare scraping del web in Python con BeautifulSoup, ti servono due librerie: requests per scaricare la pagina web, e beautifulsoup4 per estrarre i dati dal codice HTML.
Installali con il comando pip install requests beautifulsoup4, quindi segui la guida qui sotto per eseguire lo scraping di un sito passo dopo passo.
Prerequisiti per lo scraping su Python con BeautifulSoup
Prima di iniziare, non devi essere un esperto. Basta saper leggere ed eseguire uno script Python è più che sufficiente per iniziare.
Ecco cosa occorre installare per iniziare:
- Installare Python nonché un ambiente di sviluppo.
- Installare pip, lo strumento che permette di aggiungere librerie Python con un solo comando.
- Installare BeautifulSoup :
pip installare beautifulsoup4Attenzione al nome del pacchetto: su PyPI, è proprio così beautifulsoup4 che bisogna scrivere. Il modulo che dovrai importare nel tuo codice si chiama bs4.
- Installare Requests per scaricare le pagine web:
pip installa le richieste- Installare lxml (opzionale), un parser più veloce utilizzato da BeautifulSoup per analizzare l'HTML:
pip install lxmlCome fare web scraping con Python e BeautifulSoup?
Ecco un progetto completo per recuperare il titolo di una pagina web e tutti i collegamenti che contiene.
Passo 1: Recuperare il contenuto della pagina con le richieste
Per scaricare una pagina web, devi inviare una Richiesta HTTP GET verso un URL. È questa la funzione della libreria Requests.
Ad ogni richiesta, il server restituisce un codice di stato che ti indica se tutto è andato bene. I principali da conoscere:
- 200 successo.
- 301 / 302 reindirizzamento.
- 404 Pagina non trovata.
- 500 errore interno del server.
Insieme a Requests, puoi verificare questo risultato grazie all'attributo .codice_stato. Ecco un esempio concreto: questo codice invia una richiesta a un sito, verifica il codice di stato e, se tutto va bene, visualizza un estratto del contenuto HTML.
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 risposta.testo, si ottiene una semplice stringa di caratteri: tutto il codice HTML della pagina, ma inutilizzabile così com’è. Per poterlo manipolare facilmente, crea un oggetto BeautifulSoup, che trasforma questo codice HTML grezzo in una struttura che puoi esplorare e analizzare.
Indica sempre un parser, ad esempio "html.parser. BeautifulSoup interpreta quindi correttamente l'HTML, senza visualizzare alcun avviso. Puoi anche utilizzare lxml, più veloce, da installare separatamente.
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
L'HTML è ora un oggetto BeautifulSoup. Puoi cercare e recuperare i dati che ti interessano, tag per tag. Tre metodi coprono la maggior parte delle esigenze.
Utilizzo delle funzioni find() e find_all()
trovare() restituisce il primo elemento trovato. find_all() rimanda alla elenco completo gli elementi corrispondenti.
# 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
Puoi affinare la ricerca in base a un attributo HTML, come classe, id o qualsiasi altro. Da notare : In Python si scrive classe_ e no classe, per evitare conflitti con la parola riservata del linguaggio.
# Recuperare un elemento `div` con un ID specifico
contenitore = soup.find("div",)
# Recuperare tutti i link con una classe specifica
link_nav = soup.find_all("a", class_="nav-link")
Utilizzo dei selettori CSS con select()
Per ricerche più precise, il metodo selezionare() accetta Selettori CSS. Puoi individuare con precisione determinate parti di una pagina, senza dover scorrere manualmente tutto il codice HTML.
# 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"]]')
Come estrarre dati da una tabella HTML con BeautifulSoup?
I casi d'uso reali sono spesso più complessi del semplice recupero di un titolo o di un link. Dovrai gestire l’estrazione di dati strutturati come le tabelle e gli elenchi, la impaginazione, e gli errori più comuni nello scraping.
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, devi scorrerle riga per riga o elemento per elemento.
Per estrarre un tabella HTMLIl principio è semplice:
- Recuperare le intestazioni (
<th>) per identificare le intestazioni delle colonne. - Scorrere ogni riga (
<tr>) e la ricerca di celle (<td>) che contengono i dati. - Memorizzare le informazioni in un elenco o in un dizionario.
Per un Elenco HTML (
- Individuare tutti i tag
insieme a find_all. - Recuperare il loro contenuto (testo o link) e aggiungerlo a una lista in 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 i intestazioni e find_all("td") recupera le celle di ogni riga. Si esegue 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"]
Ciascuno viene trasformato direttamente in elemento di un elenco in Python, il che porta al risultato ["Mela", "Banana", "Arancia"]..
Gestione della paginazione e dei collegamenti
Spesso i dati non rientrano in una sola pagina. Vengono suddivisi tramite link a “pagina successiva” o a paginazione numerata (?pagina=1, ?pagina=2, ecc.). In entrambi i casi, devi ricciolo per recuperare tutte le pagine e unire i dati.
Esempio con un parametro "page":
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 passo dopo passo:
- Prepara il’URL con un posto auto
{}per inserire il numero di pagina.
BASE_URL = "https://bonjour.com/articles?page={}- Alcuni siti bloccano le richieste senza l'identificativo del browser. Aggiungere un User-Agent evita di essere scambiato per un bot.
headers = {"User-Agent": "Mozilla/5.0"}
requests.get(url, headers=intestazioni) - Torna all'inizio della pagina Da 1 a 5.
per pagina nell'intervallo(1, 6):- Recupera il codice HTML della pagina con requests.
requests.get(url)- Limita il tempo di attesa se il sito non risponde (timeout di 20 secondi).
requests.get(url, timeout=20)- Analizza la pagina con BeautifulSoup.
BeautifulSoup(response.text, "html.parser")- Recupera tutti i titoli degli articoli.
find_all("h2", class_="title")- Aggiunge gli articoli trovati a un elenco generale.
tutti_gli_articoli.extend(articoli)- Inserisci una pausa tra una richiesta e l'altra 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. Ti capiterà spesso di incontrare degli ostacoli:
- Errori HTTP : 404 (pagina non trovata), 403 (accesso vietato) e 500 (errore lato server).
Esempio di gestione:
response = requests.get(url)
if response.status_code == 200:
print("Pagina recuperata con successo")
elif response.status_code == 404:
print("Errore: pagina non trovata")
else:
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 il HTML statico. Se la pagina carica i propri contenuti tramite JavaScript, non vedrai nulla. In questo caso, devi utilizzare uno strumento come Selenium Dove Playwright.
Per eseguire lo scraping in modo efficace senza essere bloccato né danneggiare il sito, ecco alcune buone pratiche:
- Rispetta il file robots.txt del sito che vuoi analizzare.
- Metti in atto delle scadenze tra le richieste con
time.sleep()per non sovraccaricare il server. - Utilizza dei deleghe e falli girare.
- Cambia regolarmente il tuo User-Agent.
Come posso eseguire lo scraping del web con Selenium e BeautifulSoup?
Selenium controllare un vero browser, esegue il codice JavaScript e visualizza la pagina come se fosse un utente a navigarla. BeautifulSoup Analizza poi il codice HTML una volta che la pagina è stata caricata completamente, ed estrai tutti i dati che desideri.
Passo 1: Installare Selenium e BeautifulSoup
Qui, invece di requests, usi Selenium per recuperare il contenuto della pagina. Installa le due librerie con questo comando:
pip installare selenium beautifulsoup4Devi poi scaricare un WebDriver adattato alla versione del tuo browser. Per Google Chrome, è ChromeDriver. Hai due opzioni: inserirlo nella stessa cartella del tuo script Python, oppure’aggiungere alla variabile di ambiente PATH del tuo sistema.
Passo 2: Configurazione di Selenium
Inizia importando webdriver tramite Selenium per controllare il browser.
da selenium import webdriver
da selenium.webdriver.common.by import ByApri quindi un browser. È il browser che apre la pagina e esegue il codice JavaScript, in questo caso Chrome.
driver = webdriver.Chrome()Indica al browser quale URL da visitare.
driver.get("https://www.exemple.com")Se la pagina impiega un po’ di tempo a visualizzare alcuni elementi, puoi chiedere a Selenium di attendere fino a 10 secondi.
driver.implicitly_wait(10)Passo 3: Recupero del contenuto della pagina
Una volta caricata la pagina, recupera il DOM completo : il codice sorgente HTML ottenuto dopo l'esecuzione del JavaScript.
html_content = driver.page_sourcePasso 4: Analisi HTML con BeautifulSoup
Ora passa questo codice sorgente a Bella Zuppa per utilizzarlo:
from bs4 import BeautifulSoup
# Creare un oggetto BeautifulSoup
soup = BeautifulSoup(html_content, 'html.parser')
# Esempio: recuperare tutti i titoli della pagina
titoli = soup.find_all('h2')
for titolo in titoli:
print(titolo.get_text())BeautifulSoup offre potenti metodi come find(), find_all() e i selettori CSS per individuare ed estrarre elementi specifici dell'HTML.
Passo 5: chiusura del browser
Molto importante: chiudi sempre il browser al termine dell'esecuzione per liberare le risorse.
driver.quit()In questo modo unisci la potenza di Selenium per simulare la navigazione umana (clic, scorrimento) con l'efficienza di BeautifulSoup nell'analisi dell'HTML. È il metodo ideale per eseguire lo scraping di un sito che carica i propri dati tramite JavaScript.
Domande frequenti
Qual è il miglior strumento per il web scraping in Python?
Non c'è alcun’strumento di raschiatura non soluzioni universali, ma piuttosto soluzioni adatte al tuo progetto. Ecco le tre più utilizzate:
- BeautifulSoup : semplice ed efficace per analizzare il codice HTML ed estrarre rapidamente i contenuti. Ideale se sei alle prime armi o se hai progetti di piccole dimensioni.
- Scrapy : un framework completo, progettato per gestire grandi volumi di dati con funzionalità avanzate.
- Playwright : perfetto per i siti complessi generati da JavaScript. Simula un vero browser e interagisce con la pagina come farebbe un utente.
Come si usa BeautifulSoup per estrarre il contenuto di un tag div?
Insieme a BeautifulSoup, si individua un tag specifico grazie a un Selettore CSS. Per estrarre il contenuto di un tag <div>, segui questi passaggi.
1. Caricare la pagina web con requests, quindi analizzare il codice HTML con 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. Utilizzare il metodo selezionare() utilizzando il tuo selettore CSS per selezionare il tag <div>.
Per recuperare il primo elemento, usa soup.select_one. Per recuperare tutti gli elementi, usa soup.select. Ecco un esempio di codice HTML:
<div>
<h2>Titre de l'article</h2>
<p>Voici le contenu du paragraphe.</p>
</div>Ed ecco l'esempio con il selettore CSS div.articolo :
# 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. Estrarre gli elementi all'interno della <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)Come si possono usare insieme Requests e BeautifulSoup?
Queste due biblioteche sono aggiuntivo : una scarica la pagina, l’altra la analizza.
1. requests invia una richiesta HTTP e scarica il codice HTML non formattato della pagina.
import requests
url = "https://sitecible.com"
response = requests.get(url) # requête HTTP
print(response.text) # affiche le HTML brutA questo punto, hai solo un testo enorme pieno di tag (<html>, <div>, <p>ecc.).
2. BeautifulSoup analizza questo codice HTML grezzo e lo trasforma in un struttura organizzata. A questo punto puoi navigare nella pagina, individuare i tag e recuperare i dati.
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)Perché il mio codice di web scraping non funziona su alcuni siti?
A volte può capitare che il tuo script non recuperi nulla. Alcuni siti non forniscono tutti i loro contenuti direttamente in HTML: utilizzano JavaScript per caricare i dati in modo dinamico. Tuttavia, BeautifulSoup non è in grado di analizzare i dati restituiti da JavaScript. In questo caso, devi ricorrere a strumenti come Playwright Dove Selenium.
Che ruolo ha BeautifulSoup nel web scraping?
BeautifulSoup svolge il ruolo di’Parser HTML. Trasforma il codice di una pagina in un oggetto strutturato che puoi esplorare facilmente. In poche parole, è il convertitore tra HTML grezzo e il tuo codice Python.
Web scraping: BeautifulSoup o Scrapy?
BeautifulSoup e Scrapy sono davvero diversi, anche se entrambi servono a scraping del web.
| BeautifulSoup | Scrapy |
|---|---|
| Una semplice libreria utilizzata esclusivamente per analizzare l'HTML ed estrarre dati. | Un framework completo che gestisce l'intero processo di scraping: richieste, tracciamento dei link, impaginazione, esportazione dei dati e gestione degli errori. |
BeautifulSoup è la scelta perfetta per chi è alle prime armi: rende l’Estrazione di dati HTML in Python semplice e veloce.
Se preferisci ridurre al minimo la parte relativa al codice, lo strumento Dati luminosi offre set di dati pronti all’uso per ridurre la parte di programmazione.
Italiano