Scrapy - Guida rapida

Scrapy è un framework di scansione web veloce e open source scritto in Python, utilizzato per estrarre i dati dalla pagina web con l'aiuto di selettori basati su XPath.

Scrapy è stato rilasciato per la prima volta il 26 giugno 2008 con licenza BSD, con il rilascio di una pietra miliare 1.0 nel giugno 2015.

Perché usare Scrapy?

• È più facile creare e ridimensionare progetti di scansione di grandi dimensioni.

• Ha un meccanismo integrato chiamato Selettori, per estrarre i dati dai siti web.

• Gestisce le richieste in modo asincrono ed è veloce.

• Regola automaticamente la velocità di scansione utilizzando il meccanismo di regolazione automatica .

• Garantisce l'accessibilità agli sviluppatori.

Caratteristiche di Scrapy

• Scrapy è un framework di scansione web open source e gratuito.

• Scrapy genera esportazioni di feed in formati come JSON, CSV e XML.

• Scrapy ha il supporto integrato per la selezione e l'estrazione di dati da sorgenti tramite XPath o espressioni CSS.

• Scrapy basato su crawler, consente di estrarre automaticamente i dati dalle pagine web.

Vantaggi

• Scrapy è facilmente estensibile, veloce e potente.

• È un framework applicativo multipiattaforma (Windows, Linux, Mac OS e BSD).

• Le richieste scrapy vengono pianificate ed elaborate in modo asincrono.

• Scrapy viene fornito con un servizio integrato chiamato Scrapyd che consente di caricare progetti e controllare gli spider utilizzando il servizio web JSON.

• È possibile eliminare qualsiasi sito Web, sebbene quel sito Web non disponga di API per l'accesso ai dati grezzi.

Svantaggi

• Scrapy è solo per Python 2.7. +

• L'installazione è diversa per i diversi sistemi operativi.

In questo capitolo, discuteremo come installare e configurare Scrapy. Scrapy deve essere installato con Python.

Scrapy può essere installato utilizzando pip. Per installare, eseguire il seguente comando:

pip install Scrapy

finestre

Note - Python 3 non è supportato sul sistema operativo Windows.

Step 1- Installa Python 2.7 da Python

Imposta le variabili ambientali aggiungendo i seguenti percorsi al PERCORSO:

C:\Python27\;C:\Python27\Scripts\;

Puoi controllare la versione di Python usando il seguente comando:

python --version

Step 2- Installa OpenSSL .

Aggiungi C: \ OpenSSL-Win32 \ bin nelle variabili ambientali.

Note - OpenSSL è preinstallato in tutti i sistemi operativi tranne Windows.

Step 3- Installa i ridistribuibili di Visual C ++ 2008 .

Step 4- Installa pywin32 .

Step 5- Installa pip per le versioni di Python precedenti alla 2.7.9.

Puoi controllare la versione pip usando il seguente comando:

pip --version

Step 6 - Per installare scrapy, esegui il seguente comando:

pip install Scrapy

Anaconda

Se hai installato anaconda o miniconda sulla tua macchina, esegui il comando seguente per installare Scrapy usando conda -

conda install -c scrapinghub scrapy

La società Scrapinghub supporta i pacchetti conda ufficiali per Linux, Windows e OS X.

Note - Si consiglia di installare Scrapy utilizzando il comando precedente se si riscontrano problemi con l'installazione tramite pip.

Ubuntu 9.10 o versioni successive

L'ultima versione di Python è preinstallata sul sistema operativo Ubuntu. Usa i pacchetti di Ubuntu aptgatable forniti da Scrapinghub. Per utilizzare i pacchetti:

Step 1 - Devi importare la chiave GPG utilizzata per firmare i pacchetti Scrapy nel portachiavi APT -

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 627220E7

Step 2 - Successivamente, usa il seguente comando per creare il file /etc/apt/sources.list.d/scrapy.list -

echo 'deb http://archive.scrapy.org/ubuntu scrapy main' | sudo tee 
/etc/apt/sources.list.d/scrapy.list

Step 3 - Aggiorna l'elenco dei pacchetti e installa scrapy -

sudo apt-get update && sudo apt-get install scrapy

Archlinux

È possibile installare Scrapy dal pacchetto AUR Scrapy utilizzando il seguente comando:

yaourt -S scrapy

Mac OS X

Utilizzare il seguente comando per installare gli strumenti della riga di comando di Xcode:

xcode-select --install

Invece di usare il sistema Python, installa una nuova versione aggiornata che non sia in conflitto con il resto del tuo sistema.

Step 1- Installa homebrew .

Step 2 - Imposta la variabile PATH ambientale per specificare che i pacchetti homebrew devono essere usati prima dei pacchetti di sistema -

echo "export PATH = /usr/local/bin:/usr/local/sbin:$PATH" >> ~/.bashrc

Step 3 - Per assicurarti che le modifiche siano state apportate, ricarica .bashrc utilizzando il seguente comando:

source ~/.bashrc

Step 4 - Successivamente, installa Python usando il seguente comando -

brew install python

Step 5 - Installa Scrapy utilizzando il seguente comando -

pip install Scrapy

Descrizione

Lo strumento della riga di comando Scrapy viene utilizzato per il controllo di Scrapy, spesso denominato 'Scrapy tool'. Include i comandi per vari oggetti con un gruppo di argomenti e opzioni.

Impostazioni di configurazione

Scrapy troverà le impostazioni di configurazione nel file scrapy.cfgfile. Di seguito sono riportate alcune posizioni:

• C: \ scrapy (cartella del progetto) \ scrapy.cfg nel sistema

• ~ / .config / scrapy.cfg ($ XDG_CONFIG_HOME) e ~ / .scrapy.cfg ($ HOME) per le impostazioni globali

• Puoi trovare scrapy.cfg all'interno della radice del progetto.

Scrapy può anche essere configurato utilizzando le seguenti variabili d'ambiente:

• SCRAPY_SETTINGS_MODULE
• SCRAPY_PROJECT
• SCRAPY_PYTHON_SHELL

Progetto Default Structure Scrapy

La struttura seguente mostra la struttura dei file predefinita del progetto Scrapy.

scrapy.cfg                - Deploy the configuration file
project_name/             - Name of the project
   _init_.py
   items.py               - It is project's items file
   pipelines.py           - It is project's pipelines file
   settings.py            - It is project's settings file
   spiders                - It is the spiders directory
      _init_.py
      spider_name.py
      . . .

Il scrapy.cfgfile è una directory principale del progetto, che include il nome del progetto con le impostazioni del progetto. Ad esempio:

[settings] 
default = [name of the project].settings  

[deploy] 
#url = http://localhost:6800/ 
project = [name of the project]

Utilizzando Scrapy Tool

Lo strumento Scrapy fornisce alcuni comandi di utilizzo e disponibili come segue:

Scrapy X.Y  - no active project 
Usage: 
   scrapy  [options] [arguments] 
Available commands: 
   crawl      It puts spider (handle the URL) to work for crawling data 
   fetch      It fetches the response from the given URL

Creazione di un progetto

È possibile utilizzare il seguente comando per creare il progetto in Scrapy:

scrapy startproject project_name

Questo creerà il progetto chiamato project_namedirectory. Quindi, vai al progetto appena creato, usando il seguente comando:

cd  project_name

Controllo dei progetti

Puoi controllare il progetto e gestirli utilizzando lo strumento Scrapy e anche creare il nuovo spider, utilizzando il seguente comando:

scrapy genspider mydomain mydomain.com

I comandi come scansione, ecc. Devono essere utilizzati all'interno del progetto Scrapy. Verrai a sapere quali comandi devono essere eseguiti all'interno del progetto Scrapy nella prossima sezione.

Scrapy contiene alcuni comandi incorporati che possono essere utilizzati per il tuo progetto. Per visualizzare l'elenco dei comandi disponibili, utilizzare il seguente comando:

scrapy -h

Quando esegui il seguente comando, Scrapy mostrerà l'elenco dei comandi disponibili come elencato:

• fetch - Recupera l'URL utilizzando il downloader Scrapy.

• runspider - Viene utilizzato per eseguire spider autonomo senza creare un progetto.

• settings - Specifica il valore di impostazione del progetto.

• shell - È un modulo di scraping interattivo per l'URL specificato.

• startproject - Crea un nuovo progetto Scrapy.

• version - Visualizza la versione Scrapy.

• view - Recupera l'URL utilizzando Scrapy downloader e mostra i contenuti in un browser.

Puoi avere alcuni comandi relativi al progetto come elencato -

• crawl - Viene utilizzato per eseguire la scansione dei dati utilizzando lo spider.

• check - Controlla gli elementi restituiti dal comando sottoposto a scansione.

• list - Visualizza l'elenco degli spider disponibili presenti nel progetto.

• edit - Puoi modificare gli spider utilizzando l'editor.

• parse - Analizza l'URL fornito con lo spider.

• bench - Viene utilizzato per eseguire test di benchmark rapidi (il benchmark indica il numero di pagine che possono essere scansionate al minuto da Scrapy).

Comandi di progetto personalizzati

Puoi creare un comando di progetto personalizzato con COMMANDS_MODULEimpostazione nel progetto Scrapy. Include una stringa vuota predefinita nell'impostazione. Puoi aggiungere il seguente comando personalizzato:

COMMANDS_MODULE = 'mycmd.commands'

I comandi Scrapy possono essere aggiunti utilizzando la sezione scrapy.commands nel file setup.py mostrato come segue:

from setuptools import setup, find_packages  

setup(name = 'scrapy-module_demo', 
   entry_points = { 
      'scrapy.commands': [ 
         'cmd_demo = my_module.commands:CmdDemo', 
      ], 
   }, 
)

Il codice sopra aggiunge cmd_demo comando in setup.py file.

Descrizione

Spider è una classe responsabile della definizione di come seguire i collegamenti attraverso un sito web ed estrarre le informazioni dalle pagine.

I ragni predefiniti di Scrapy sono i seguenti:

scrapy.Ragno

È un ragno da cui devono ereditare tutti gli altri ragni. Ha la seguente classe:

class scrapy.spiders.Spider

La tabella seguente mostra i campi della classe scrapy.Spider -

Argomenti del ragno

Gli argomenti Spider vengono utilizzati per specificare gli URL di inizio e vengono passati utilizzando il comando di scansione con -a opzione, mostrata come segue:

scrapy crawl first_scrapy -a group = accessories

Il codice seguente mostra come uno spider riceve gli argomenti:

import scrapy 

class FirstSpider(scrapy.Spider): 
   name = "first" 
   
   def __init__(self, group = None, *args, **kwargs): 
      super(FirstSpider, self).__init__(*args, **kwargs) 
      self.start_urls = ["http://www.example.com/group/%s" % group]

Ragni generici

Puoi utilizzare ragni generici per sottoclassare i tuoi ragni. Il loro scopo è quello di seguire tutti i collegamenti sul sito Web in base a determinate regole per estrarre i dati da tutte le pagine.

Per gli esempi utilizzati nei seguenti spider, supponiamo di avere un progetto con i seguenti campi:

import scrapy 
from scrapy.item import Item, Field 
  
class First_scrapyItem(scrapy.Item): 
   product_title = Field() 
   product_link = Field() 
   product_description = Field()

CrawlSpider

CrawlSpider definisce una serie di regole per seguire i link e scartare più di una pagina. Ha la seguente classe:

class scrapy.spiders.CrawlSpider

Di seguito sono riportati gli attributi della classe CrawlSpider:

regole

È un elenco di oggetti regola che definisce il modo in cui il crawler segue il collegamento.

La tabella seguente mostra le regole della classe CrawlSpider -

parse_start_url (risposta)

Restituisce un oggetto o un oggetto richiesta consentendo di analizzare le risposte iniziali.

Note - Assicurati di rinominare la funzione di analisi diversa dall'analisi durante la scrittura delle regole perché la funzione di analisi viene utilizzata da CrawlSpider per implementare la sua logica.

Diamo un'occhiata al seguente esempio, in cui spider inizia a eseguire la scansione della home page di demoexample.com, raccogliendo tutte le pagine, i collegamenti e le analisi con il metodo parse_items -

import scrapy
from scrapy.spiders import CrawlSpider, Rule
from scrapy.linkextractors import LinkExtractor

class DemoSpider(CrawlSpider):
   name = "demo"
   allowed_domains = ["www.demoexample.com"]
   start_urls = ["http://www.demoexample.com"]
      
   rules = ( 
      Rule(LinkExtractor(allow =(), restrict_xpaths = ("//div[@class = 'next']",)),
         callback = "parse_item", follow = True),
   )
   
   def parse_item(self, response):
      item = DemoItem()
      item["product_title"] = response.xpath("a/text()").extract()
      item["product_link"] = response.xpath("a/@href").extract()
      item["product_description"] = response.xpath("div[@class = 'desc']/text()").extract()
      return items

XMLFeedSpider

È la classe base per i ragni che raschiano dai feed XML e itera sui nodi. Ha la seguente classe:

class scrapy.spiders.XMLFeedSpider

La tabella seguente mostra gli attributi di classe utilizzati per impostare un iteratore e un nome di tag -

CSVFeedSpider

Itera attraverso ciascuna delle sue righe, riceve un file CSV come risposta e chiama il metodo parse_row () . Ha la seguente classe:

class scrapy.spiders.CSVFeedSpider

La tabella seguente mostra le opzioni che possono essere impostate riguardo al file CSV -

Esempio CSVFeedSpider

from scrapy.spiders import CSVFeedSpider
from demoproject.items import DemoItem  

class DemoSpider(CSVFeedSpider): 
   name = "demo" 
   allowed_domains = ["www.demoexample.com"] 
   start_urls = ["http://www.demoexample.com/feed.csv"] 
   delimiter = ";" 
   quotechar = "'" 
   headers = ["product_title", "product_link", "product_description"]  
   
   def parse_row(self, response, row): 
      self.logger.info("This is row: %r", row)  
      item = DemoItem() 
      item["product_title"] = row["product_title"] 
      item["product_link"] = row["product_link"] 
      item["product_description"] = row["product_description"] 
      return item

Mappa del sitoSpider

SitemapSpider con l'aiuto delle Sitemap esegue la scansione di un sito web individuando gli URL da robots.txt. Ha la seguente classe:

class scrapy.spiders.SitemapSpider

La tabella seguente mostra i campi di SitemapSpider -

SitemapSpider Example

La seguente SitemapSpider elabora tutti gli URL:

from scrapy.spiders import SitemapSpider  

class DemoSpider(SitemapSpider): 
   urls = ["http://www.demoexample.com/sitemap.xml"]  
   
   def parse(self, response): 
      # You can scrap items here

La seguente SitemapSpider elabora alcuni URL con callback -

from scrapy.spiders import SitemapSpider  

class DemoSpider(SitemapSpider): 
   urls = ["http://www.demoexample.com/sitemap.xml"] 
   
   rules = [ 
      ("/item/", "parse_item"), 
      ("/group/", "parse_group"), 
   ]  
   
   def parse_item(self, response): 
      # you can scrap item here  
   
   def parse_group(self, response): 
      # you can scrap group here

Il codice seguente mostra le sitemap nel file robots.txt il cui URL ha /sitemap_company -

from scrapy.spiders import SitemapSpider

class DemoSpider(SitemapSpider): 
   urls = ["http://www.demoexample.com/robots.txt"] 
   rules = [ 
      ("/company/", "parse_company"), 
   ] 
   sitemap_follow = ["/sitemap_company"]  
   
   def parse_company(self, response): 
      # you can scrap company here

Puoi anche combinare SitemapSpider con altri URL come mostrato nel seguente comando.

from scrapy.spiders import SitemapSpider  

class DemoSpider(SitemapSpider): 
   urls = ["http://www.demoexample.com/robots.txt"] 
   rules = [ 
      ("/company/", "parse_company"), 
   ]  
   
   other_urls = ["http://www.demoexample.com/contact-us"] 
   def start_requests(self): 
      requests = list(super(DemoSpider, self).start_requests()) 
      requests += [scrapy.Request(x, self.parse_other) for x in self.other_urls] 
      return requests 

   def parse_company(self, response): 
      # you can scrap company here... 

   def parse_other(self, response): 
      # you can scrap other here...

Descrizione

Quando stai raschiando le pagine web, devi estrarre una certa parte del sorgente HTML usando il meccanismo chiamato selectors, ottenuto utilizzando espressioni XPath o CSS. I selettori si basano sulxml libreria, che elabora XML e HTML in linguaggio Python.

Usa il seguente frammento di codice per definire diversi concetti di selettori:

<html>
   <head>
      <title>My Website</title>
   </head>
   
   <body>
      <span>Hello world!!!</span>
      <div class = 'links'>
         <a href = 'one.html'>Link 1<img src = 'image1.jpg'/></a>
         <a href = 'two.html'>Link 2<img src = 'image2.jpg'/></a>
         <a href = 'three.html'>Link 3<img src = 'image3.jpg'/></a>
      </div>
   </body>
</html>

Costruire i selettori

È possibile costruire le istanze della classe selector passando il text o TextResponseoggetto. In base al tipo di input fornito, il selettore sceglie le seguenti regole:

from scrapy.selector import Selector 
from scrapy.http import HtmlResponse

Usando il codice sopra, puoi costruire dal testo come -

Selector(text = body).xpath('//span/text()').extract()

Visualizzerà il risultato come:

[u'Hello world!!!']

Puoi costruire dalla risposta come:

response = HtmlResponse(url = 'http://mysite.com', body = body) 
Selector(response = response).xpath('//span/text()').extract()

Visualizzerà il risultato come:

[u'Hello world!!!']

Utilizzo dei selettori

Usando il semplice snippet di codice sopra, puoi costruire l'XPath per selezionare il testo che è definito nel tag del titolo come mostrato di seguito -

>>response.selector.xpath('//title/text()')

Ora puoi estrarre i dati testuali usando il file .extract() metodo mostrato come segue -

>>response.xpath('//title/text()').extract()

Produrrà il risultato come:

[u'My Website']

È possibile visualizzare il nome di tutti gli elementi mostrati come segue:

>>response.xpath('//div[@class = "links"]/a/text()').extract()

Visualizzerà gli elementi come:

Link 1
Link 2
Link 3

Se vuoi estrarre il primo elemento, usa il metodo .extract_first(), mostrato come segue -

>>response.xpath('//div[@class = "links"]/a/text()').extract_first()

Mostrerà l'elemento come -

Link 1

Selettori di annidamento

Utilizzando il codice precedente, è possibile nidificare i selettori per visualizzare il collegamento alla pagina e l'origine dell'immagine utilizzando l'estensione .xpath() metodo, mostrato come segue:

links = response.xpath('//a[contains(@href, "image")]') 

for index, link in enumerate(links): 
   args = (index, link.xpath('@href').extract(), link.xpath('img/@src').extract()) 
   print 'The link %d pointing to url %s and image %s' % args

Visualizzerà il risultato come:

Link 1 pointing to url [u'one.html'] and image [u'image1.jpg']
Link 2 pointing to url [u'two.html'] and image [u'image2.jpg']
Link 3 pointing to url [u'three.html'] and image [u'image3.jpg']

Selettori che utilizzano espressioni regolari

Scrapy consente di estrarre i dati utilizzando espressioni regolari, che utilizza l'estensione .re()metodo. Dal codice HTML sopra, estrarremo i nomi delle immagini mostrati come segue:

>>response.xpath('//a[contains(@href, "image")]/text()').re(r'Name:\s*(.*)')

La riga sopra mostra i nomi delle immagini come -

[u'Link 1', 
u'Link 2', 
u'Link 3']

Utilizzo di XPath relativi

Quando lavori con XPaths, che inizia con il /, i selettori annidati e XPath sono correlati al percorso assoluto del documento e non al percorso relativo del selettore.

Se vuoi estrarre il file <p> elementi, quindi ottieni prima tutti gli elementi div -

>>mydiv = response.xpath('//div')

Successivamente, puoi estrarre tutti i file 'p' elementi all'interno, anteponendo a XPath un punto come .//p come mostrato di seguito -

>>for p in mydiv.xpath('.//p').extract()

Utilizzo delle estensioni EXSLT

EXSLT è una comunità che rilascia le estensioni per XSLT (Extensible Stylesheet Language Transformations) che converte i documenti XML in documenti XHTML. È possibile utilizzare le estensioni EXSLT con lo spazio dei nomi registrato nelle espressioni XPath come mostrato nella tabella seguente:

È possibile controllare il formato del codice semplice per l'estrazione dei dati utilizzando le espressioni regolari nella sezione precedente.

Ci sono alcuni suggerimenti XPath, utili quando si utilizza XPath con i selettori Scrapy. Per ulteriori informazioni, fare clic su questo collegamento .

Descrizione

Il processo scrapy può essere utilizzato per estrarre i dati da fonti come le pagine web utilizzando gli spider. Usi scrapyItem class per produrre l'output i cui oggetti vengono utilizzati per raccogliere i dati raschiati.

Dichiarazione di articoli

È possibile dichiarare gli elementi utilizzando la sintassi della definizione della classe insieme agli oggetti campo mostrati come segue:

import scrapy 
class MyProducts(scrapy.Item): 
   productName = Field() 
   productLink = Field() 
   imageURL = Field() 
   price = Field() 
   size = Field()

Campi oggetto

I campi elemento vengono utilizzati per visualizzare i metadati per ogni campo. Poiché non vi è alcuna limitazione di valori sugli oggetti campo, le chiavi dei metadati accessibili non contengono alcun elenco di riferimento dei metadati. Gli oggetti campo vengono utilizzati per specificare tutti i metadati del campo ed è possibile specificare qualsiasi altra chiave del campo secondo le proprie esigenze nel progetto. È possibile accedere agli oggetti campo utilizzando l'attributo Item.fields.

Lavorare con gli oggetti

Ci sono alcune funzioni comuni che possono essere definite quando si lavora con gli elementi. Per ulteriori informazioni, fare clic su questo collegamento .

Elementi di estensione

Gli elementi possono essere estesi affermando la sottoclasse dell'elemento originale. Ad esempio:

class MyProductDetails(Product): 
   original_rate = scrapy.Field(serializer = str) 
   discount_rate = scrapy.Field()

È possibile utilizzare i metadati del campo esistenti per estendere i metadati del campo aggiungendo più valori o modificando i valori esistenti come mostrato nel codice seguente:

class MyProductPackage(Product): 
   name = scrapy.Field(Product.fields['name'], serializer = serializer_demo)

Oggetti oggetto

Gli oggetti elemento possono essere specificati utilizzando la seguente classe che fornisce il nuovo elemento inizializzato dall'argomento dato -

class scrapy.item.Item([arg])

L'oggetto fornisce una copia del costruttore e fornisce un attributo aggiuntivo fornito dagli elementi nei campi.

Oggetti campo

Gli oggetti campo possono essere specificati utilizzando la seguente classe in cui la classe Field non emette il processo o gli attributi aggiuntivi:

class scrapy.item.Field([arg])

Descrizione

I caricatori di articoli forniscono un modo conveniente per riempire gli articoli che vengono raschiati dai siti web.

Dichiarazione di caricatori di articoli

La dichiarazione di Item Loaders è come Articoli.

Ad esempio:

from scrapy.loader import ItemLoader 
from scrapy.loader.processors import TakeFirst, MapCompose, Join  

class DemoLoader(ItemLoader):  
   default_output_processor = TakeFirst()  
   title_in = MapCompose(unicode.title) 
   title_out = Join()  
   size_in = MapCompose(unicode.strip)  
   # you can continue scraping here

Nel codice sopra, puoi vedere che i processori di input sono dichiarati usando _in suffisso e processori di output vengono dichiarati utilizzando _out suffisso.

Il ItemLoader.default_input_processor e ItemLoader.default_output_processor gli attributi vengono utilizzati per dichiarare i processori di input / output predefiniti.

Utilizzo dei caricatori di articoli per popolare gli articoli

Per utilizzare Item Loader, crea prima un'istanza con un oggetto dict-like o senza uno in cui l'elemento utilizza la classe Item specificata in ItemLoader.default_item_class attributo.

• È possibile utilizzare i selettori per raccogliere i valori nel caricatore articolo.

• È possibile aggiungere più valori nello stesso campo articolo, dove Item Loader utilizzerà un gestore appropriato per aggiungere questi valori.

Il codice seguente mostra come gli elementi vengono popolati utilizzando Item Loaders -

from scrapy.loader import ItemLoader 
from demoproject.items import Demo  

def parse(self, response): 
   l = ItemLoader(item = Product(), response = response)
   l.add_xpath("title", "//div[@class = 'product_title']")
   l.add_xpath("title", "//div[@class = 'product_name']")
   l.add_xpath("desc", "//div[@class = 'desc']")
   l.add_css("size", "div#size]")
   l.add_value("last_updated", "yesterday")
   return l.load_item()

Come mostrato sopra, ci sono due diversi XPath da cui il file title campo viene estratto utilizzando add_xpath() metodo -

1. //div[@class = "product_title"] 

2. //div[@class = "product_name"]

Successivamente, viene utilizzata una richiesta simile per desccampo. I dati sulle dimensioni vengono estratti utilizzandoadd_css() metodo e last_updated viene riempito con un valore "ieri" utilizzando add_value() metodo.

Una volta raccolti tutti i dati, chiama ItemLoader.load_item() metodo che restituisce gli elementi riempiti con i dati estratti utilizzando add_xpath(), add_css() e add_value() metodi.

Processori di input e output

Ogni campo di un Item Loader contiene un processore di input e un processore di output.

• Quando i dati vengono estratti, il processore di input li elabora e il risultato viene archiviato in ItemLoader.

• Successivamente, dopo aver raccolto i dati, chiama il metodo ItemLoader.load_item () per ottenere l'oggetto Item popolato.

• Infine, puoi assegnare il risultato del processore di output all'elemento.

Il codice seguente mostra come chiamare i processori di input e output per un campo specifico:

l = ItemLoader(Product(), some_selector)
l.add_xpath("title", xpath1) # [1]
l.add_xpath("title", xpath2) # [2]
l.add_css("title", css)      # [3]
l.add_value("title", "demo") # [4]
return l.load_item()         # [5]

Line 1 - I dati del titolo vengono estratti da xpath1 e passati attraverso il processore di input e il suo risultato viene raccolto e archiviato in ItemLoader.

Line 2 - Allo stesso modo, il titolo viene estratto da xpath2 e passato attraverso lo stesso processore di input e il suo risultato viene aggiunto ai dati raccolti per [1].

Line 3 - Il titolo viene estratto dal selettore css e passato attraverso lo stesso processore di input e il risultato viene aggiunto ai dati raccolti per [1] e [2].

Line 4 - Successivamente, il valore "demo" viene assegnato e passato attraverso i processori di input.

Line 5 - Infine, i dati vengono raccolti internamente da tutti i campi e passati al processore di output e il valore finale viene assegnato all'Articolo.

Dichiarazione di processori di input e output

I processori di input e output sono dichiarati nella definizione ItemLoader. Oltre a questo, possono anche essere specificati nel fileItem Field metadati.

Ad esempio:

import scrapy 
from scrapy.loader.processors import Join, MapCompose, TakeFirst 
from w3lib.html import remove_tags  

def filter_size(value): 
   if value.isdigit(): 
      return value  

class Item(scrapy.Item): 
   name = scrapy.Field( 
      input_processor = MapCompose(remove_tags), 
      output_processor = Join(), 
   )
   size = scrapy.Field( 
      input_processor = MapCompose(remove_tags, filter_price), 
      output_processor = TakeFirst(), 
   ) 

>>> from scrapy.loader import ItemLoader 
>>> il = ItemLoader(item = Product()) 
>>> il.add_value('title', [u'Hello', u'<strong>world</strong>']) 
>>> il.add_value('size', [u'<span>100 kg</span>']) 
>>> il.load_item()

Visualizza un output come -

{'title': u'Hello world', 'size': u'100 kg'}

Contesto caricatore articolo

Il contesto Item Loader è un dettato di valori chiave arbitrari condivisi tra processori di input e output.

Ad esempio, supponi di avere una funzione parse_length -

def parse_length(text, loader_context): 
   unit = loader_context.get('unit', 'cm') 
   
   # You can write parsing code of length here  
   return parsed_length

Ricevendo argomenti loader_context, comunica a Item Loader che può ricevere il contesto Item Loader. Esistono diversi modi per modificare il valore del contesto Item Loader:

• Modifica il contesto del caricatore articolo attivo corrente -

loader = ItemLoader (product)
loader.context ["unit"] = "mm"

• Sulla creazione di istanze di Item Loader -

loader = ItemLoader(product, unit = "mm")

• Sulla dichiarazione Item Loader per processori di input / output che crea un'istanza con il contesto Item Loader -

class ProductLoader(ItemLoader):
   length_out = MapCompose(parse_length, unit = "mm")

Oggetti ItemLoader

È un oggetto che restituisce un nuovo caricatore di elementi per popolare l'elemento specificato. Ha la seguente classe:

class scrapy.loader.ItemLoader([item, selector, response, ]**kwargs)

La tabella seguente mostra i parametri degli oggetti ItemLoader:

La tabella seguente mostra i metodi degli oggetti ItemLoader:

>>> from scrapy.loader.processors import TakeFirst
>>> loader.get_value(u'title: demoweb', TakeFirst(), 
unicode.upper, re = 'title: (.+)')
'DEMOWEB`

loader.add_value('title', u'DVD')
loader.add_value('colors', [u'black', u'white'])
loader.add_value('length', u'80')
loader.add_value('price', u'2500')

loader.replace_value('title', u'DVD')
loader.replace_value('colors', [u'black', 
u'white'])
loader.replace_value('length', u'80')
loader.replace_value('price', u'2500')

# HTML code: <div class = "item-name">DVD</div>
loader.get_xpath("//div[@class = 
'item-name']")

# HTML code: <div id = "length">the length is 
45cm</div>
loader.get_xpath("//div[@id = 'length']", TakeFirst(), 
re = "the length is (.*)")

# HTML code: <div class = "item-name">DVD</div>
loader.add_xpath('name', '//div
[@class = "item-name"]')

# HTML code: <div id = "length">the length is 
45cm</div>
loader.add_xpath('length', '//div[@id = "length"]',
 re = 'the length is (.*)')

# HTML code: <div class = "item-name">DVD</div>
loader.replace_xpath('name', '
//div[@class = "item-name"]')

# HTML code: <div id = "length">the length is
 45cm</div>
loader.replace_xpath('length', '
//div[@id = "length"]', re = 'the length is (.*)')

loader.get_css("div.item-name")
loader.get_css("div#length", TakeFirst(), 
re = "the length is (.*)")

loader.add_css('name', 'div.item-name')
loader.add_css('length', 'div#length', 
re = 'the length is (.*)')

loader.replace_css('name', 'div.item-name')
loader.replace_css('length', 'div#length',
 re = 'the length is (.*)')

def parse(self, response):
l = ItemLoader(item = Product(), 
response = response)
l.add_xpath('title', '//
div[@class = "product_title"]')
loader.load_item()

loader = ItemLoader(item = Item())
loader.add_xpath('social', '
a[@class = "social"]/@href')
loader.add_xpath('email', '
a[@class = "email"]/@href')

loader = ItemLoader(item = Item())
loader.add_css('social', 'a[@class = "social"]/@href')
loader.add_css('email', 'a[@class = "email"]/@href')

La tabella seguente mostra gli attributi degli oggetti ItemLoader:

Caricatori annidati

Viene utilizzato per creare caricatori annidati durante l'analisi dei valori dalla sottosezione di un documento. Se non crei caricatori nidificati, devi specificare XPath o CSS completi per ogni valore che desideri estrarre.

Ad esempio, supponiamo che i dati vengano estratti da una pagina di intestazione:

<header>
   <a class = "social" href = "http://facebook.com/whatever">facebook</a>
   <a class = "social" href = "http://twitter.com/whatever">twitter</a>
   <a class = "email" href = "mailto:[email protected]">send mail</a>
</header>

Successivamente, puoi creare un caricatore nidificato con il selettore di intestazione aggiungendo valori correlati all'intestazione -

loader = ItemLoader(item = Item())
header_loader = loader.nested_xpath('//header')
header_loader.add_xpath('social', 'a[@class = "social"]/@href')
header_loader.add_xpath('email', 'a[@class = "email"]/@href')
loader.load_item()

Riutilizzo ed estensione dei caricatori di articoli

I caricatori di oggetti sono progettati per alleviare la manutenzione che diventa un problema fondamentale quando il tuo progetto acquisisce più ragni.

Ad esempio, supponi che un sito abbia il nome del prodotto racchiuso tra tre trattini (ad esempio --DVD ---). È possibile rimuovere questi trattini riutilizzando il caricatore di articoli prodotto predefinito, se non lo si desidera nei nomi dei prodotti finali come mostrato nel codice seguente:

from scrapy.loader.processors import MapCompose 
from demoproject.ItemLoaders import DemoLoader  

def strip_dashes(x): 
   return x.strip('-')  

class SiteSpecificLoader(DemoLoader): 
   title_in = MapCompose(strip_dashes, DemoLoader.title_in)

Processori integrati disponibili

Di seguito sono riportati alcuni dei processori integrati comunemente usati:

class scrapy.loader.processors.Identity

Restituisce il valore originale senza alterarlo. Ad esempio:

>>> from scrapy.loader.processors import Identity
>>> proc = Identity()
>>> proc(['a', 'b', 'c'])
['a', 'b', 'c']

class scrapy.loader.processors.TakeFirst

Restituisce il primo valore non nullo / non vuoto dall'elenco dei valori ricevuti. Ad esempio:

>>> from scrapy.loader.processors import TakeFirst
>>> proc = TakeFirst()
>>> proc(['', 'a', 'b', 'c'])
'a'

class scrapy.loader.processors.Join (separator = u '')

Restituisce il valore allegato al separatore. Il separatore predefinito è u '' ed è equivalente alla funzioneu' '.join. Ad esempio:

>>> from scrapy.loader.processors import Join
>>> proc = Join()
>>> proc(['a', 'b', 'c'])
u'a b c'
>>> proc = Join('<br>')
>>> proc(['a', 'b', 'c'])
u'a<br>b<br>c'

class scrapy.loader.processors.Compose (* funzioni, ** default_loader_context)

È definito da un processore in cui ciascuno dei suoi valori di input viene passato alla prima funzione, e il risultato di quella funzione viene passato alla seconda funzione e così via, finché la funzione ast restituisce il valore finale come output.

Ad esempio:

>>> from scrapy.loader.processors import Compose
>>> proc = Compose(lambda v: v[0], str.upper)
>>> proc(['python', 'scrapy'])
'PYTHON'

class scrapy.loader.processors.MapCompose (* funzioni, ** default_loader_context)

È un processore in cui il valore di input viene iterato e la prima funzione viene applicata a ciascun elemento. Successivamente, il risultato di queste chiamate di funzione viene concatenato per creare un nuovo iterabile che viene quindi applicato alla seconda funzione e così via, fino all'ultima funzione.

Ad esempio:

>>> def filter_scrapy(x): 
   return None if x == 'scrapy' else x  

>>> from scrapy.loader.processors import MapCompose 
>>> proc = MapCompose(filter_scrapy, unicode.upper) 
>>> proc([u'hi', u'everyone', u'im', u'pythonscrapy']) 
[u'HI, u'IM', u'PYTHONSCRAPY']

class scrapy.loader.processors.SelectJmes (json_path)

Questa classe interroga il valore utilizzando il percorso json fornito e restituisce l'output.

Ad esempio:

>>> from scrapy.loader.processors import SelectJmes, Compose, MapCompose
>>> proc = SelectJmes("hello")
>>> proc({'hello': 'scrapy'})
'scrapy'
>>> proc({'hello': {'scrapy': 'world'}})
{'scrapy': 'world'}

Di seguito è riportato il codice, che interroga il valore importando json -

>>> import json
>>> proc_single_json_str = Compose(json.loads, SelectJmes("hello"))
>>> proc_single_json_str('{"hello": "scrapy"}')
u'scrapy'
>>> proc_json_list = Compose(json.loads, MapCompose(SelectJmes('hello')))
>>> proc_json_list('[{"hello":"scrapy"}, {"world":"env"}]')
[u'scrapy']

Descrizione

Scrapy shell può essere utilizzato per scartare i dati con codice privo di errori, senza l'uso di spider. Lo scopo principale della shell Scrapy è testare il codice estratto, XPath o le espressioni CSS. Aiuta anche a specificare le pagine web da cui stai estraendo i dati.

Configurazione della shell

La shell può essere configurata installando la console IPython (utilizzata per l'elaborazione interattiva), che è una potente shell interattiva che fornisce il completamento automatico, l'output colorato, ecc.

Se stai lavorando sulla piattaforma Unix, è meglio installare IPython. Puoi anche usare bpython , se IPython è inaccessibile.

È possibile configurare la shell impostando la variabile di ambiente chiamata SCRAPY_PYTHON_SHELL o definendo il file scrapy.cfg come segue:

[settings]
shell = bpython

Avvio della shell

Scrapy Shell può essere lanciato utilizzando il seguente comando:

scrapy shell <url>

L' URL specifica l'URL per il quale i dati devono essere raschiati.

Utilizzando la Shell

La shell fornisce alcune scorciatoie aggiuntive e oggetti Scrapy come descritto nella tabella seguente:

Scorciatoie disponibili

Shell fornisce le seguenti scorciatoie disponibili nel progetto:

Oggetti Scrapy disponibili

Shell fornisce i seguenti oggetti Scrapy disponibili nel progetto:

Esempio di sessione di shell

Proviamo a eseguire lo scrapy del sito scrapy.org e quindi iniziamo a eliminare i dati da reddit.com come descritto.

Prima di andare avanti, per prima cosa avvieremo la shell come mostrato nel seguente comando:

scrapy shell 'http://scrapy.org' --nolog

Scrapy mostrerà gli oggetti disponibili durante l'utilizzo dell'URL sopra -

[s] Available Scrapy objects:
[s]   crawler    <scrapy.crawler.Crawler object at 0x1e16b50>
[s]   item       {}
[s]   request    <GET http://scrapy.org >
[s]   response   <200 http://scrapy.org >
[s]   settings   <scrapy.settings.Settings object at 0x2bfd650>
[s]   spider     <Spider 'default' at 0x20c6f50>
[s] Useful shortcuts:
[s]   shelp()           Provides available objects and shortcuts with help option
[s]   fetch(req_or_url) Collects the response from the request or URL and associated 
objects will get update
[s]   view(response)    View the response for the given request

Quindi, inizia con il lavoro degli oggetti, mostrato come segue:

>> response.xpath('//title/text()').extract_first() 
u'Scrapy | A Fast and Powerful Scraping and Web Crawling Framework'  
>> fetch("http://reddit.com") 
[s] Available Scrapy objects: 
[s]   crawler     
[s]   item       {} 
[s]   request     
[s]   response   <200 https://www.reddit.com/> 
[s]   settings    
[s]   spider      
[s] Useful shortcuts: 
[s]   shelp()           Shell help (print this help) 
[s]   fetch(req_or_url) Fetch request (or URL) and update local objects 
[s]   view(response)    View response in a browser  
>> response.xpath('//title/text()').extract() 
[u'reddit: the front page of the internet']  
>> request = request.replace(method="POST")  
>> fetch(request) 
[s] Available Scrapy objects: 
[s]   crawler     
...

Invocare la shell dagli spider per esaminare le risposte

Puoi esaminare le risposte che vengono elaborate dallo spider, solo se ti aspetti di ottenere quella risposta.

Ad esempio:

import scrapy 

class SpiderDemo(scrapy.Spider): 
   name = "spiderdemo" 
   start_urls = [ 
      "http://mysite.com", 
      "http://mysite1.org", 
      "http://mysite2.net", 
   ]  
   
   def parse(self, response): 
      # You can inspect one specific response 
      if ".net" in response.url: 
         from scrapy.shell import inspect_response 
         inspect_response(response, self)

Come mostrato nel codice sopra, puoi invocare la shell dagli spider per ispezionare le risposte usando la seguente funzione:

scrapy.shell.inspect_response

Ora esegui il ragno e otterrai la seguente schermata:

2016-02-08 18:15:20-0400 [scrapy] DEBUG: Crawled (200)  (referer: None) 
2016-02-08 18:15:20-0400 [scrapy] DEBUG: Crawled (200)  (referer: None) 
2016-02-08 18:15:20-0400 [scrapy] DEBUG: Crawled (200)  (referer: None) 
[s] Available Scrapy objects: 
[s]   crawler     
...  
>> response.url 
'http://mysite2.org'

È possibile verificare se il codice estratto funziona utilizzando il codice seguente:

>> response.xpath('//div[@class = "val"]')

Visualizza l'output come

[]

La riga sopra ha visualizzato solo un output vuoto. Ora puoi invocare la shell per ispezionare la risposta come segue:

>> view(response)

Visualizza la risposta come

True

Descrizione

Item Pipelineè un metodo in cui vengono elaborati gli articoli scartati. Quando un elemento viene inviato alla pipeline degli elementi, viene raschiato da uno spider ed elaborato utilizzando diversi componenti, che vengono eseguiti in sequenza.

Ogni volta che viene ricevuto un articolo, decide una delle seguenti azioni:

• Continua a processare l'oggetto.
• Rilascialo dalla pipeline.
• Interrompi l'elaborazione dell'articolo.

Le pipeline degli articoli vengono generalmente utilizzate per i seguenti scopi:

• Archiviazione degli elementi raschiati nel database.
• Se l'elemento ricevuto viene ripetuto, verrà rilasciato l'elemento ripetuto.
• Controllerà se l'elemento è con campi mirati.
• Cancellazione dei dati HTML.

Sintassi

È possibile scrivere la pipeline degli articoli utilizzando il metodo seguente:

process_item(self, item, spider)

Il metodo sopra contiene i seguenti parametri:

• Oggetto (oggetto oggetto o dizionario): specifica l'elemento raschiato.
• ragno (oggetto ragno) - Il ragno che ha raschiato l'oggetto.

È possibile utilizzare metodi aggiuntivi indicati nella tabella seguente:

Esempio

Di seguito sono riportati gli esempi di pipeline di elementi utilizzati in diversi concetti.

Eliminazione di elementi senza tag

Nel codice seguente, la pipeline bilancia l' attributo (prezzo) per quegli articoli che non includono l'IVA (attributo excles_vat) e ignora gli articoli che non hanno un cartellino del prezzo -

from Scrapy.exceptions import DropItem  
class PricePipeline(object): 
   vat = 2.25 

   def process_item(self, item, spider): 
      if item['price']: 
         if item['excludes_vat']: 
            item['price'] = item['price'] * self.vat 
            return item 
         else: 
            raise DropItem("Missing price in %s" % item)

Scrittura di elementi in un file JSON

Il codice seguente memorizzerà tutti gli elementi raschiati da tutti i ragni in un unico file items.jlfile, che contiene un elemento per riga in un formato serializzato in formato JSON. IlJsonWriterPipeline class viene utilizzata nel codice per mostrare come scrivere la pipeline di elementi -

import json  

class JsonWriterPipeline(object): 
   def __init__(self): 
      self.file = open('items.jl', 'wb') 

   def process_item(self, item, spider): 
      line = json.dumps(dict(item)) + "\n" 
      self.file.write(line) 
      return item

Scrittura di elementi in MongoDB

Puoi specificare l'indirizzo MongoDB e il nome del database nelle impostazioni di Scrapy e la raccolta MongoDB può essere denominata in base alla classe dell'elemento. Il codice seguente descrive come usarefrom_crawler() metodo per raccogliere correttamente le risorse -

import pymongo  

class MongoPipeline(object):  
   collection_name = 'Scrapy_list' 

   def __init__(self, mongo_uri, mongo_db): 
      self.mongo_uri = mongo_uri 
      self.mongo_db = mongo_db 

   @classmethod 
   def from_crawler(cls, crawler): 
      return cls( 
         mongo_uri = crawler.settings.get('MONGO_URI'), 
         mongo_db = crawler.settings.get('MONGO_DB', 'lists') 
      ) 
  
   def open_spider(self, spider): 
      self.client = pymongo.MongoClient(self.mongo_uri) 
      self.db = self.client[self.mongo_db] 

   def close_spider(self, spider): 
      self.client.close() 

   def process_item(self, item, spider): 
      self.db[self.collection_name].insert(dict(item)) 
      return item

Filtri di duplicazione

Un filtro controllerà gli elementi ripetuti e rimuoverà gli elementi già elaborati. Nel codice seguente, abbiamo utilizzato un ID univoco per i nostri articoli, ma spider restituisce molti articoli con lo stesso ID -

from scrapy.exceptions import DropItem  

class DuplicatesPipeline(object):  
   def __init__(self): 
      self.ids_seen = set() 

   def process_item(self, item, spider): 
      if item['id'] in self.ids_seen: 
         raise DropItem("Repeated items found: %s" % item) 
      else: 
         self.ids_seen.add(item['id']) 
         return item

Attivazione di una pipeline di articoli

È possibile attivare un componente Item Pipeline aggiungendo la sua classe all'impostazione ITEM_PIPELINES come mostrato nel codice seguente. È possibile assegnare valori interi alle classi nell'ordine in cui vengono eseguite (l'ordine può essere di valore inferiore a classi di valore superiore) e i valori saranno compresi nell'intervallo 0-1000.

ITEM_PIPELINES = {
   'myproject.pipelines.PricePipeline': 100,
   'myproject.pipelines.JsonWriterPipeline': 600,
}

Descrizione

Le esportazioni di feed sono un metodo per archiviare i dati estratti dai siti, che genera un file "export file".

Formati di serializzazione

Utilizzando più formati di serializzazione e backend di archiviazione, Feed Exports utilizza gli esportatori di articoli e genera un feed con articoli raschiati.

La tabella seguente mostra i formati supportati -

Utilizzando FEED_EXPORTERS impostazioni, i formati supportati possono anche essere estesi -

Backend di archiviazione

Il backend di archiviazione definisce dove archiviare il feed utilizzando l'URI.

La tabella seguente mostra i backend di archiviazione supportati:

Parametri URI di archiviazione

Di seguito sono riportati i parametri dell'URL di archiviazione, che viene sostituito durante la creazione del feed:

• % (time) s: questo parametro viene sostituito da un timestamp.
• % (name) s: questo parametro viene sostituito dal nome dello spider.

impostazioni

La tabella seguente mostra le impostazioni con cui è possibile configurare le esportazioni di feed:

Descrizione

Scrapy può eseguire la scansione di siti Web utilizzando il Request e Responseoggetti. Gli oggetti di richiesta passano sul sistema, utilizza gli spider per eseguire la richiesta e tornare alla richiesta quando restituisce un oggetto di risposta.

Richiedi oggetti

L'oggetto richiesta è una richiesta HTTP che genera una risposta. Ha la seguente classe:

class scrapy.http.Request(url[, callback, method = 'GET', headers, body, cookies, meta,
   encoding = 'utf-8', priority = 0, dont_filter = False, errback])

La tabella seguente mostra i parametri degli oggetti Request -

Passaggio di dati aggiuntivi alle funzioni di callback

La funzione di callback di una richiesta viene chiamata quando la risposta viene scaricata come primo parametro.

Ad esempio:

def parse_page1(self, response): 
   return scrapy.Request("http://www.something.com/some_page.html", 
      callback = self.parse_page2)  

def parse_page2(self, response): 
   self.logger.info("%s page visited", response.url)

Puoi usare Request.meta attributo, se si desidera passare argomenti a funzioni richiamabili e ricevere tali argomenti nel secondo callback come mostrato nell'esempio seguente:

def parse_page1(self, response): 
   item = DemoItem() 
   item['foremost_link'] = response.url 
   request = scrapy.Request("http://www.something.com/some_page.html", 
      callback = self.parse_page2) 
   request.meta['item'] = item 
   return request  

def parse_page2(self, response): 
   item = response.meta['item'] 
   item['other_link'] = response.url 
   return item

Utilizzo di errback per rilevare le eccezioni nell'elaborazione delle richieste

L'errback è una funzione richiamabile da chiamare quando viene sollevata un'eccezione durante l'elaborazione di una richiesta.

Il seguente esempio lo dimostra:

import scrapy  

from scrapy.spidermiddlewares.httperror import HttpError 
from twisted.internet.error import DNSLookupError 
from twisted.internet.error import TimeoutError, TCPTimedOutError  

class DemoSpider(scrapy.Spider): 
   name = "demo" 
   start_urls = [ 
      "http://www.httpbin.org/",              # HTTP 200 expected 
      "http://www.httpbin.org/status/404",    # Webpage not found  
      "http://www.httpbin.org/status/500",    # Internal server error 
      "http://www.httpbin.org:12345/",        # timeout expected 
      "http://www.httphttpbinbin.org/",       # DNS error expected 
   ]  
   
   def start_requests(self): 
      for u in self.start_urls: 
         yield scrapy.Request(u, callback = self.parse_httpbin, 
         errback = self.errback_httpbin, 
         dont_filter=True)  
   
   def parse_httpbin(self, response): 
      self.logger.info('Recieved response from {}'.format(response.url)) 
      # ...  
   
   def errback_httpbin(self, failure): 
      # logs failures 
      self.logger.error(repr(failure))  
      
      if failure.check(HttpError): 
         response = failure.value.response 
         self.logger.error("HttpError occurred on %s", response.url)  
      
      elif failure.check(DNSLookupError): 
         request = failure.request 
         self.logger.error("DNSLookupError occurred on %s", request.url) 

      elif failure.check(TimeoutError, TCPTimedOutError): 
         request = failure.request 
         self.logger.error("TimeoutError occurred on %s", request.url)

Request.meta Special Keys

Le chiavi speciali request.meta sono un elenco di meta chiavi speciali identificate da Scrapy.

La tabella seguente mostra alcune delle chiavi di Request.meta -

Richiedi sottoclassi

È possibile implementare la propria funzionalità personalizzata creando una sottoclasse della classe di richiesta. Le sottoclassi di richiesta integrate sono le seguenti:

Oggetti FormRequest

La classe FormRequest si occupa dei moduli HTML estendendo la richiesta di base. Ha la seguente classe:

class scrapy.http.FormRequest(url[,formdata, callback, method = 'GET', headers, body, 
   cookies, meta, encoding = 'utf-8', priority = 0, dont_filter = False, errback])

Di seguito è riportato il parametro:

formdata - È un dizionario con i dati del modulo HTML assegnati al corpo della richiesta.

Note - I parametri rimanenti sono gli stessi della classe di richiesta ed è spiegato in Request Objects sezione.

I seguenti metodi di classe sono supportati da FormRequest oggetti oltre ai metodi di richiesta -

classmethod from_response(response[, formname = None, formnumber = 0, formdata = None, 
   formxpath = None, formcss = None, clickdata = None, dont_click = False, ...])

La tabella seguente mostra i parametri della classe di cui sopra -

Esempi

Di seguito sono riportati alcuni esempi di utilizzo della richiesta:

Using FormRequest to send data via HTTP POST

Il codice seguente mostra come restituire FormRequest oggetto quando vuoi duplicare il modulo HTML POST nel tuo spider -

return [FormRequest(url = "http://www.something.com/post/action", 
   formdata = {'firstname': 'John', 'lastname': 'dave'}, 
   callback = self.after_post)]

Using FormRequest.from_response() to simulate a user login

Normalmente, i siti Web utilizzano elementi attraverso i quali fornisce campi modulo precompilati.

Il FormRequest.form_response() può essere utilizzato quando si desidera che questi campi vengano popolati automaticamente durante lo scraping.

Il seguente esempio lo dimostra.

import scrapy  
class DemoSpider(scrapy.Spider): 
   name = 'demo' 
   start_urls = ['http://www.something.com/users/login.php']  
   def parse(self, response): 
      return scrapy.FormRequest.from_response( 
         response, 
         formdata = {'username': 'admin', 'password': 'confidential'}, 
         callback = self.after_login 
      )  
   
   def after_login(self, response): 
      if "authentication failed" in response.body: 
         self.logger.error("Login failed") 
         return  
      # You can continue scraping here

Oggetti risposta

È un oggetto che indica la risposta HTTP che viene fornita agli spider per l'elaborazione. Ha la seguente classe:

class scrapy.http.Response(url[, status = 200, headers, body, flags])

La tabella seguente mostra i parametri degli oggetti Response:

Sottoclassi di risposta

È possibile implementare la propria funzionalità personalizzata creando una sottoclasse della classe di risposta. Le sottoclassi di risposta integrate sono le seguenti:

TextResponse objects

Gli oggetti TextResponse vengono utilizzati per dati binari come immagini, suoni, ecc. Che hanno la capacità di codificare la classe Response di base. Ha la seguente classe:

class scrapy.http.TextResponse(url[, encoding[,status = 200, headers, body, flags]])

Di seguito è riportato il parametro:

encoding - È una stringa con codifica utilizzata per codificare una risposta.

Note - I parametri rimanenti sono gli stessi della classe di risposta ed è spiegato in Response Objects sezione.

La tabella seguente mostra gli attributi supportati dall'oggetto TextResponse oltre ai metodi di risposta:

La tabella seguente mostra i metodi supportati dagli oggetti TextResponse oltre ai metodi di risposta :

Oggetti HtmlResponse

È un oggetto che supporta la codifica e l'auto-discovery osservando l' attributo metatpequiv dell'HTML. I suoi parametri sono gli stessi della classe di risposta ed è spiegato nella sezione Oggetti risposta. Ha la seguente classe:

class scrapy.http.HtmlResponse(url[,status = 200, headers, body, flags])

Oggetti XmlResponse

È un oggetto che supporta la codifica e l'auto-discovery guardando la riga XML. I suoi parametri sono gli stessi della classe di risposta ed è spiegato nella sezione Oggetti risposta. Ha la seguente classe:

class scrapy.http.XmlResponse(url[, status = 200, headers, body, flags])

Descrizione

Come indica il nome stesso, Link Extractors sono gli oggetti che vengono utilizzati per estrarre i link dalle pagine web utilizzando scrapy.http.Responseoggetti. In Scrapy, ci sono estrattori incorporati comescrapy.linkextractors importare LinkExtractor. Puoi personalizzare il tuo estrattore di link in base alle tue esigenze implementando una semplice interfaccia.

Ogni estrattore di link ha un metodo pubblico chiamato extract_linksche include un oggetto Response e restituisce un elenco di oggetti scrapy.link.Link. Puoi istanziare gli estrattori di link solo una volta e chiamare più volte il metodo extract_links per estrarre link con risposte diverse. La CrawlSpiderclass utilizza estrattori di link con una serie di regole il cui scopo principale è estrarre i link.

Riferimento di Link Extractor integrato

Normalmente gli estrattori di link sono raggruppati con Scrapy e sono forniti nel modulo scrapy.linkextractors. Per impostazione predefinita, l'estrattore di link sarà LinkExtractor che è uguale in funzionalità a LxmlLinkExtractor -

from scrapy.linkextractors import LinkExtractor

LxmlLinkExtractor

class scrapy.linkextractors.lxmlhtml.LxmlLinkExtractor(allow = (), deny = (), 
   allow_domains = (), deny_domains = (), deny_extensions = None, restrict_xpaths = (), 
   restrict_css = (), tags = ('a', 'area'), attrs = ('href', ), 
   canonicalize = True, unique = True, process_value = None)

Il LxmlLinkExtractor è un estrattore di collegamento altamente raccomandato, perché ha opzioni di filtraggio a portata di mano e viene utilizzato con HTMLParser robusta di lxml.

Esempio

Il codice seguente viene utilizzato per estrarre i collegamenti:

<a href = "javascript:goToPage('../other/page.html'); return false">Link text</a>

La seguente funzione di codice può essere utilizzata in process_value -

def process_value(val): 
   m = re.search("javascript:goToPage\('(.*?)'", val) 
   if m: 
      return m.group(1)

Descrizione

Il comportamento dei componenti Scrapy può essere modificato utilizzando le impostazioni Scrapy. Le impostazioni possono anche selezionare il progetto Scrapy attualmente attivo, nel caso tu abbia più progetti Scrapy.

Designazione delle impostazioni

Devi notificare a Scrapy quale impostazione stai utilizzando quando scarti un sito web. Per questo, variabile d'ambienteSCRAPY_SETTINGS_MODULE dovrebbe essere usato e il suo valore dovrebbe essere nella sintassi del percorso Python.

Popolamento delle impostazioni

La tabella seguente mostra alcuni dei meccanismi con cui è possibile popolare le impostazioni:

scrapy crawl myspider -s LOG_FILE = scrapy.log

class DemoSpider(scrapy.Spider): 
   name = 'demo'  
   custom_settings = { 
      'SOME_SETTING': 'some value', 
   }

Impostazioni di accesso

Sono disponibili tramite self.settings e impostati nello spider di base dopo che è stato inizializzato.

Il seguente esempio lo dimostra.

class DemoSpider(scrapy.Spider): 
   name = 'demo' 
   start_urls = ['http://example.com']  
   def parse(self, response): 
      print("Existing settings: %s" % self.settings.attributes.keys())

Per utilizzare le impostazioni prima di inizializzare lo spider, devi sovrascrivere il metodo from_crawler nel metodo _init_ () del tuo spider. È possibile accedere alle impostazioni tramite l'attributo scrapy.crawler.Crawler.settings passato al metodo from_crawler .

Il seguente esempio lo dimostra.

class MyExtension(object): 
   def __init__(self, log_is_enabled = False): 
      if log_is_enabled: 
         print("Enabled log") 
         @classmethod 
   def from_crawler(cls, crawler): 
      settings = crawler.settings 
      return cls(settings.getbool('LOG_ENABLED'))

Motivazioni per l'impostazione dei nomi

I nomi delle impostazioni vengono aggiunti come prefisso al componente che configurano. Ad esempio, per l'estensione robots.txt, i nomi delle impostazioni possono essere ROBOTSTXT_ENABLED, ROBOTSTXT_OBEY, ROBOTSTXT_CACHEDIR e così via.

Riferimento alle impostazioni integrate

La tabella seguente mostra le impostazioni integrate di Scrapy:

{  
   'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,
	*/*;q=0.8', 'Accept-Language': 'en',  
}

{ 'scrapy.downloadermiddlewares.robotstxt.RobotsTxtMiddleware': 100, }

{ 'file': 'scrapy.core.downloader.handlers.file.FileDownloadHandler', }

{ 
   'scrapy.contracts.default.UrlContract' : 1, 
   'scrapy.contracts.default.ReturnsContract': 2, 
}

{ 
   'scrapy.spidermiddlewares.httperror.HttpErrorMiddleware': 50, 
}

Per altre impostazioni di Scrapy, vai a questo link .

Descrizione

Gli eventi irregolari sono indicati come eccezioni. In Scrapy, le eccezioni vengono sollevate per motivi quali la configurazione mancante, l'eliminazione di un elemento dalla pipeline degli elementi, ecc. Di seguito è riportato l'elenco delle eccezioni menzionate in Scrapy e la loro applicazione.

Lasciare oggetto

Item Pipeline utilizza questa eccezione per interrompere l'elaborazione dell'articolo in qualsiasi fase. Può essere scritto come -

exception (scrapy.exceptions.DropItem)

CloseSpider

Questa eccezione viene utilizzata per arrestare lo spider utilizzando la richiesta di richiamata. Può essere scritto come -

exception (scrapy.exceptions.CloseSpider)(reason = 'cancelled')

Contiene il parametro chiamato reason (str) che specifica il motivo della chiusura.

Ad esempio, il codice seguente mostra l'utilizzo di questa eccezione:

def parse_page(self, response): 
   if 'Bandwidth exceeded' in response.body: 
      raise CloseSpider('bandwidth_exceeded')

IgnoreRequest

Questa eccezione viene utilizzata dallo scheduler o dal middleware del downloader per ignorare una richiesta. Può essere scritto come -

exception (scrapy.exceptions.IgnoreRequest)

Non configurato

Indica una situazione di configurazione mancante e dovrebbe essere generato in un costruttore di componenti.

exception (scrapy.exceptions.NotConfigured)

Questa eccezione può essere sollevata se uno dei seguenti componenti è disabilitato.

• Extensions
• Pipeline di articoli
• Middleware del downloader
• Middleware Spider

Non supportato

Questa eccezione viene sollevata quando una funzione o un metodo non è supportato. Può essere scritto come -

exception (scrapy.exceptions.NotSupported)

Descrizione

Per eliminare i dati dalle pagine web, prima devi creare il progetto Scrapy in cui memorizzerai il codice. Per creare una nuova directory, esegui il seguente comando:

scrapy startproject first_scrapy

Il codice sopra creerà una directory con nome first_scrapy e conterrà la seguente struttura:

first_scrapy/
scrapy.cfg            # deploy configuration file
first_scrapy/         # project's Python module, you'll import your code from here
__init__.py
items.py              # project items file
pipelines.py          # project pipelines file
settings.py           # project settings file
spiders/              # a directory where you'll later put your spiders
__init__.py

Descrizione

Gli elementi sono i contenitori utilizzati per raccogliere i dati che vengono scartati dai siti web. Devi avviare il tuo ragno definendo il tuo oggetto. Per definire gli elementi, modificaitems.py file trovato nella directory first_scrapy(directory personalizzata). Il file items.py ha il seguente aspetto:

import scrapy  

class First_scrapyItem(scrapy.Item): 
   # define the fields for your item here like: 
      # name = scrapy.Field()

La classe MyItem eredita da Item contenente un numero di oggetti predefiniti che Scrapy ha già creato per noi. Ad esempio, se si desidera estrarre il nome, l'URL e la descrizione dai siti, è necessario definire i campi per ciascuno di questi tre attributi.

Quindi, aggiungiamo quegli oggetti che vogliamo raccogliere -

from scrapy.item import Item, Field  

class First_scrapyItem(scrapy.Item): 
   name = scrapy.Field() 
   url = scrapy.Field() 
   desc = scrapy.Field()

Descrizione

Spider è una classe che definisce l'URL iniziale da cui estrarre i dati, come seguire i collegamenti di impaginazione e come estrarre e analizzare i campi definiti nel items.py. Scrapy fornisce diversi tipi di ragni, ognuno dei quali ha uno scopo specifico.

Crea un file chiamato "first_spider.py"nella directory first_scrapy / spiders, dove possiamo dire a Scrapy come trovare i dati esatti che stiamo cercando. Per questo, è necessario definire alcuni attributi:

• name - Definisce il nome univoco del ragno.

• allowed_domains - Contiene gli URL di base per la scansione dello spider.

• start-urls - Un elenco di URL da cui lo spider inizia a eseguire la scansione.

• parse() - È un metodo che estrae e analizza i dati raschiati.

Il codice seguente mostra l'aspetto di un codice spider:

import scrapy  

class firstSpider(scrapy.Spider): 
   name = "first" 
   allowed_domains = ["dmoz.org"] 
   
   start_urls = [ 
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/", 
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/" 
   ]  
   def parse(self, response): 
      filename = response.url.split("/")[-2] + '.html' 
      with open(filename, 'wb') as f: 
         f.write(response.body)

Descrizione

Per eseguire il tuo spider, esegui il seguente comando nella tua directory first_scrapy -

scrapy crawl first

Dove, first è il nome del ragno specificato durante la creazione del ragno.

Una volta che il ragno striscia, puoi vedere il seguente output:

2016-08-09 18:13:07-0400 [scrapy] INFO: Scrapy started (bot: tutorial)
2016-08-09 18:13:07-0400 [scrapy] INFO: Optional features available: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Overridden settings: {}
2016-08-09 18:13:07-0400 [scrapy] INFO: Enabled extensions: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Enabled downloader middlewares: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Enabled spider middlewares: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Enabled item pipelines: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Spider opened
2016-08-09 18:13:08-0400 [scrapy] DEBUG: Crawled (200) 
<GET http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/> (referer: None)
2016-08-09 18:13:09-0400 [scrapy] DEBUG: Crawled (200) 
<GET http://www.dmoz.org/Computers/Programming/Languages/Python/Books/> (referer: None)
2016-08-09 18:13:09-0400 [scrapy] INFO: Closing spider (finished)

Come puoi vedere nell'output, per ogni URL c'è una riga di log che (referer: Nessuno) afferma che gli URL sono URL iniziali e non hanno referrer. Successivamente, dovresti vedere due nuovi file denominati Books.html e Resources.html creati nella tua directory first_scrapy .

Descrizione

Per estrarre i dati dalle pagine web, Scrapy utilizza una tecnica chiamata selettori basata su espressioni XPath e CSS . Di seguito sono riportati alcuni esempi di espressioni XPath:

• /html/head/title - Questo selezionerà l'elemento <title>, all'interno dell'elemento <head> di un documento HTML.

• /html/head/title/text() - Questo selezionerà il testo all'interno dello stesso elemento <title>.

• //td - Questo selezionerà tutti gli elementi da <td>.

• //div[@class = "slice"]- Questo selezionerà tutti gli elementi da div che contengono un attributo class = "slice"

I selettori hanno quattro metodi di base come mostrato nella tabella seguente:

Utilizzo dei selettori nella shell

Per dimostrare i selettori con la shell Scrapy incorporata, è necessario che IPython sia installato nel sistema. La cosa importante qui è che gli URL dovrebbero essere inclusi tra virgolette durante l'esecuzione di Scrapy; altrimenti gli URL con i caratteri "&" non funzioneranno. È possibile avviare una shell utilizzando il seguente comando nella directory di livello superiore del progetto:

scrapy shell "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/"

Una shell sarà simile alla seguente:

[ ... Scrapy log here ... ]

2014-01-23 17:11:42-0400 [scrapy] DEBUG: Crawled (200) 
<GET http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>(referer: None)
[s] Available Scrapy objects:
[s]   crawler    <scrapy.crawler.Crawler object at 0x3636b50>
[s]   item       {}
[s]   request    <GET http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>
[s]   response   <200 http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>
[s]   settings   <scrapy.settings.Settings object at 0x3fadc50>
[s]   spider     <Spider 'default' at 0x3cebf50>
[s] Useful shortcuts:
[s]   shelp()           Shell help (print this help)
[s]   fetch(req_or_url) Fetch request (or URL) and update local objects
[s]   view(response)    View response in a browser

In [1]:

Quando la shell viene caricata, è possibile accedere al corpo o all'intestazione utilizzando rispettivamente response.body e response.header . Allo stesso modo, è possibile eseguire query sulla risposta utilizzando response.selector.xpath () o response.selector.css () .

Ad esempio:

In [1]: response.xpath('//title')
Out[1]: [<Selector xpath = '//title' data = u'<title>My Book - Scrapy'>]

In [2]: response.xpath('//title').extract()
Out[2]: [u'<title>My Book - Scrapy: Index: Chapters</title>']

In [3]: response.xpath('//title/text()')
Out[3]: [<Selector xpath = '//title/text()' data = u'My Book - Scrapy: Index:'>]

In [4]: response.xpath('//title/text()').extract()
Out[4]: [u'My Book - Scrapy: Index: Chapters']

In [5]: response.xpath('//title/text()').re('(\w+):')
Out[5]: [u'Scrapy', u'Index', u'Chapters']

Estrazione dei dati

Per estrarre i dati da un normale sito HTML, dobbiamo ispezionare il codice sorgente del sito per ottenere XPath. Dopo l'ispezione, puoi vedere che i dati saranno nel fileuletichetta. Seleziona gli elementi all'internoli etichetta.

Le seguenti righe di codice mostrano l'estrazione di diversi tipi di dati:

Per selezionare i dati all'interno del tag li -

response.xpath('//ul/li')

Per selezionare le descrizioni -

response.xpath('//ul/li/text()').extract()

Per selezionare i titoli del sito -

response.xpath('//ul/li/a/text()').extract()

Per selezionare i collegamenti al sito -

response.xpath('//ul/li/a/@href').extract()

Il codice seguente dimostra l'uso degli estrattori di cui sopra:

import scrapy

class MyprojectSpider(scrapy.Spider):
   name = "project"
   allowed_domains = ["dmoz.org"]
   
   start_urls = [
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/",
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/"
   ]
   def parse(self, response):
      for sel in response.xpath('//ul/li'):
         title = sel.xpath('a/text()').extract()
         link = sel.xpath('a/@href').extract()
         desc = sel.xpath('text()').extract()
         print title, link, desc

Descrizione

Itemgli oggetti sono i normali dettami di Python. Possiamo usare la seguente sintassi per accedere agli attributi della classe:

>>> item = DmozItem()
>>> item['title'] = 'sample title'
>>> item['title']
'sample title'

Aggiungi il codice sopra al seguente esempio:

import scrapy

from tutorial.items import DmozItem

class MyprojectSpider(scrapy.Spider):
   name = "project"
   allowed_domains = ["dmoz.org"]
   
   start_urls = [
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/",
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/"
   ]
   def parse(self, response):
      for sel in response.xpath('//ul/li'):
         item = DmozItem()
         item['title'] = sel.xpath('a/text()').extract()
         item['link'] = sel.xpath('a/@href').extract()
         item['desc'] = sel.xpath('text()').extract()
         yield item

L'output del ragno sopra sarà:

[scrapy] DEBUG: Scraped from <200 
http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>
   {'desc': [u' - By David Mertz; Addison Wesley. Book in progress, full text, 
      ASCII format. Asks for feedback. [author website, Gnosis Software, Inc.\n],
   'link': [u'http://gnosis.cx/TPiP/'],
   'title': [u'Text Processing in Python']}
[scrapy] DEBUG: Scraped from <200 
http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>
   {'desc': [u' - By Sean McGrath; Prentice Hall PTR, 2000, ISBN 0130211192, 
      has CD-ROM. Methods to build XML applications fast, Python tutorial, DOM and 
      SAX, new Pyxie open source XML processing library. [Prentice Hall PTR]\n'],
   'link': [u'http://www.informit.com/store/product.aspx?isbn=0130211192'],
   'title': [u'XML Processing with Python']}

Descrizione

In questo capitolo studieremo come estrarre i link delle pagine di nostro interesse, seguirli ed estrarre dati da quella pagina. Per questo, dobbiamo apportare le seguenti modifiche nel nostro codice precedente mostrato come segue:

import scrapy
from tutorial.items import DmozItem

class MyprojectSpider(scrapy.Spider):
   name = "project"
   allowed_domains = ["dmoz.org"]
   
   start_urls = [
      "http://www.dmoz.org/Computers/Programming/Languages/Python/",
   ]
   def parse(self, response):
      for href in response.css("ul.directory.dir-col > li > a::attr('href')"):
         url = response.urljoin(href.extract())
            yield scrapy.Request(url, callback = self.parse_dir_contents)

   def parse_dir_contents(self, response):
      for sel in response.xpath('//ul/li'):
         item = DmozItem()
         item['title'] = sel.xpath('a/text()').extract()
         item['link'] = sel.xpath('a/@href').extract()
         item['desc'] = sel.xpath('text()').extract()
         yield item

Il codice sopra contiene i seguenti metodi:

• parse() - Estrarrà i link di nostro interesse.

• response.urljoin - Il metodo parse () utilizzerà questo metodo per creare un nuovo URL e fornire una nuova richiesta, che verrà inviata successivamente al callback.

• parse_dir_contents() - Questa è una richiamata che effettivamente rascherà i dati di interesse.

Qui, Scrapy utilizza un meccanismo di callback per seguire i collegamenti. Utilizzando questo meccanismo, il crawler più grande può essere progettato e può seguire i collegamenti di interesse per estrarre i dati desiderati da pagine diverse. Il metodo normale sarà il metodo di richiamata, che estrarrà gli elementi, cercherà i collegamenti per seguire la pagina successiva e quindi fornirà una richiesta per la stessa richiamata.

L'esempio seguente produce un ciclo, che seguirà i collegamenti alla pagina successiva.

def parse_articles_follow_next_page(self, response):
   for article in response.xpath("//article"):
      item = ArticleItem()
    
      ... extract article data here

      yield item

   next_page = response.css("ul.navigation > li.next-page > a::attr('href')")
   if next_page:
      url = response.urljoin(next_page[0].extract())
      yield scrapy.Request(url, self.parse_articles_follow_next_page)

Descrizione

Il modo migliore per archiviare i dati di scraping è utilizzare le esportazioni di feed, che garantisce che i dati vengano archiviati correttamente utilizzando più formati di serializzazione. JSON, linee JSON, CSV, XML sono i formati supportati prontamente nei formati di serializzazione. I dati possono essere memorizzati con il seguente comando:

scrapy crawl dmoz -o data.json

Questo comando creerà un file data.jsonfile contenente dati raschiati in JSON. Questa tecnica è valida per piccole quantità di dati. Se è necessario gestire una grande quantità di dati, è possibile utilizzare Item Pipeline. Proprio come il file data.json, un file riservato viene impostato quando il progetto viene creato intutorial/pipelines.py.

Descrizione

Loggingsignifica traccia degli eventi, che utilizza il sistema di registrazione integrato e definisce funzioni e classi per implementare applicazioni e librerie. La registrazione è un materiale pronto per l'uso, che può funzionare con le impostazioni di Scrapy elencate in Impostazioni di registrazione.

Scrapy imposterà alcune impostazioni predefinite e gestirà queste impostazioni con l'aiuto di scrapy.utils.log.configure_logging () durante l'esecuzione dei comandi.

Livelli di registro

In Python, ci sono cinque diversi livelli di gravità in un messaggio di log. Il seguente elenco mostra i messaggi di registro standard in ordine crescente:

• logging.DEBUG - per il debug dei messaggi (gravità minima)

• logging.INFO - per messaggi informativi

• logging.WARNING - per i messaggi di avviso

• logging.ERROR - per errori regolari

• logging.CRITICAL - per errori critici (massima gravità)

Come registrare i messaggi

Il codice seguente mostra la registrazione di un messaggio utilizzando logging.info livello.

import logging 
logging.info("This is an information")

Il messaggio di registrazione sopra può essere passato come argomento usando logging.log mostrato come segue -

import logging 
logging.log(logging.INFO, "This is an information")

Ora puoi anche usare i logger per racchiudere il messaggio usando gli helper di logging logging per ottenere il messaggio di logging chiaramente mostrato come segue:

import logging
logger = logging.getLogger()
logger.info("This is an information")

Possono esserci più logger ed è possibile accedervi ottenendo i loro nomi con l'uso di logging.getLogger funzione mostrata come segue.

import logging
logger = logging.getLogger('mycustomlogger')
logger.info("This is an information")

Un logger personalizzato può essere utilizzato per qualsiasi modulo utilizzando la variabile __name__ che contiene il percorso del modulo mostrato come segue -

import logging
logger = logging.getLogger(__name__)
logger.info("This is an information")

Registrazione da Spider

Ogni istanza di spider ha un file logger al suo interno e può essere utilizzato come segue:

import scrapy 

class LogSpider(scrapy.Spider):  
   name = 'logspider' 
   start_urls = ['http://dmoz.com']  
   def parse(self, response): 
      self.logger.info('Parse function called on %s', response.url)

Nel codice sopra, il logger viene creato usando il nome del ragno, ma puoi usare qualsiasi logger personalizzato fornito da Python come mostrato nel codice seguente:

import logging
import scrapy

logger = logging.getLogger('customizedlogger')
class LogSpider(scrapy.Spider):
   name = 'logspider'
   start_urls = ['http://dmoz.com']

   def parse(self, response):
      logger.info('Parse function called on %s', response.url)

Configurazione registrazione

I logger non sono in grado di visualizzare i messaggi inviati da loro da soli. Quindi richiedono "gestori" per visualizzare quei messaggi e i gestori reindirizzeranno questi messaggi alle rispettive destinazioni come file, email e output standard.

A seconda delle seguenti impostazioni, Scrapy configurerà il gestore per il logger.

Impostazioni di registrazione

Le seguenti impostazioni vengono utilizzate per configurare la registrazione:

• Il LOG_FILE e LOG_ENABLED decidere la destinazione per i messaggi di registro.

• Quando imposti il ​​file LOG_ENCODING a false, non visualizzerà i messaggi di output del registro.

• Il LOG_LEVELdeterminerà l'ordine di gravità del messaggio; quei messaggi con minore gravità verranno filtrati.

• Il LOG_FORMAT e LOG_DATEFORMAT vengono utilizzati per specificare i layout di tutti i messaggi.

• Quando imposti il ​​file LOG_STDOUT a true, tutti gli output standard e i messaggi di errore del processo verranno reindirizzati al registro.

Opzioni della riga di comando

Le impostazioni di Scrapy possono essere sovrascritte passando gli argomenti della riga di comando come mostrato nella tabella seguente:

modulo scrapy.utils.log

Questa funzione può essere utilizzata per inizializzare i valori predefiniti di registrazione per Scrapy.

scrapy.utils.log.configure_logging(settings = None, install_root_handler = True)

La funzione di cui sopra -

• Instrada gli avvisi e le registrazioni distorte tramite la registrazione standard di Python.
• Assegna DEBUG a Scrapy e il livello ERROR ai logger Twisted.
• Instrada lo stdout al log, se l'impostazione LOG_STDOUT è vera.

Le opzioni predefinite possono essere sovrascritte utilizzando il settingsdiscussione. Quando le impostazioni non sono specificate, vengono utilizzati i valori predefiniti. Il gestore può essere creato per il logger di root, quando install_root_handler è impostato su true. Se è impostato su false, non sarà impostato alcun output di log. Quando si utilizzano i comandi Scrapy, il configure_logging verrà chiamato automaticamente e può essere eseguito in modo esplicito, durante l'esecuzione degli script personalizzati.

Per configurare manualmente l'output della registrazione, è possibile utilizzare logging.basicConfig() mostrato come segue -

import logging 
from scrapy.utils.log import configure_logging  

configure_logging(install_root_handler = False) 
logging.basicConfig ( 
   filename = 'logging.txt', 
   format = '%(levelname)s: %(your_message)s', 
   level = logging.INFO 
)

Descrizione

Stats Collector è una funzione fornita da Scrapy per raccogliere le statistiche sotto forma di chiave / valori e vi si accede utilizzando l'API Crawler (Crawler fornisce l'accesso a tutti i componenti principali di Scrapy). Il raccoglitore delle statistiche fornisce una tabella delle statistiche per spider in cui il raccoglitore delle statistiche si apre automaticamente quando il ragno si apre e chiude il raccoglitore delle statistiche quando il ragno è chiuso.

Usi comuni del collezionista di statistiche

Il codice seguente accede al raccoglitore di statistiche utilizzando stats attributo.

class ExtensionThatAccessStats(object): 
   def __init__(self, stats): 
      self.stats = stats  
   
   @classmethod 
   def from_crawler(cls, crawler): 
      return cls(crawler.stats)

La tabella seguente mostra varie opzioni che possono essere utilizzate con il raccoglitore di statistiche:

stats.set_value('hostname', socket.gethostname())

stats.inc_value('customized_count')

stats.max_value('max_items_scraped', value)

stats.min_value('min_free_memory_percent', value)

stats.get_value('customized_count')

stats.get_stats() {'custom_count': 1, 'start_time': 
datetime.datetime(2009, 7, 14, 21, 47, 28, 977139)}

Collezionisti di statistiche disponibili

Scrapy fornisce diversi tipi di raccoglitore di statistiche a cui è possibile accedere utilizzando il STATS_CLASS ambientazione.

MemoryStatsCollector

È il raccoglitore di statistiche predefinito che mantiene le statistiche di ogni spider che è stato utilizzato per lo scraping ei dati verranno archiviati nella memoria.

class scrapy.statscollectors.MemoryStatsCollector

DummyStatsCollector

Questo raccoglitore di statistiche è molto efficiente e non fa nulla. Questo può essere impostato utilizzando l' impostazione STATS_CLASS e può essere utilizzato per disabilitare la raccolta di statistiche al fine di migliorare le prestazioni.

class scrapy.statscollectors.DummyStatsCollector

Descrizione

Scrapy può inviare e-mail utilizzando la propria funzione chiamata Twisted non-blocking IO che tiene lontano dall'IO non bloccante del crawler. È possibile configurare le poche impostazioni di invio di e-mail e fornire una semplice API per l'invio di allegati.

Esistono due modi per creare un'istanza di MailSender come mostrato nella tabella seguente:

La riga seguente invia un'e-mail senza allegati -

mailer.send(to = ["[email protected]"], subject = "subject data", body = "body data", 
   cc = ["[email protected]"])

Riferimento alla classe MailSender

La classe MailSender utilizza IO non bloccante Twisted per l'invio di e-mail da Scrapy.

class scrapy.mail.MailSender(smtphost = None, mailfrom = None, smtpuser = None, 
   smtppass = None, smtpport = None)

La tabella seguente mostra i parametri utilizzati nella classe MailSender -

I seguenti due metodi sono presenti nel riferimento alla classe MailSender come specificato. Primo metodo,

classmethod from_settings(settings)

Incorpora utilizzando l'oggetto Impostazioni Scrapy. Contiene il seguente parametro:

settings (scrapy.settings.Settings object) - Viene considerato come destinatario di posta elettronica.

Un altro metodo,

send(to, subject, body, cc = None, attachs = (), mimetype = 'text/plain', charset = None)

La tabella seguente contiene i parametri del metodo precedente:

Impostazioni della posta

Le seguenti impostazioni assicurano che senza scrivere alcun codice, possiamo configurare un'e-mail utilizzando la classe MailSender nel progetto.

Descrizione

La console Telnet è una shell Python che viene eseguita all'interno del processo Scrapy e viene utilizzata per l'ispezione e il controllo di un processo in esecuzione di Scrapy.

Accedi a Telnet Console

È possibile accedere alla console telnet utilizzando il seguente comando:

telnet localhost 6023

Fondamentalmente, la console telnet è elencata nella porta TCP, che è descritta in TELNETCONSOLE_PORT impostazioni.

Variabili

Alcune delle variabili predefinite fornite nella tabella seguente vengono utilizzate come scorciatoie:

Esempi

Di seguito sono riportati alcuni esempi illustrati utilizzando Telnet Console.

Metti in pausa, riprendi e spegni il motore Scrapy

Per mettere in pausa il motore Scrapy, utilizzare il seguente comando:

telnet localhost 6023
>>> engine.pause()
>>>

Per riprendere il motore Scrapy, utilizzare il seguente comando:

telnet localhost 6023
>>> engine.unpause()
>>>

Per arrestare il motore Scrapy, utilizzare il seguente comando:

telnet localhost 6023
>>> engine.stop()
Connection closed by foreign host.

Visualizza lo stato del motore

Usi della console Telnet est() metodo per verificare lo stato del motore Scrapy come mostrato nel codice seguente -

telnet localhost 6023
>>> est()
Execution engine status

time()-engine.start_time                        : 8.62972998619
engine.has_capacity()                           : False
len(engine.downloader.active)                   : 16
engine.scraper.is_idle()                        : False
engine.spider.name                              : followall
engine.spider_is_idle(engine.spider)            : False
engine.slot.closing                             : False
len(engine.slot.inprogress)                     : 16
len(engine.slot.scheduler.dqs or [])            : 0
len(engine.slot.scheduler.mqs)                  : 92
len(engine.scraper.slot.queue)                  : 0
len(engine.scraper.slot.active)                 : 0
engine.scraper.slot.active_size                 : 0
engine.scraper.slot.itemproc_size               : 0
engine.scraper.slot.needs_backout()             : False

Segnali della console Telnet

È possibile utilizzare i segnali della console telnet per aggiungere, aggiornare o eliminare le variabili nello spazio dei nomi locale telnet. Per eseguire questa azione, devi aggiungere il dict telnet_vars nel tuo gestore.

scrapy.extensions.telnet.update_telnet_vars(telnet_vars)

Parametri -

telnet_vars (dict)

Dove, dict è un dizionario contenente variabili telnet.

Impostazioni Telnet

La tabella seguente mostra le impostazioni che controllano il comportamento di Telnet Console:

Descrizione

Un web crawler Scrapy in esecuzione può essere controllato tramite JSON-RPC. È abilitato dall'impostazione JSONRPC_ENABLED. Questo servizio fornisce l'accesso all'oggetto crawler principale tramite il protocollo JSON-RPC 2.0 . L'endpoint per l'accesso all'oggetto crawler è:

http://localhost:6080/crawler

La tabella seguente contiene alcune delle impostazioni che mostrano il comportamento del servizio web: