Scrapy - Ragni

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 esegue la scansione dello spider.
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 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 usare 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 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 della 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 dello 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 che corrisponde 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.

CSVFeedSpider Esempio

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 persino 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...