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 -

Suor n Campo e descrizione
1

name

È il nome del tuo ragno.

2

allowed_domains

È un elenco di domini su cui lo spider esegue la scansione.

3

start_urls

È un elenco di URL, che saranno le radici per le successive scansioni, da cui inizierà la scansione dello spider.

4

custom_settings

Queste sono le impostazioni, quando si esegue lo spider, verranno sovrascritte dalla configurazione a livello di progetto.

5

crawler

È un attributo che si collega all'oggetto Crawler a cui è associata l'istanza spider.

6

settings

Queste sono le impostazioni per eseguire uno spider.

7

logger

È un logger Python utilizzato per inviare messaggi di log.

8

from_crawler(crawler,*args,**kwargs)

È un metodo di classe, che crea il tuo ragno. I parametri sono:

  • crawler - Un crawler a cui verrà associata l'istanza dello spider.

  • args(list)- Questi argomenti vengono passati al metodo _init_ () .

  • kwargs(dict)- Questi argomenti di parole chiave vengono passati al metodo _init_ () .

9

start_requests()

Quando non sono specificati URL particolari e lo spider è aperto per lo scrapping, Scrapy chiama il metodo start_requests () .

10

make_requests_from_url(url)

È un metodo utilizzato per convertire gli URL in richieste.

11

parse(response)

Questo metodo elabora la risposta e restituisce i dati scartati seguendo più URL.

12

log(message[,level,component])

È un metodo che invia un messaggio di registro tramite lo spider logger.

13

closed(reason)

Questo metodo viene chiamato quando il ragno si chiude.

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 -

Suor n Regola e descrizione
1

LinkExtractor

Specifica come lo spider segue i collegamenti ed estrae i dati.

2

callback

Deve essere chiamato dopo che ogni pagina è stata raschiata.

3

follow

Specifica se continuare o meno a seguire i collegamenti.

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 -

Suor n Attributo e descrizione
1

iterator

Definisce l'iteratore da utilizzare. Può essere iternodes, html o xml . L'impostazione predefinita è iternodes .

2

itertag

È una stringa con il nome del nodo da iterare.

3

namespaces

È definito da un elenco di tuple (prefisso, uri) che registra automaticamente gli spazi dei nomi utilizzando il metodo register_namespace () .

4

adapt_response(response)

Riceve la risposta e modifica il corpo della risposta non appena arriva dal middleware spider, prima che lo spider inizi ad analizzarlo.

5

parse_node(response,selector)

Riceve la risposta e un selettore quando viene chiamato per ogni nodo corrispondente al nome del tag fornito.

Note - Il tuo ragno non funzionerà se non ignori questo metodo.

6

process_results(response,results)

Restituisce un elenco di risultati e risposte restituiti dallo spider.

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 -

Suor n Opzione e descrizione
1

delimiter

È una stringa contenente un separatore virgola (",") per ogni campo.

2

quotechar

È una stringa contenente virgolette ('"') per ogni campo.

3

headers

È un elenco di istruzioni da cui è possibile estrarre i campi.

4

parse_row(response,row)

Riceve una risposta e ogni riga insieme a una chiave per l'intestazione.

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 -

Suor n Campo e descrizione
1

sitemap_urls

Un elenco di URL di cui desideri eseguire la scansione che punta alle Sitemap.

2

sitemap_rules

È un elenco di tuple (regex, callback), dove regex è un'espressione regolare e callback viene utilizzato per elaborare gli URL che corrispondono a un'espressione regolare.

3

sitemap_follow

È un elenco di espressioni regolari della mappa del sito da seguire.

4

sitemap_alternate_links

Specifica i collegamenti alternativi da seguire per un singolo URL.

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:

Suor n Prefisso e utilizzo Spazio dei nomi
1

re

espressioni regolari

http://exslt.org/regexp/index.html

2

set

impostare la manipolazione

http://exslt.org/set/index.html

È 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:

Suor n Parametro e descrizione
1

item

È l'elemento da popolare chiamando add_xpath (), add_css () o add_value ().

2

selector

Viene utilizzato per estrarre dati dai siti Web.

3

response

Viene utilizzato per costruire selector utilizzando default_selector_class.

La tabella seguente mostra i metodi degli oggetti ItemLoader:

Suor n Metodo e descrizione Esempio
1

get_value(value, *processors, **kwargs)

Da un determinato processore e argomenti di parole chiave, il valore viene elaborato dal metodo get_value ().

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

add_value(field_name, value, *processors, **kwargs)

Elabora il valore e aggiunge al campo in cui viene passato per la prima volta attraverso get_value fornendo processori e argomenti di parole chiave prima di passare attraverso il processore di input del campo.

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')
3

replace_value(field_name, value, *processors, **kwargs)

Sostituisce i dati raccolti con un nuovo valore.

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')
4

get_xpath(xpath, *processors, **kwargs)

Viene utilizzato per estrarre stringhe Unicode fornendo processori e argomenti di parole chiave ricevendo XPath .

# 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 (.*)")
5

add_xpath(field_name, xpath, *processors, **kwargs)

Riceve XPath nel campo che estrae le stringhe Unicode.

# 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 (.*)')
6

replace_xpath(field_name, xpath, *processors, **kwargs)

Sostituisce i dati raccolti utilizzando XPath dai siti.

# 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 (.*)')
7

get_css(css, *processors, **kwargs)

Riceve il selettore CSS utilizzato per estrarre le stringhe Unicode.

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

add_css(field_name, css, *processors, **kwargs)

È simile al metodo add_value () con una differenza che aggiunge il selettore CSS al campo.

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

replace_css(field_name, css, *processors, **kwargs)

Sostituisce i dati estratti utilizzando il selettore CSS.

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

load_item()

Quando i dati vengono raccolti, questo metodo riempie l'articolo con i dati raccolti e lo restituisce.

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

nested_xpath(xpath)

Viene utilizzato per creare caricatori nidificati con un selettore XPath.

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

nested_css(css)

Viene utilizzato per creare caricatori nidificati con un selettore CSS.

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:

Suor n Attributo e descrizione
1

item

È un oggetto su cui Item Loader esegue l'analisi.

2

context

È il contesto corrente di Item Loader che è attivo.

3

default_item_class

Viene utilizzato per rappresentare gli elementi, se non fornito nel costruttore.

4

default_input_processor

I campi che non specificano il processore di input sono gli unici per i quali vengono utilizzati default_input_processors.

5

default_output_processor

I campi che non specificano il processore di output sono gli unici per i quali vengono utilizzati default_output_processors.

6

default_selector_class

È una classe usata per costruire il selettore, se non è data nel costruttore.

7

selector

È un oggetto che può essere utilizzato per estrarre i dati dai siti.

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:

Suor n Collegamento e descrizione
1

shelp()

Fornisce gli oggetti e le scorciatoie disponibili con l'opzione di aiuto.

2

fetch(request_or_url)

Raccoglie la risposta dalla richiesta o dall'URL e gli oggetti associati verranno aggiornati correttamente.

3

view(response)

È possibile visualizzare la risposta per la richiesta data nel browser locale per l'osservazione e per visualizzare correttamente il collegamento esterno, si aggiunge un tag di base al corpo della risposta.

Oggetti Scrapy disponibili

Shell fornisce i seguenti oggetti Scrapy disponibili nel progetto:

Suor n Oggetto e descrizione
1

crawler

Specifica l'oggetto crawler corrente.

2

spider

Se non è presente uno spider per l'URL attuale, gestirà l'URL o l'oggetto spider definendo il nuovo spider.

3

request

Specifica l'oggetto richiesta per l'ultima pagina raccolta.

4

response

Specifica l'oggetto risposta per l'ultima pagina raccolta.

5

settings

Fornisce le impostazioni Scrapy correnti.

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:

Suor n Metodo e descrizione Parametri
1

open_spider(self, spider)

Viene selezionato all'apertura del ragno.

ragno (oggetto ragno) - Si riferisce al ragno che è stato aperto.

2

close_spider(self, spider)

Viene selezionato quando il ragno è chiuso.

ragno (oggetto ragno) - Si riferisce al ragno che era chiuso.

3

from_crawler(cls, crawler)

Con l'aiuto del crawler, la pipeline può accedere ai componenti principali come i segnali e le impostazioni di Scrapy.

crawler (oggetto Crawler) - Si riferisce al crawler che utilizza questa pipeline.

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 -

Suor n Formato e descrizione
1

JSON

FEED_FORMAT è json

L' utilità di esportazione utilizzata è la classe scrapy.exporters.JsonItemExporter

2

JSON lines

FEED_FROMAT è jsonlines

L' utilità di esportazione utilizzata è la classe scrapy.exporters.JsonLinesItemExporter

3

CSV

FEED_FORMAT è CSV

L' utilità di esportazione utilizzata è la classe scrapy.exporters.CsvItemExporter

4

XML

FEED_FORMAT è xml

L' utilità di esportazione utilizzata è la classe scrapy.exporters.XmlItemExporter

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

Suor n Formato e descrizione
1

Pickle

FEED_FORMAT è pickel

L'esportatore utilizzato è la classe scrapy.exporters.PickleItemExporter

2

Marshal

FEED_FORMAT è il marshal

L'esportatore utilizzato è la classe scrapy.exporters.MarshalItemExporter

Backend di archiviazione

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

La tabella seguente mostra i backend di archiviazione supportati:

Suor n Backend di archiviazione e descrizione
1

Local filesystem

Lo schema URI è un file e viene utilizzato per memorizzare i feed.

2

FTP

Lo schema URI è ftp e viene utilizzato per memorizzare i feed.

3

S3

Lo schema URI è S3 e i feed sono archiviati su Amazon S3. Sono richieste librerie esterne botocore o boto .

4

Standard output

Lo schema URI è stdout e i feed vengono memorizzati nell'output standard.

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:

Suor n Impostazione e descrizione
1

FEED_URI

È l'URI del feed di esportazione utilizzato per abilitare le esportazioni di feed.

2

FEED_FORMAT

È un formato di serializzazione utilizzato per il feed.

3

FEED_EXPORT_FIELDS

Viene utilizzato per definire i campi che devono essere esportati.

4

FEED_STORE_EMPTY

Definisce se esportare feed senza elementi.

5

FEED_STORAGES

È un dizionario con backend per l'archiviazione dei feed aggiuntivi.

6

FEED_STORAGES_BASE

È un dizionario con backend per l'archiviazione dei feed incorporati.

7

FEED_EXPORTERS

È un dizionario con ulteriori esportatori di mangimi.

8

FEED_EXPORTERS_BASE

È un dizionario con esportatori di mangimi incorporati.

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 -

Suor n Parametro e descrizione
1

url

È una stringa che specifica la richiesta dell'URL.

2

callback

È una funzione richiamabile che utilizza la risposta della richiesta come primo parametro.

3

method

È una stringa che specifica la richiesta del metodo HTTP.

4

headers

È un dizionario con intestazioni di richiesta.

5

body

È una stringa o un unicode che ha un corpo della richiesta.

6

cookies

È un elenco contenente i cookie di richiesta.

7

meta

È un dizionario che contiene i valori per i metadati della richiesta.

8

encoding

È una stringa contenente la codifica utf-8 utilizzata per codificare l'URL.

9

priority

È un numero intero in cui lo scheduler utilizza la priorità per definire l'ordine di elaborazione delle richieste.

10

dont_filter

È un valore booleano che specifica che lo scheduler non deve filtrare la richiesta.

11

errback

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

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 -

Suor n Chiave e descrizione
1

dont_redirect

È una chiave quando impostata su true, non reindirizza la richiesta in base allo stato della risposta.

2

dont_retry

È una chiave quando impostata su true, non ritenta le richieste non riuscite e verrà ignorata dal middleware.

3

handle_httpstatus_list

È una chiave che definisce quali codici di risposta per richiesta possono essere consentiti.

4

handle_httpstatus_all

È una chiave utilizzata per consentire qualsiasi codice di risposta a una richiesta impostandolo su true .

5

dont_merge_cookies

È una chiave utilizzata per evitare la fusione con i cookie esistenti impostandola su true .

6

cookiejar

È una chiave utilizzata per mantenere più sessioni di cookie per spider.

7

dont_cache

È una chiave utilizzata per evitare di memorizzare nella cache richieste e risposte HTTP su ogni criterio.

8

redirect_urls

È una chiave che contiene gli URL attraverso i quali passano le richieste.

9

bindaddress

È l'IP dell'indirizzo IP in uscita che può essere utilizzato per eseguire la richiesta.

10

dont_obey_robotstxt

È una chiave quando impostata su true, non filtra le richieste vietate dallo standard di esclusione robots.txt, anche se ROBOTSTXT_OBEY è abilitato.

11

download_timeout

Viene utilizzato per impostare il timeout (in secondi) per spider per il quale il downloader attenderà prima che scada.

12

download_maxsize

Viene utilizzato per impostare la dimensione massima (in byte) per spider, che il downloader scaricherà.

13

proxy

È possibile impostare il proxy per gli oggetti Request per impostare il proxy HTTP per l'utilizzo delle richieste.

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 -

Suor n Parametro e descrizione
1

response

È un oggetto utilizzato per precompilare i campi del modulo utilizzando il modulo di risposta HTML.

2

formname

È una stringa in cui verrà utilizzato il modulo avente l'attributo name, se specificato.

3

formnumber

È un numero intero di moduli da utilizzare quando sono presenti più moduli nella risposta.

4

formdata

È un dizionario di campi nei dati del modulo utilizzati per sovrascrivere.

5

formxpath

È una stringa quando specificato, viene utilizzata la forma che corrisponde a xpath.

6

formcss

È una stringa quando specificata, viene utilizzata la forma che corrisponde al selettore css.

7

clickdata

È un dizionario di attributi utilizzato per osservare il controllo cliccato.

8

dont_click

I dati del modulo verranno inviati senza fare clic su alcun elemento, se impostato su true.

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:

Suor n Parametro e descrizione
1

url

È una stringa che specifica la risposta dell'URL.

2

status

È un numero intero che contiene la risposta di stato HTTP.

3

headers

È un dizionario contenente le intestazioni delle risposte.

4

body

È una stringa con il corpo della risposta.

5

flags

È un elenco contenente flag di risposta.

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:

Suor n Attributo e descrizione
1

text

È un corpo di risposta, in cui è possibile accedere più volte a response.text.

2

encoding

È una stringa contenente la codifica per la risposta.

3

selector

È un attributo istanziato al primo accesso e utilizza la risposta come destinazione.

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

Suor n Metodo e descrizione
1

xpath (query)

È un collegamento a TextResponse.selector.xpath (query).

2

css (query)

È un collegamento a TextResponse.selector.css (query).

3

body_as_unicode()

È un corpo di risposta disponibile come metodo, in cui è possibile accedere più volte a response.text.

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.

Suor n Parametro e descrizione
1

allow (un'espressione regolare (o un elenco di))

Consente una singola espressione o un gruppo di espressioni che devono corrispondere all'URL che deve essere estratto. Se non viene menzionato, corrisponderà a tutti i collegamenti.

2

deny (un'espressione regolare (o un elenco di))

Blocca o esclude una singola espressione o gruppo di espressioni che dovrebbero corrispondere all'URL che non deve essere estratto. Se non viene menzionato o lasciato vuoto, non eliminerà i collegamenti indesiderati.

3

allow_domains (str o elenco)

Consente una singola stringa o un elenco di stringhe che devono corrispondere ai domini da cui devono essere estratti i collegamenti.

4

deny_domains (str o elenco)

Blocca o esclude una singola stringa o un elenco di stringhe che devono corrispondere ai domini da cui non devono essere estratti i collegamenti.

5

deny_extensions (elenco)

Blocca l'elenco delle stringhe con le estensioni durante l'estrazione dei collegamenti. Se non è impostato, per impostazione predefinita verrà impostato su IGNORED_EXTENSIONS che contiene l'elenco predefinito nel pacchetto scrapy.linkextractors .

6

restrict_xpaths (str o elenco)

È una regione dell'elenco XPath da cui devono essere estratti i collegamenti dalla risposta. Se forniti, i collegamenti verranno estratti solo dal testo, che viene selezionato da XPath.

7

restrict_css (str o elenco)

Si comporta in modo simile al parametro limits_xpaths che estrarrà i collegamenti dalle regioni selezionate CSS all'interno della risposta.

8

tags (str o elenco)

Un singolo tag o un elenco di tag da considerare durante l'estrazione dei collegamenti. Per impostazione predefinita, sarà ('a', 'area').

9

attrs (elenco)

Un singolo attributo o elenco di attributi dovrebbe essere considerato durante l'estrazione dei collegamenti. Per impostazione predefinita, sarà ('href',).

10

canonicalize (booleano)

L'URL estratto viene riportato al formato standard utilizzando scrapy.utils.url.canonicalize_url . Per impostazione predefinita, sarà True.

11

unique (booleano)

Verrà utilizzato se i collegamenti estratti vengono ripetuti.

12

process_value (richiamabile)

È una funzione che riceve un valore dai tag e dagli attributi scansionati. Il valore ricevuto può essere modificato e restituito oppure non verrà restituito nulla per rifiutare il collegamento. Se non utilizzato, per impostazione predefinita sarà lambda x: x.

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:

Suor n Meccanismo e descrizione
1

Command line options

Qui, gli argomenti passati hanno la massima precedenza sovrascrivendo altre opzioni. -S viene utilizzato per sovrascrivere una o più impostazioni.

scrapy crawl myspider -s LOG_FILE = scrapy.log
2

Settings per-spider

Gli spider possono avere le proprie impostazioni che sovrascrivono quelle del progetto utilizzando l'attributo custom_settings.

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

Project settings module

Qui puoi popolare le tue impostazioni personalizzate come l'aggiunta o la modifica delle impostazioni nel file settings.py.

4

Default settings per-command

Ogni comando dello strumento Scrapy definisce le proprie impostazioni nell'attributo default_settings, per sovrascrivere le impostazioni predefinite globali.

5

Default global settings

Queste impostazioni si trovano nel modulo scrapy.settings.default_settings.

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:

Suor n Impostazione e descrizione
1

AWS_ACCESS_KEY_ID

Viene utilizzato per accedere a Amazon Web Services.

Valore predefinito: Nessuno

2

AWS_SECRET_ACCESS_KEY

Viene utilizzato per accedere a Amazon Web Services.

Valore predefinito: Nessuno

3

BOT_NAME

È il nome del bot che può essere utilizzato per costruire User-Agent.

Valore predefinito: "scrapybot"

4

CONCURRENT_ITEMS

Numero massimo di articoli esistenti nell'elaboratore articoli utilizzati per l'elaborazione parallela.

Valore predefinito: 100

5

CONCURRENT_REQUESTS

Numero massimo di richieste esistenti eseguite da Scrapy downloader.

Valore predefinito: 16

6

CONCURRENT_REQUESTS_PER_DOMAIN

Numero massimo di richieste esistenti che vengono eseguite simultaneamente per ogni singolo dominio.

Valore predefinito: 8

7

CONCURRENT_REQUESTS_PER_IP

Numero massimo di richieste esistenti che vengono eseguite simultaneamente su un singolo IP.

Valore predefinito: 0

8

DEFAULT_ITEM_CLASS

È una classe usata per rappresentare gli oggetti.

Valore predefinito: "scrapy.item.Item"

9

DEFAULT_REQUEST_HEADERS

È un'intestazione predefinita utilizzata per le richieste HTTP di Scrapy.

Valore predefinito -

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

DEPTH_LIMIT

La profondità massima consentita da un ragno per eseguire la scansione di qualsiasi sito.

Valore predefinito: 0

11

DEPTH_PRIORITY

È un numero intero utilizzato per modificare la priorità della richiesta in base alla profondità.

Valore predefinito: 0

12

DEPTH_STATS

Indica se raccogliere statistiche di profondità o meno.

Valore predefinito: vero

13

DEPTH_STATS_VERBOSE

Questa impostazione, se abilitata, il numero di richieste viene raccolto nelle statistiche per ogni profondità dettagliata.

Valore predefinito: False

14

DNSCACHE_ENABLED

Viene utilizzato per abilitare il DNS nella cache di memoria.

Valore predefinito: vero

15

DNSCACHE_SIZE

Definisce la dimensione del DNS nella cache di memoria.

Valore predefinito: 10000

16

DNS_TIMEOUT

Viene utilizzato per impostare il timeout per il DNS per elaborare le query.

Valore predefinito: 60

17

DOWNLOADER

È un downloader utilizzato per il processo di scansione.

Valore predefinito: "scrapy.core.downloader.Downloader"

18

DOWNLOADER_MIDDLEWARES

È un dizionario contenente il middleware del downloader e i loro ordini.

Valore predefinito: {}

19

DOWNLOADER_MIDDLEWARES_BASE

È un dizionario che contiene il middleware del downloader che è abilitato per impostazione predefinita.

Valore predefinito -

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

DOWNLOADER_STATS

Questa impostazione viene utilizzata per abilitare le statistiche del downloader.

Valore predefinito: vero

21

DOWNLOAD_DELAY

Definisce il tempo totale per il downloader prima che scarichi le pagine dal sito.

Valore predefinito: 0

22

DOWNLOAD_HANDLERS

È un dizionario con gestori di download.

Valore predefinito: {}

23

DOWNLOAD_HANDLERS_BASE

È un dizionario con gestori di download abilitato per impostazione predefinita.

Valore predefinito -

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

DOWNLOAD_TIMEOUT

È il tempo totale di attesa del downloader prima che scada.

Valore predefinito: 180

25

DOWNLOAD_MAXSIZE

È la dimensione massima della risposta per il download del downloader.

Valore predefinito: 1073741824 (1024 MB)

26

DOWNLOAD_WARNSIZE

Definisce la dimensione della risposta che il downloader deve avvertire.

Valore predefinito: 33554432 (32 MB)

27

DUPEFILTER_CLASS

È una classe utilizzata per rilevare e filtrare le richieste duplicate.

Valore predefinito: "scrapy.dupefilters.RFPDupeFilter"

28

DUPEFILTER_DEBUG

Questa impostazione registra tutti i filtri duplicati se impostata su true.

Valore predefinito: False

29

EDITOR

Viene utilizzato per modificare gli spider utilizzando il comando di modifica.

Valore predefinito: dipende dall'ambiente

30

EXTENSIONS

È un dizionario con estensioni abilitate nel progetto.

Valore predefinito: {}

31

EXTENSIONS_BASE

È un dizionario con estensioni incorporate.

Valore predefinito: {'scrapy.extensions.corestats.CoreStats': 0,}

32

FEED_TEMPDIR

È una directory utilizzata per impostare la cartella personalizzata in cui è possibile archiviare i file temporanei del crawler.

33

ITEM_PIPELINES

È un dizionario con pipeline.

Valore predefinito: {}

34

LOG_ENABLED

Definisce se la registrazione deve essere abilitata.

Valore predefinito: vero

35

LOG_ENCODING

Definisce il tipo di codifica da utilizzare per la registrazione.

Valore predefinito: "utf-8"

36

LOG_FILE

È il nome del file da utilizzare per l'output della registrazione.

Valore predefinito: Nessuno

37

LOG_FORMAT

È una stringa con la quale è possibile formattare i messaggi di registro.

Valore predefinito: '% (asctime) s [% (name) s]% (levelname) s:% (message) s'

38

LOG_DATEFORMAT

È una stringa che utilizza la quale è possibile formattare data / ora.

Valore predefinito: '% Y-% m-% d% H:% M:% S'

39

LOG_LEVEL

Definisce il livello minimo di registrazione.

Valore predefinito: "DEBUG"

40

LOG_STDOUT

Se questa impostazione è impostata su true, tutto l'output del processo verrà visualizzato nel registro.

Valore predefinito: False

41

MEMDEBUG_ENABLED

Definisce se il debug della memoria deve essere abilitato.

Valore predefinito: False

42

MEMDEBUG_NOTIFY

Definisce il rapporto sulla memoria che viene inviato a un particolare indirizzo quando è abilitato il debug della memoria.

Valore predefinito: []

43

MEMUSAGE_ENABLED

Definisce se l'utilizzo della memoria deve essere abilitato quando un processo Scrapy supera un limite di memoria.

Valore predefinito: False

44

MEMUSAGE_LIMIT_MB

Definisce il limite massimo consentito per la memoria (in megabyte).

Valore predefinito: 0

45

MEMUSAGE_CHECK_INTERVAL_SECONDS

Viene utilizzato per controllare l'attuale utilizzo della memoria impostando la lunghezza degli intervalli.

Valore predefinito: 60,0

46

MEMUSAGE_NOTIFY_MAIL

Viene utilizzato per notificare con un elenco di e-mail quando la memoria raggiunge il limite.

Valore predefinito: False

47

MEMUSAGE_REPORT

Definisce se il rapporto sull'utilizzo della memoria deve essere inviato alla chiusura di ogni spider.

Valore predefinito: False

48

MEMUSAGE_WARNING_MB

Definisce una memoria totale da consentire prima dell'invio di un avviso.

Valore predefinito: 0

49

NEWSPIDER_MODULE

È un modulo in cui viene creato un nuovo spider utilizzando il comando genspider.

Valore predefinito: ''

50

RANDOMIZE_DOWNLOAD_DELAY

Definisce un periodo di tempo casuale che uno Scrapy deve attendere durante il download delle richieste dal sito.

Valore predefinito: vero

51

REACTOR_THREADPOOL_MAXSIZE

Definisce una dimensione massima per il pool di thread del reattore.

Valore predefinito: 10

52

REDIRECT_MAX_TIMES

Definisce quante volte una richiesta può essere reindirizzata.

Valore predefinito: 20

53

REDIRECT_PRIORITY_ADJUST

Questa impostazione, se impostata, regola la priorità di reindirizzamento di una richiesta.

Valore predefinito: +2

54

RETRY_PRIORITY_ADJUST

Questa impostazione, se impostata, regola la priorità dei tentativi di una richiesta.

Valore predefinito: -1

55

ROBOTSTXT_OBEY

Scrapy obbedisce alle norme del file robots.txt se impostato su true .

Valore predefinito: False

56

SCHEDULER

Definisce lo scheduler da utilizzare a scopo di scansione.

Valore predefinito: "scrapy.core.scheduler.Scheduler"

57

SPIDER_CONTRACTS

È un dizionario nel progetto con contratti di ragno per testare i ragni.

Valore predefinito: {}

58

SPIDER_CONTRACTS_BASE

È un dizionario che contiene i contratti Scrapy che è abilitato in Scrapy per impostazione predefinita.

Valore predefinito -

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

SPIDER_LOADER_CLASS

Definisce una classe che implementa l'API SpiderLoader per caricare gli spider.

Valore predefinito: "scrapy.spiderloader.SpiderLoader"

60

SPIDER_MIDDLEWARES

È un dizionario che contiene middleware ragno.

Valore predefinito: {}

61

SPIDER_MIDDLEWARES_BASE

È un dizionario che contiene middleware spider che è abilitato in Scrapy per impostazione predefinita.

Valore predefinito -

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

SPIDER_MODULES

È un elenco di moduli contenenti spider che Scrapy cercherà.

Valore predefinito: []

63

STATS_CLASS

È una classe che implementa Stats Collector API per raccogliere statistiche.

Valore predefinito: "scrapy.statscollectors.MemoryStatsCollector"

64

STATS_DUMP

Questa impostazione, se impostata su true, scarica le statistiche nel registro.

Valore predefinito: vero

65

STATSMAILER_RCPTS

Una volta che i ragni finiscono di raschiare, Scrapy usa questa impostazione per inviare le statistiche.

Valore predefinito: []

66

TELNETCONSOLE_ENABLED

Definisce se abilitare la telnetconsole.

Valore predefinito: vero

67

TELNETCONSOLE_PORT

Definisce una porta per la console telnet.

Valore predefinito: [6023, 6073]

68

TEMPLATES_DIR

È una directory contenente modelli che possono essere utilizzati durante la creazione di nuovi progetti.

Valore predefinito: directory dei modelli all'interno del modulo scrapy

69

URLLENGTH_LIMIT

Definisce il limite massimo di lunghezza consentito per l'URL per gli URL sottoposti a scansione.

Valore predefinito: 2083

70

USER_AGENT

Definisce l'agente utente da utilizzare durante la scansione di un sito.

Valore predefinito: "Scrapy / VERSION (+ http: //scrapy.org)"

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:

Suor n Metodo e descrizione
1

extract()

Restituisce una stringa Unicode insieme ai dati selezionati.

2

re()

Restituisce un elenco di stringhe Unicode, estratte quando l'espressione regolare è stata data come argomento.

3

xpath()

Restituisce un elenco di selettori, che rappresenta i nodi selezionati dall'espressione xpath data come argomento.

4

css()

Restituisce un elenco di selettori, che rappresenta i nodi selezionati dall'espressione CSS fornita come argomento.

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:

Suor n Comando e descrizione
1

--logfile FILE

Sostituisce LOG_FILE

2

--loglevel/-L LEVEL

Sostituisce LOG_LEVEL

3

--nolog

Imposta LOG_ENABLED su False

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)

Suor n Parametro e descrizione
1

settings (dict, None)

Crea e configura il gestore per root logger. Per impostazione predefinita, è Nessuno .

2

install_root_handler (bool)

Specifica di installare il gestore di registrazione root. Per impostazione predefinita, è 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:

Suor n Parametri Descrizione
1
stats.set_value('hostname', socket.gethostname())
Viene utilizzato per impostare il valore delle statistiche.
2
stats.inc_value('customized_count')
Incrementa il valore stat.
3
stats.max_value('max_items_scraped', value)
È possibile impostare il valore stat, solo se maggiore del valore precedente.
4
stats.min_value('min_free_memory_percent', value)
È possibile impostare il valore stat, solo se inferiore al valore precedente.
5
stats.get_value('customized_count')
Recupera il valore stat.
6
stats.get_stats() {'custom_count': 1, 'start_time': 
datetime.datetime(2009, 7, 14, 21, 47, 28, 977139)}
Recupera tutte le statistiche

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:

Suor n Parametri Metodo
1 da scrapy.mail import MailSender mailer = MailSender () Utilizzando un costruttore standard.
2 mailer = MailSender.from_settings (impostazioni) Utilizzando l'oggetto impostazioni Scrapy.

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 -

Suor n Parametro e descrizione
1

smtphost (str)

L'host SMTP viene utilizzato per inviare le e-mail. In caso contrario, verrà utilizzata l'impostazione MAIL_HOST .

2

mailfrom (str)

L'indirizzo del destinatario viene utilizzato per inviare le e-mail. In caso contrario, verrà utilizzata l'impostazione MAIL_FROM .

3

smtpuser

Specifica l'utente SMTP. Se non viene utilizzata, verrà utilizzata l'impostazione MAIL_USER e non ci sarà convalida SMTP se non viene menzionata.

4

smtppass (str)

Specifica il passaggio SMTP per la convalida.

5

smtpport (int)

Specifica la porta SMTP per la connessione.

6

smtptls (boolean)

Implementa utilizzando SMTP STARTTLS.

7

smtpssl (boolean)

Si amministra utilizzando una connessione SSL sicura.

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:

Suor n Parametro e descrizione
1

to (list)

Si riferisce al destinatario dell'e-mail.

2

subject (str)

Specifica l'oggetto dell'email.

3

cc (list)

Si riferisce all'elenco dei ricevitori.

4

body (str)

Si riferisce ai dati del corpo dell'email.

5

attachs (iterable)

Si riferisce all'allegato dell'e-mail, al tipo MIME dell'allegato e al nome dell'allegato.

6

mimetype (str)

Rappresenta il tipo MIME dell'e-mail.

7

charset (str)

Specifica la codifica dei caratteri utilizzata per i contenuti delle e-mail.

Impostazioni della posta

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

Suor n Impostazioni e descrizione Valore predefinito
1

MAIL_FROM

Si riferisce all'e-mail del mittente per l'invio di e-mail.

"scrapy @ localhost"
2

MAIL_HOST

Si riferisce all'host SMTP utilizzato per l'invio di e-mail.

"localhost"
3

MAIL_PORT

Specifica la porta SMTP da utilizzare per l'invio di e-mail.

25
4

MAIL_USER

Si riferisce alla convalida SMTP. Non ci sarà alcuna convalida, se questa impostazione è disabilitata.

Nessuna
5

MAIL_PASS

Fornisce la password utilizzata per la convalida SMTP.

Nessuna
6

MAIL_TLS

Fornisce il metodo per aggiornare una connessione non sicura a una connessione protetta utilizzando SSL / TLS.

Falso
7

MAIL_SSL

Implementa la connessione utilizzando una connessione crittografata SSL.

Falso

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:

Suor n Collegamento e descrizione
1

crawler

Si riferisce all'oggetto Scrapy Crawler (scrapy.crawler.Crawler).

2

engine

Si riferisce all'attributo Crawler.engine.

3

spider

Questo si riferisce al ragno che è attivo.

4

slot

Questo si riferisce allo slot del motore.

5

extensions

Si riferisce all'attributo Extension Manager (Crawler.extensions).

6

stats

Si riferisce all'attributo Stats Collector (Crawler.stats).

7

setting

Si riferisce all'attributo dell'oggetto impostazioni Scrapy (Crawler.settings).

8

est

Si riferisce alla stampa di un rapporto sullo stato del motore.

9

prefs

Si riferisce alla memoria per il debug.

10

p

Si riferisce a un collegamento alla funzione pprint.pprint .

11

hpy

Questo si riferisce al debug della memoria.

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:

Suor n Impostazioni e descrizione Valore predefinito
1

TELNETCONSOLE_PORT

Si riferisce all'intervallo di porte per la console Telnet. Se è impostato su nessuno, la porta verrà assegnata dinamicamente.

[6023, 6073]
2

TELNETCONSOLE_HOST

Si riferisce all'interfaccia su cui la console telnet dovrebbe ascoltare.

"127.0.0.1"

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:

Suor n Impostazione e descrizione Valore predefinito
1

JSONRPC_ENABLED

Si riferisce al booleano, che decide che il servizio web e la sua estensione saranno abilitati o meno.

Vero
2

JSONRPC_LOGFILE

Si riferisce al file utilizzato per registrare le richieste HTTP effettuate al servizio web. Se non è impostato, verrà utilizzato il registro Scrapy standard.

Nessuna
3

JSONRPC_PORT

Si riferisce all'intervallo di porte per il servizio web. Se è impostato su nessuno, la porta verrà assegnata dinamicamente.

[6080, 7030]
4

JSONRPC_HOST

Si riferisce all'interfaccia su cui il servizio web dovrebbe ascoltare.

"127.0.0.1"