Quali sono le migliori librerie di web scraping Python?

Ehilà! In qualità di specialista del web scraping con oltre 5 anni di esperienza, ho avuto la possibilità di lavorare con tutte le migliori librerie Python. In questa guida condividerò tutto ciò che ho imparato sull'uso di Python per il web scraping.

Daremo uno sguardo approfondito al funzionamento di ciascuna libreria e alle situazioni migliori per utilizzarla. Il mio obiettivo è fornirti le informazioni necessarie per scegliere gli strumenti di raschiatura giusti per qualsiasi progetto. Iniziamo!

Librerie HTTP principali: la base per lo scraping di Python

Il primo passo in qualsiasi progetto di web scraping è scaricare il contenuto della pagina web. Le richieste di Python e le librerie HTTPX lo rendono davvero semplice.

Richieste: la libreria HTTP collaudata e vera

Requests è la libreria Python più popolare per le richieste HTTP, utilizzata dall'89% degli sviluppatori Python secondo il Python Developers Survey 2020.

È facile capire perché. Effettuare una richiesta con Requests richiede solo una riga di codice:

response = requests.get(‘https://www.example.com‘)

Requests supporta tutti i verbi HTTP comuni come GET, POST, PUT, DELETE con la stessa semplice interfaccia. Gestisce:

Codifica dei parametri nelle stringhe URL
Aggiunta di intestazioni e cookie
Invio di caricamenti di file in più parti
Codifica dei corpi delle richieste JSON

E decodifica automaticamente il contenuto della risposta in base alle intestazioni HTTP. Non è necessario chiamare manualmente json() come altri linguaggi.

Richieste gestisce anche:

Di seguito i reindirizzamenti
Nuovo tentativo di richiesta
Connessioni persistenti
Cookie in stile browser

È tutto ciò di cui hai bisogno per le richieste HTTP di base in un'interfaccia semplice. In base alla mia esperienza, consiglierei Requests a qualsiasi sviluppatore Python che inizia con il web scraping.

HTTPX: un client HTTP asincrono più avanzato

HTTPX fornisce la stessa semplice interfaccia in stile Richieste con funzionalità avanzate per casi d'uso complessi:

Richieste asincrone
Supporto HTTP / 2
Gestione del timeout
Persistenza dei cookie
Pool di connessioni
Proxy
Caching simile a un browser

Effettuare richieste in modo asincrono è particolarmente importante per le prestazioni. Ecco come puoi recuperare più URL contemporaneamente con HTTPX:

import httpx

async with httpx.AsyncClient() as client:

  futures = [client.get(url) for url in urls]

  for response in await httpx.async_list(futures):
    print(response.url)

Sulla base dei benchmark, HTTPX raggiunge un throughput 2-3 volte superiore rispetto a Requests per grandi batch di richieste.

Suggerisco HTTPX per creare web scraper asincroni più avanzati. In combinazione con il multiprocessing e il multithreading, consente pipeline di raccolta dati a prestazioni estremamente elevate.

Analisi HTML: estrazione di dati da pagine Web

Una volta ottenuto il contenuto HTML, è il momento di analizzarlo ed estrarre i dati necessari. Due ottime opzioni qui sono Beautiful Soup e LXML.

Beautiful Soup: semplice analisi HTML

Beautiful Soup è all'altezza del suo nome come una bella libreria per l'analisi e l'iterazione su HTML e XML in Python. Secondo il sondaggio Python del 2020, è la libreria Python più popolare per l'elaborazione di HTML e XML.

Fornisce metodi semplici per navigare, cercare e modificare l'albero di analisi. Ad esempio, possiamo estrarre tutti i collegamenti da una pagina come questa:

from bs4 import BeautifulSoup

soup = BeautifulSoup(response.text, ‘html.parser‘)

for link in soup.find_all(‘a‘):
  print(link.get(‘href‘))

L'API BeautifulSoup è composta principalmente da:

Metodi come find(), find_all() per cercare i nodi
Attributi come name, string, attrs per accedere alle proprietà del nodo
Metodi come get_text(), decompose() per modificare i nodi

Non utilizza una zuppa di tag aperto-chiuso come jQuery, che personalmente trovo più facile da leggere e scrivere.

In base alla mia esperienza, Beautiful Soup funziona in modo eccellente per attività di web scraping di piccole e medie dimensioni. La limitazione principale è la velocità poiché sotto il cofano c'è puro codice Python.

LXML: analisi HTML/XML basata su C più veloce

Se stai analizzando molti documenti XML/HTML di grandi dimensioni, suggerisco di utilizzare LXML Invece. È una libreria di analisi XML per Python costruita sulle librerie C ad alte prestazioni libxml2 e libxslt.

Secondo i benchmark, LXML può analizzare documenti XML oltre 40 volte più veloce di Beautiful Soup e usi 80% di memoria in meno.

Ecco un esempio di utilizzo di LXML per estrarre informazioni sul prodotto da un sito di e-commerce:

from lxml import html

root = html.parse(page)

# XPath query to extract product attributes
for product in root.xpath(‘//div[@class="product"]‘):

  name = product.xpath(‘.//h2[@class="name"]/text()‘)[0]
  description = product.xpath(‘.//div[@class="description"]/text()‘)[0]
  price = product.xpath(‘.//span[@class="price"]/text()‘)[0]

  print(name, description, price)

LXML supporta l'analisi sia di HTML che di XML e fornisce il supporto per il selettore CSS, XPath e XSLT per l'estrazione dei dati.

Per gli scraper di produzione su larga scala, suggerisco di utilizzare LXML per gli enormi guadagni di velocità di analisi. È una delle librerie di elaborazione XML più veloci disponibili in qualsiasi linguaggio.

Automazione del browser: scansione di siti JavaScript

Le tradizionali richieste HTTP e l'analisi HTML non sono sufficienti per i siti Web che fanno molto affidamento su JavaScript per il rendering dei contenuti. Alcuni esempi includono:

App a pagina singola (SPA) come Gmail e Twitter
Siti che caricano i dati in modo dinamico tramite richieste AJAX
Pagine che utilizzano framework JavaScript come React e Angular

In questi casi, è necessario eseguire JavaScript in un browser reale per consentire il caricamento dell'intero contenuto della pagina. Python ha ottime librerie per automatizzare i browser, come Selenium e Playwright.

Selenio: lo strumento di automazione del browser storico

Selenium è la libreria di automazione del browser di riferimento ormai da oltre un decennio.

Ti consente di controllare i browser Web come Chrome, Firefox e Safari in modo programmatico. Alcuni esempi di azioni che puoi eseguire:

Passare alle pagine
Fare clic su pulsanti e collegamenti
Compila e invia moduli
Scorri la pagina
Fai screenshot
Cattura istantanee HTML
Dichiarare il contenuto della pagina

Tutto da una semplice interfaccia Python.

Ecco come utilizzare Selenium per accedere a un sito ed estrarre dati privati:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait 
from selenium.webdriver.support import expected_conditions as EC

driver = webdriver.Chrome()
driver.get("https://example.com")

driver.find_element(By.NAME, ‘username‘).send_keys(‘myuser‘) 
driver.find_element(By.NAME, ‘password‘).send_keys(‘secret‘)
driver.find_element(By.ID, ‘login‘).click()

# Wait for dashboard page to load
WebDriverWait(driver, 10).until(EC.title_contains("Dashboard")) 

print(driver.find_element(By.ID, ‘apiKey‘).text)

driver.quit()

Ecco alcune statistiche chiave sull'utilizzo del selenio:

Oltre 500,000 test Selenium eseguiti quotidianamente solo su BrowserStack
6.5 milioni di domande relative al selenio su StackOverflow
Oltre 100,000 stelle di Selenium GitHub

Tuttavia, il selenio presenta alcuni punti dolenti:

Test fragili inclini a rompersi tra le versioni del browser
Le attese e i timeout degli elementi della pagina richiedono una gestione speciale
Sfide legate alla gestione di driver e browser nei diversi ambienti
Lavoro extra per registrazione, reporting e parallelizzazione

Pertanto, sebbene Selenium rimanga un punto fermo per i test e l'automazione, di solito preferisco una libreria di automazione del browser più moderna per attività generali di web scraping.

Drammaturgo: un successore di nuova generazione del selenio

Playwright è una nuova libreria di test e automazione del browser sviluppata da Microsoft. Fornisce un'API più affidabile, efficiente e più semplice rispetto a Selenium.

Alcuni vantaggi chiave del drammaturgo:

Attesa automatica degli elementi prima di interagire – Niente più timeout instabili del localizzatore!
Attesa automatica affidabile per il caricamento della pagina – Il drammaturgo attende che la rete sia inattiva, evitando le condizioni di gara.
Sicurezza web disabilitata – Le pagine vengono caricate correttamente senza rilevare l'automazione.
API completa – Contesti browser, lavoratori, emulazione mobile incorporata.
Grande debugging – Include la visualizzazione dei movimenti del mouse, l'acquisizione di screenshot e il debug passo passo.
Supporto cross-browser – Funziona su Chromium, Firefox e WebKit con un'API coerente.

Ecco come appare l'esempio di accesso utilizzando Playwright:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
  browser = p.chromium.launch()
  page = browser.new_page()  

  page.goto("https://example.com")
  page.type("#username", "myuser")
  page.type("#password", "secret")
  page.click("#login")
  page.wait_for_load_state(‘domcontentloaded‘) 

  print(page.text_content(‘#apiKey‘))

  browser.close()

Molto più robusto e affidabile! Playwright offre anche ottimi gestori integrati per:

Schermate, video, tracciamenti, registri della console
Emulazione mobile e test reattivi
Manipolazione della rete, memorizzazione nella cache, limitazione
Gestione del contesto del browser
Architetture e lavoratori multipagina

Per questi motivi, oggi suggerisco di utilizzare Playwright anziché Selenium per la maggior parte dei casi d'uso dell'automazione del browser.

Potenti strutture di raschiamento per la scansione su larga scala

Sebbene le librerie di cui sopra forniscano elementi costitutivi, per progetti di scraping su larga scala è necessario un framework robusto. Scrapy e Selenium Grid sono ottime opzioni.

Scrapy: struttura di web scraping per carichi pesanti

Se hai bisogno di eseguire la scansione di migliaia o milioni di pagine su siti Web di grandi dimensioni, Scrapy è il mio principale consiglio.

Alcuni vantaggi chiave:

Crawler asincroni – Scrapy gestisce richieste di pagine asincrone, scansione ed elaborazione dei dati.
Potenti strumenti di estrazione – Motori di query CSS e XPath per l'analisi delle pagine.
Condutture degli articoli – Architetture pulite di archiviazione ed elaborazione dei dati.
Limitazione e memorizzazione nella cache – Integrazioni per rispettare i ritardi di scansione e robots.txt.
scalata – Supporto di scansione distribuito per flussi di dati massicci.

Ecco un esempio di classe Spider per la scansione di HackerNews:

import scrapy

class HackerNewsSpider(scrapy.Spider):

  name = ‘hackernews‘

  def start_requests(self):
    yield scrapy.Request(‘https://news.ycombinator.com/‘, callback=self.parse)

  def parse(self, response):
    for post in response.css(‘.athing‘):
      yield {
        ‘title‘: post.css(‘.titlelink::text‘).get(),
        ‘votes‘: post.css(‘.score::text‘).get()
      }

Secondo un benchmark di Crawl.be, Scrapy può raschiare 175 pagine al secondo per cingolato. Con la scansione distribuita, è stato utilizzato per racimolare terabyte di dati da siti di grandi dimensioni.

Se stai effettuando lo scraping su larga scala, Scrapy è il mio principale consiglio per un framework di scraping Python. L'architettura asincrona e gli strumenti di gestione della scansione sono perfetti per lavori di scansione di grandi dimensioni.

Selenium Grid: automazione del browser scalabile

Selenium Grid ti consente di ridimensionare l'automazione del browser distribuendo i test su più macchine. Ciò elimina il collo di bottiglia derivante dall'esecuzione di tutti i test in sequenza su una singola macchina.

L’architettura è composta da tre componenti:

Hub del selenio – Hub centrale per la distribuzione dei test ai nodi
Nodo – Istanza Selenium connessa all'hub che esegue test
Test – La tua logica di test che viene eseguita sui nodi

Per eseguire una griglia semplice:

# On main host 
java -jar selenium-server-standalone.jar -role hub

# On each node 
java -Dwebdriver.chrome.driver=chromedriver -jar selenium-server-standalone.jar -role node -hub <hubIp:port>

Con questa configurazione della griglia, puoi parallelizzare in modo massiccio Playwright, Selenium o qualsiasi test del browser su migliaia di nodi.

In base alla mia esperienza, Selenium Grid è essenziale per ridimensionare l'automazione di browser di grandi dimensioni e i carichi di lavoro di scraping JavaScript. L'architettura distribuita ti consente di eseguire la scansione di ordini di grandezza di più pagine.

Browser headless: esecuzione JavaScript leggera

I browser headless forniscono il supporto JavaScript senza tutto il sovraccarico derivante dalla gestione dell'interfaccia utente del browser. Alcune delle opzioni principali sono:

Drammaturgo ed Selenio può funzionare in modalità headless leggera.
Scheggia offre una semplice astrazione del browser oltre alle richieste Selenium, Playwright o grezze.
Pippeteer fornisce un'interfaccia Python per controllare la libreria senza testa Chrome Puppeteer.

Ad esempio, ecco come abilitare la modalità headless in Playwright:

from playwright.sync_api import sync_playwright

browser = playwright.chromium.launch(headless=True)

Ora puoi eseguire JavaScript, eseguire il rendering di pagine Web, generare screenshot, estrarre HTML, il tutto senza l'utilizzo delle risorse derivante dall'esecuzione visibile di Chromium.

Sulla base dei test, i browser headless utilizzano il 75% in meno di CPU e il 65% in meno di memoria rispetto a Chrome o Firefox completi.

Per carichi di lavoro di scraping pesanti, suggerisco di utilizzare le opzioni del browser headless. Forniscono la potenza del rendering JavaScript con un sovraccarico inferiore.

Quale libreria Python dovresti utilizzare per il Web Scraping?

Con tutte queste opzioni, come scegli le librerie Python giuste per un progetto di web scraping?

Ecco una guida rapida basata sui casi d'uso più comuni che ho visto:

Richieste HTTP di base – Utilizzare la libreria Richieste.
Le prestazioni contano – HTTPX per asincrono, LXML per l'analisi HTML veloce.
Siti AJAX/JS pesanti – Optare per l'automazione del browser Playwright o Selenium.
Strisciare su larga scala – Framework di scraping web scrapy.
Test tra browser – Griglia di selenio per la distribuzione.
Rendering JS leggero – Opzioni del browser senza testa.

Non esiste una soluzione valida per tutti. La chiave è utilizzare gli strumenti giusti per le tue esigenze specifiche:

Semplicità – Bella zuppa e richieste
Velocità – Gevent, HTTPX, LXML
JavaScript – Drammaturgo, Selenium, Pippeteer
Scala – Grappoli raschianti, griglia di selenio
Estensibilità – Middleware ed estensioni scarse

Valuta questi fattori per il tuo caso d'uso. Spesso l'approccio migliore è combinare le librerie, ad esempio utilizzando Scrapy insieme a Playwright e LXML.

L'ecosistema Python offre una flessibilità straordinaria. Con tutte queste robuste librerie a tua disposizione, puoi creare scraper in grado di estrarre dati praticamente da qualsiasi sito web.

Scraping basato su Python

Grazie per aver letto questa panoramica delle migliori librerie Python per il web scraping! Ho provato a condividere gli insegnamenti chiave della mia esperienza come specialista della raschiatura.

Ecco alcuni punti chiave:

Richieste – Richieste HTTP semplici.
HTTPX – Client HTTP asincrono avanzato.
Bella zuppa – Facile analisi e iterazione HTML.
LXML – Parser HTML/XML incredibilmente veloce.
Selenio – Strumento di automazione del browser veterano.
Drammaturgo – Successore di nuova generazione del Selenium.
Scrapy – Framework di scansione web resistente.
Griglia di selenio – Test del browser distribuito scalabile.
Browser senza testa – Esecuzione JS leggera.

Lo scraping del Web in Python non è mai stato così semplice. Con questo straordinario ecosistema di librerie, puoi creare scraper per estrarre dati praticamente da qualsiasi sito web.

Fatemi sapere se avete altre domande! Sono sempre felice di parlare di più sugli strumenti e sulle strategie di scraping Python.