Extrazione dei dati con Scrapy Shell

Il metodo migliore per imparare come estrarre i dati da una pagina HTML usando i selettori CSS o XPath è quello di lanciare la Scrapy Shell da terminale andando ad indicare la pagina che vogliano analizzare:

scrapy shell 'http://quotes.toscrape.com/page/1/'

NOTA: Nel caso di OS Windows ricordarsi di utilizzare le doppie virgolette:

# Doppie virgolette per Windows 
scrapy shell "http://quotes.toscrape.com/page/1/"

La Scrapy Shell è particolarmente adatta durante le fasi di sviluppo o di debug di un progetto di estrazione dati perchè permette di testare rapidamente i selettori da usare ed i risultati che essi producono.

Quello che ottentiamo sara qualcosa di simile a questo:

2019-10-27 00:04:17 [scrapy.core.engine] DEBUG: Crawled (200)  (referer: None)
[s] Available Scrapy objects:
[s] scrapy scrapy module (contains scrapy.Request, scrapy.Selector, etc)
[s] crawler
[s] item {}
[s] request
[s] response <200 http://quotes.toscrape.com/page/1/>
[s] settings
[s] spider
[s] Useful shortcuts:
[s] fetch(url[, redirect=True]) Fetch URL and update local objects (by default, redirects are followed)
[s] fetch(req) Fetch a scrapy.Request and update local objects
[s] shelp() Shell help (print this help)
[s] view(response) View response in a browser
In [1]: _

A questo punto abbiamo attivato la nostra console di Scrapy ed abbiamo estratto la pagina che ci interessava che ora è disponibile come oggetto response. Ora possiamo provare ad estrarre degli elementi della pagina utilizzando i selettori CSS con l’oggetto response appena ottenuto:

 
>>> response.css('title') [<Selector xpath='descendant-or-self::title' data='<title>Quotes to Scrape</title>'>]

Quello che otteniamo da questo comando è una lista di elementi chiamata SelectorList. che rappresenta una lista di oggetti Selector contenuti in elementi XML/HTML che ci permettono di effettuare ulteriori operazioni di ricerca ed estrazione dati.

Quindi abbiamo ottenuto degli oggetti, dei nodi della pagina HTML, ma non sono quello che cerchiamo effettivamente, nella maggior mparte dei casi quello che cerchiamo è il testo contenuto in essi. Per estrarre il testo possiamo scrivere il comando:

  
>>> response.css('title::text').get()
'Quotes to Scrape'

Con questo comando viene riportato solo il primo elemento trovato dal selettore, nel caso in cui ci fosse una lista di elementi e volessimo ottenerli tutti dobbiamo scrivere:

>>> response.css('title').getall() 
['<title>Quotes to Scrape</title>']

Otteniamo così il risultato sotto forma di array o lista di elementi.

Le combinazioni dei selettori CSS per individuare uno o più elementi della pagina sono davvero numerose, ovviamente dovete conoscere anche un po’ di HTML, DOM (Document Object Model) e di CSS (Cascade Style Sheet). Se siete pigri o volete la vita facile esiste un efficace strumento chiamato SelectorGadget, supportato dalla maggior parte dei browser, che aiuta molto nella ricerca del giusto selettore CSS.

Introduzione ai selettori XPath

A fianco dei selettori CSS esiste un altro tipo di selettori che hanno maggiore precisione, questi possono essere utilizzati con le espressioni XPath.

 
>>> response.xpath('//title')
[<Selector xpath='//title' data='<title>Quotes to Scrape</title>'>]
>>> response.xpath('//title/text()').get()
'Quotes to Scrape'

I selettori XPath sono molto potenti e sono alla base delle ricerche dei selettori in Scrapy. Infatti i selettori CSS vengono trasformati da Scrapy in selettori XPath mentre è in esecuzione. Anche se hanno una sintassi e delle regole più difficili da comprendere a prima vista , le espressioni XPath permettono di navigare all’interno della struttura del documento ed avere una maggiore precisione. L’argomento è ampio è bene cercare della documentazione dedicata per comprendere meglio il loro utilizzo Nel pezzo successivo andiamo a vedere come trovare i selettori XPath utilizzando lo strumento per sviluppatori del nostro web browser.

Creare un progetto in Scrapy

Andiamo a vedere come realizzare il nostro primo progetto in Scrapy, supponiamo che abbiate già provveduto all’installazione, ma se così non fosse è sufficiente utilizzare il gestore di pacchetti python pip scrivendo nel nostro terminale:

pip install scrapy

Molto semplice, in pochi istanti il nostro sistema sarà pronto per accettare il nostro primo comando con il quale andremo a creare un progetto Scrapy, basta editare:

scrapy startproject tutorial

Questo andrà a creare una directory chiamata tutorial con il seguente contenuto:

tutorial/
scrapy.cfg # file per le configurazioni
tutorial/  # directory dove scriveremo il nostro codice
__init__.py
items.py # file per la definizione degli item
middlewares.py # file per la definizione dei middlewares
pipelines.py # file per la definizione dei pipeline
settings.py # file per la definizione delle impostazioni
spiders/ # directory dove metteremo gli spiders
__init__.py

Il nostro primo Spider

Gli ‘Spiders‘ sono classi che Scrapy utilizza per raccogliere informazioni da un sito Web (o da un gruppo di siti Web). Devono sotto-classare scrapy.Spider e definire le richieste iniziali da effettuare, possiamo anche indicare eventualmente come seguire i collegamenti nelle pagine e come analizzare il contenuto della pagina scaricata per estrarre i dati.

Questo è il codice per il nostro primo Spider. Salvalo in un file chiamato ‘quotes_spider.py‘ nella directory tutorial / spiders nel tuo progetto:

import scrapy 

class QuotesSpider(scrapy.Spider):
name = "quotes"
  def start_requests(self):
urls = [
'http://quotes.toscrape.com/page/1/',
'http://quotes.toscrape.com/page/2/',
]
  for url in urls:
yield scrapy.Request(url=url, callback=self.parse)
  def parse(self, response):
page = response.url.split("/")[-2]
filename = 'quotes-%s.html' % page
  with open(filename, 'wb') as f:
f.write(response.body)
self.log('Saved file %s' % filename)

Abbiamo creato una classe QuoteSpider che è una sottoclasse scrapy.Spider e definisce alcuni attributi e metodi:

  • name: identifica il nostro Spider. Deve essere univoco all’interno di un progetto, ovvero non è possibile impostare lo stesso nome per Spider diversi.
  • start_requests (): deve restituire un iterabile di Requests (puoi restituire un elenco di URLs o scrivere una funzione generatore) da cui Spider inizierà a lavorare. Le richieste successive verranno generate successivamente da queste richieste iniziali.
  • parse (): un metodo che verrà chiamato per gestire la risposta scaricata per ciascuna delle richieste fatte. Il parametro response è un’istanza di TextResponse che contiene il contenuto della pagina e ha ulteriori metodi utili per gestirlo. Il metodo parse () di solito analizza la risposta, estraendo i dati scartati come dicts e anche trovando nuovi URL da seguire e creando nuove richieste da essi.

Lanciamo il nostro Spider

Per far funzionare il nostro ragno, saliamo nella directory del progetto ed eseguiamo:

scrapy crawl quotes

Questo comando esegue lo spider chiamato ‘quotes’ che abbiamo appena creato, ed invierà alcune richieste per il dominio quotes.toscrape.com come abbiamo indicato nella nostra funzione start_requests().

Ora controllando i file nella directory corrente. Possiamo notare che sono stati creati due nuovi file: quotes-1.html e quotes-2.html, con il contenuto dei i rispettivi URL, come indicato dal nostro metodo parse().

Scrapy ha pianificato gli oggetti scrapy.Request restituiti dal metodo start_requests del nostro Spider. Alla ricezione di una risposta per ciascuno, crea un’istanza di oggetti Response e chiama il metodo di callback associato alla richiesta (in questo caso, il metodo di parse) passando la risposta come argomento.

Nota: il tutorial appena presentato è stato tratto dal tutorial ufficiale del sito del projetto scrapy.org. Viene presentato tradotto in Italiano per pura divulgazione a scopo educativo.

Introduzione a Scrapy

Scrapy è un framework di alto livello per il web crawling ed il web scraping, viene usato per navigare tra le pagine in rete ed estrarre dati da esse. Scrapy può essere utilizzato per molteplici scopi dall’estrazione di dati a fini statistici, dal monitoraggio di prezzi, alla creazione di arvhivi e basi di dati ed al testing automation.

Uno dei principali vantaggi di Scrapy: è che le richieste vengono pianificate ed elaborate in modo asincrono. Ciò significa che Scrapy non ha bisogno di aspettare che una richiesta sia finita ed elaborata, può inviare un’altra richiesta o fare altre cose nel frattempo. Ciò significa anche che altre richieste possono continuare anche se alcune richieste falliscono o si verifica un errore durante la gestione permettendo di completare il lavoro di ricerca ed estrazione dati senza interruzioni del programma.

Sebbene ciò ti consenta di eseguire ricerche per indicizzazione molto veloci (inviando contemporaneamente più richieste simultanee, in modo tollerante ai guasti) Scrapy permette anche di avere il controllo della ricerca per indicizzazione attraverso alcune impostazioni. Puoi fare cose come impostare un ritardo di download tra ogni richiesta, limitare la quantità di richieste simultanee per dominio o per IP e persino usare un’estensione a limitazione automatica che prova a capirle automaticamente.

Panoramica dell’architettura

Immagine originale tratta dal sito scrapy.org https://docs.scrapy.org/en/latest/_images/scrapy_architecture_02.png

Il flusso di dati in Scrapy è controllato da un motore centrale (EXECUTION ENGINE) ed è rappresentato dai seguenti passaggi:

  1. Il motore ottiene gli indirizzi di partenza per far partire il crawler dai vari SPIDERS di un progetto.
  2. Il motore pianifica le richieste nell’utilità di pianificazione (SCHEDULER) e richiede la scansione delle richieste successive.
  3. Lo SCHEDULER restituisce le richieste successive al motore.
  4. Il motore invia le richieste al DOWNLOADER, passando attraverso i Downloader Middlewares (tramite i process_request ()).
  5. Una volta terminato il download della pagina, DOWNLOADER genera una risposta (con quella pagina) e la invia all’ENGINE, passando attraverso i Downloader Middlewares (tramite i process_response ()).
  6. Il motore riceve la risposta dal DOWNLOADER e la invia allo SPIDER per l’elaborazione, passando attraverso Spider Middleware (process_spider_input ()).
  7. Lo SPIDER elabora la risposta e restituisce gli oggetti raschiati dalla pagina e le nuove richieste (da seguire) al motore, passando attraverso il middleware Spider (process_spider_output ()).
  8. Il motore invia gli oggetti elaborati alle pipeline degli oggetti (ITEM PIPELINE), quindi invia le richieste elaborate all’utilità di pianificazione (SCHEDULER) e chiede eventuali richieste successive da sottoporre a scansione.
  9. Il processo si ripete (dal passaggio 1) fino a quando non ci sono più richieste dallo SCHEDULER.

Nota: il tutorial appena presentato è stato tratto dal tutorial ufficiale del sito del projetto scrapy.org. Viene presentato tradotto in Italiano per pura divulgazione a scopo educativo.