Raschiatura web con modulo di scrapy python

L'abilità di Web Racking è diventata d'oro oggi, quindi scopriamo come possiamo ottenere i dati necessari dalle pagine Web. In questo articolo, parleremo della biblioteca di Scrapy Python, cosa può fare e come usarlo. Iniziamo.

Perché Scrapy?

Scrapy è una robusta libreria di raschiatura web, che fornisce la possibilità di scaricare pagine Web, immagini e tutti i dati a cui si potrebbe pensare alla velocità della luce. La velocità è di grande importanza nel calcolo e Scrapy funziona su questo visitando siti Web in modo asincrono e facendo molto lavoro di fondo rendendo facile l'intero compito.

Va detto che Python ha altre librerie che possono essere utilizzate per raschiare i dati dai siti Web, ma nessuna è paragonabile a Scrapy quando si tratta di efficienza.

Installazione

Diamo un'occhiata rapida a come questa potente libreria può essere installata sulla macchina.

Come per la maggior parte delle librerie Python, è possibile installare Scrapy usando il modulo PIP:

PIP Installa Scrapy

Puoi verificare se l'installazione ha avuto successo importando Scrapy nella shell interattiva di Python.

$ Python
Python 3.5.2 (impostazione predefinita, 14 settembre 2017, 22:51:06)
[GCC 5.4.0 20160609] su Linux

Digita "Guida", "Copyright", "Credit" o "Licenza" per ulteriori informazioni.

>>> Importa Scrapy

Ora che abbiamo finito con l'installazione, entriamo nel bel mezzo delle cose.

Creazione di un progetto di raschiatura web

Durante l'installazione, la parola chiave Scrapy è stata aggiunta al percorso in modo da poter utilizzare la parola chiave direttamente dalla riga di comando. Ne approfitteremmo, durante il nostro uso della biblioteca.

Dalla directory di tua scelta esegui il seguente comando:

scrapy startproject webcraper

Questo creerebbe una directory chiamata Webscraper nella directory attuale e nella scrapy.File CFG. Nel Webscraper La directory avrebbe __dentro__.Py, articoli.Py, Middlewares.Py, condutture.Py, impostazioni.Py file e una directory chiamata ragni.

I nostri file ragno i.e. Lo script che fa il Webscraping per noi sarebbe archiviato in ragni directory.

Scrivere il nostro ragno

Prima di andare avanti per scrivere il nostro ragno, si prevede che sappiamo già quale sito Web vogliamo raschiare. Ai fini di questo articolo, stiamo raschiando un sito Web WebScraping di esempio: http: // Esempio.Webscraping.com.

Questo sito Web ha solo nomi di paesi e loro bandiere, con pagine diverse e stiamo per demolire tre delle pagine. Le tre pagine su cui avremmo lavorato sono:

http: // esempio.Webscraping.com/luoghi/default/indice/0
http: // esempio.Webscraping.com/luoghi/default/indice/1
http: // esempio.Webscraping.com/luoghi/default/indice/2

Tornando al nostro ragno, creeremo un sample_spider.Py nella directory dei ragni. Dal terminale, un semplice Tocca Sample_spider.Py Il comando aiuterebbe a creare un nuovo file.

Dopo aver creato il file, lo popolavamo con le seguenti righe di codice:

Importa Scrapy
Class SampleSpider (Scrapy.Ragno):
name = "campione"
start_urls = [
"http: // esempio.Webscraping.com/luoghi/default/indice/0 ",
"http: // esempio.Webscraping.com/luoghi/default/indice/1 ",
"http: // esempio.Webscraping.com/luoghi/default/indice/2 "
"
def parse (self, risposta):
Page_number = Response.URL.split ('/') [-1]
file_name = "pagina .html ".Formato (pagina_number)
con open (file_name, 'wb') come file:
file.Scrivi (risposta.corpo)

Dal livello superiore della directory del progetto, eseguire il seguente comando:

Scrapy Crawl Sample

Ricordiamo che abbiamo dato il nostro Campionspider classe A nome attributo campione.

Dopo aver eseguito quel comando, noteresti che tre file denominati Page0.HTML, pagina1.HTML, pagina2.HTML vengono salvati nella directory.

Diamo un'occhiata a cosa succede con il codice:

Importa Scrapy

Per prima cosa importa la biblioteca nel nostro spazio dei nomi.

Class SampleSpider (Scrapy.Ragno):
name = "campione"

Quindi creiamo una classe di ragno che chiamiamo Campionspider. Il nostro ragno eredita da scrapy.Ragno. Tutti i nostri ragni devono ereditare da Scrapy.Ragno. Dopo aver creato la classe, diamo al nostro ragno un nome attributo, questo nome L'attributo viene utilizzato per evocare il ragno dal terminale. Se ricordi, abbiamo gestito il Scrapy Crawl Sample comanda per eseguire il nostro codice.

start_urls = [
"http: // esempio.Webscraping.com/luoghi/default/indice/0 ",
"http: // esempio.Webscraping.com/luoghi/default/indice/1 ",
"http: // esempio.Webscraping.com/luoghi/default/indice/2 "
"

Abbiamo anche un elenco di URL per il ragno da visitare. L'elenco deve essere chiamato start_urls. Se vuoi dare all'elenco un nome diverso, dovremmo definire un start_requests funzione che ci dà alcune più capacità. Per saperne di più puoi dare un'occhiata alla documentazione di Scrapy.

Indipendentemente da ciò, non dimenticare di includere http: // o https: // per i tuoi collegamenti, dovresti affrontare un errore di schema mancante.

def parse (self, risposta):

Andiamo quindi avanti per dichiarare una funzione di analisi e dargli un parametro di risposta. Quando viene eseguito il codice, viene evocata la funzione di analisi e l'oggetto di risposta viene inviato in cui contiene tutte le informazioni della pagina Web visitata.

Page_number = Response.URL.split ('/') [-1]
file_name = "pagina .html ".Formato (pagina_number)

Quello che abbiamo fatto con questo codice è dividere la stringa contenente l'indirizzo e salvare il numero di pagina da solo in a numero di pagina variabile. Quindi creiamo un nome del file inserzione variabile numero di pagina Nella stringa sarebbe il nome file dei file che creeremo.

con open (file_name, 'wb') come file:
file.Scrivi (risposta.corpo)

Ora abbiamo creato il file e stiamo scrivendo il contenuto della pagina Web nel file utilizzando il corpo attributo del risposta oggetto.

Possiamo fare molto di più che salvare la pagina web. La biblioteca di Beautifulsoup può essere utilizzata per analizzare il corpo.risposta. Puoi dare un'occhiata a questo tutorial di BeautyullOup se non hai familiarità con la biblioteca.

Dalla pagina da demolire, ecco un estratto dell'HTML contenente i dati di cui abbiamo bisogno:

..
..

Afghanistan

Isole Aland

Noteresti che tutti i dati necessari sono racchiusi nei tag DIV, quindi riscriveremo il codice per analizzare l'HTML.
Ecco la nostra nuova sceneggiatura:

Importa Scrapy
Da BS4 Import Beautifulsoup
Class SampleSpider (Scrapy.Ragno):
name = "campione"
start_urls = [
"http: // esempio.Webscraping.com/luoghi/default/indice/0 ",
"http: // esempio.Webscraping.com/luoghi/default/indice/1 ",
"http: // esempio.Webscraping.com/luoghi/default/indice/2 "
"
def parse (self, risposta):
Page_number = Response.URL.split ('/') [-1]
file_name = "pagina .TXT".Formato (pagina_number)
con open (file_name, 'w') come file:
html_content = beautifulsoup (risposta.corpo, "lxml")
Div_tags = html_content.find ("div", "id": "risultati")
Country_tags = Div_tags.find_all ("div")
country_name_position = zip (intervallo (len (country_tags)), country_tags)
Per posizione, country_name in country_name_position:
file.write ("Country Number : \ n".Formato (posizione + 1, country_name.testo))

Il codice è praticamente lo stesso di quello iniziale, tuttavia ho aggiunto Beautifulsoup al nostro spazio dei nomi e ho cambiato la logica nella funzione di analisi.

Diamo un'occhiata rapida alla logica.

def parse (self, risposta):

Qui abbiamo definito la funzione di analisi e gli abbiamo dato un parametro di risposta.

Page_number = Response.URL.split ('/') [-1]
file_name = "pagina .TXT".Formato (pagina_number)
con open (file_name, 'w') come file:

Questo fa la stessa cosa discussa nel codice iniziale, l'unica differenza è che stiamo lavorando con un file di testo anziché con un file HTML. Salveremmo i dati raschiati nel file di testo e non l'intero contenuto Web in HTML come fatto in precedenza.

html_content = beautifulsoup (risposta.corpo, "lxml")

Quello che abbiamo fatto in questa riga di codice è inviare nel risposta.corpo come argomento alla biblioteca del bellissimo e assegnato i risultati al html_content variabile.

Div_tags = html_content.find ("div", "id": "risultati")

Prendendo il contenuto HTML, lo stiamo analizzando qui cercando un div tag che ha anche e id attributo con Risultati Dato che è valore, allora possiamo salvarlo in a Div_tags variabile.

Country_tags = Div_tags.find_all ("div")

Ricorda che i paesi esistevano div anche tag, ora stiamo semplicemente ottenendo tutti i div tag e salvarli come elenco in country_tags variabile.

country_name_position = zip (intervallo (len (country_tags)), country_tags)
Per posizione, country_name in country_name_position:
file.write ("Country Number : \ n".Formato (posizione + 1, country_name.testo))

Qui, stiamo ripetendo la posizione dei paesi tra tutti i tag del paese, quindi stiamo salvando il contenuto in un file di testo.

Quindi nel tuo file di testo, avresti qualcosa di simile:

Paese numero 1: Afghanistan
Paese numero 2: Aland Islands
Paese numero 3: Albania
..

Conclusione

Scrapy è senza dubbio una delle biblioteche più potenti là fuori, è molto veloce e sostanzialmente scarica la pagina web. Ti dà quindi la libertà a tutto ciò che desideri con il contenuto web.

Dovremmo notare che Scrapy può fare molto di più di quanto abbiamo controllato qui. Puoi analizzare i dati con Scrapy CSS o XPath Selectors se lo si desidera. Puoi leggere la documentazione se hai bisogno di fare qualcosa di più complesso.