Scrapy - Arañas

Descripción

Spider es una clase encargada de definir cómo seguir los enlaces a través de un sitio web y extraer la información de las páginas.

Las arañas predeterminadas de Scrapy son las siguientes:

scrapy Araña

Es una araña de la que todas las demás arañas deben heredar. Tiene la siguiente clase:

class scrapy.spiders.Spider

La siguiente tabla muestra los campos de la clase scrapy.Spider -

No Señor	Campo Descripción
1	name Es el nombre de tu araña.
2	allowed_domains Es una lista de dominios en los que se arrastra la araña.
3	start_urls Es una lista de URL, que serán las raíces de los rastreos posteriores, desde donde la araña comenzará a rastrear.
4	custom_settings Estas son las configuraciones, cuando se ejecuta la araña, se anularán de la configuración de todo el proyecto.
5	crawler Es un atributo que se vincula al objeto Crawler al que está vinculada la instancia de araña.
6	settings Estos son los ajustes para ejecutar una araña.
7	logger Es un registrador de Python que se utiliza para enviar mensajes de registro.
8	from_crawler(crawler,*args,**kwargs) Es un método de clase, que crea tu araña. Los parámetros son: crawler - Un rastreador al que se vinculará la instancia de araña. args(list)- Estos argumentos se pasan al método _init_ () . kwargs(dict)- Estos argumentos de palabras clave se pasan al método _init_ () .
9	start_requests() Cuando no se especifican URL en particular y la araña se abre para desguace, Scrapy llama al método start_requests () .
10	make_requests_from_url(url) Es un método utilizado para convertir URL en solicitudes.
11	parse(response) Este método procesa la respuesta y devuelve datos desechados después de más URL.
12	log(message[,level,component]) Es un método que envía un mensaje de registro a través de spiders logger.
13	closed(reason) Este método se llama cuando la araña se cierra.

Argumentos de araña

Los argumentos de araña se utilizan para especificar las URL de inicio y se pasan mediante el comando de rastreo con -a opción, que se muestra a continuación:

scrapy crawl first_scrapy -a group = accessories

El siguiente código demuestra cómo una araña recibe argumentos:

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]

Arañas genéricas

Puede usar arañas genéricas para subclasificar sus arañas. Su objetivo es seguir todos los enlaces del sitio web según determinadas reglas para extraer datos de todas las páginas.

Para los ejemplos utilizados en las siguientes arañas, supongamos que tenemos un proyecto con los siguientes campos:

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

Gatear Araña

CrawlSpider define un conjunto de reglas para seguir los enlaces y eliminar más de una página. Tiene la siguiente clase:

class scrapy.spiders.CrawlSpider

A continuación se muestran los atributos de la clase CrawlSpider:

reglas

Es una lista de objetos de reglas que define cómo el rastreador sigue el enlace.

La siguiente tabla muestra las reglas de la clase CrawlSpider:

No Señor	Regla y descripción
1	LinkExtractor Especifica cómo Spider sigue los enlaces y extrae los datos.
2	callback Se llamará después de que se raspe cada página.
3	follow Especifica si continuar siguiendo enlaces o no.

parse_start_url (respuesta)

Devuelve el elemento o el objeto de solicitud al permitir analizar las respuestas iniciales.

Note - Asegúrese de cambiar el nombre de la función de análisis que no sea analizar mientras escribe las reglas, ya que CrawlSpider utiliza la función de análisis para implementar su lógica.

Echemos un vistazo al siguiente ejemplo, donde spider comienza a rastrear la página de inicio de demoexample.com, recopilando todas las páginas, enlaces y análisis con el método 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

Es la clase base para arañas que se extraen de fuentes XML e itera sobre los nodos. Tiene la siguiente clase:

class scrapy.spiders.XMLFeedSpider

La siguiente tabla muestra los atributos de clase utilizados para establecer un iterador y un nombre de etiqueta:

No Señor	Atributo y descripción
1	iterator Define el iterador que se utilizará. Puede ser iternodes, html o xml . El valor predeterminado es iternodes .
2	itertag Es una cadena con nombre de nodo para iterar.
3	namespaces Está definido por una lista de (prefijo, uri) tuplas que registra automáticamente los espacios de nombres usando el método register_namespace () .
4	adapt_response(response) Recibe la respuesta y modifica el cuerpo de la respuesta tan pronto como llega del middleware spider, antes de que spider comience a analizarlo.
5	parse_node(response,selector) Recibe la respuesta y un selector cuando se llama para cada nodo que coincida con el nombre de etiqueta proporcionado. Note - Su araña no funcionará si no anula este método.
6	process_results(response,results) Devuelve una lista de resultados y respuestas devueltas por la araña.

CSVFeedSpider

Repite cada una de sus filas, recibe un archivo CSV como respuesta y llama al método parse_row () . Tiene la siguiente clase:

class scrapy.spiders.CSVFeedSpider

La siguiente tabla muestra las opciones que se pueden configurar con respecto al archivo CSV:

No Señor	Opción y descripción
1	delimiter Es una cadena que contiene un separador de coma (',') para cada campo.
2	quotechar Es una cadena que contiene comillas ('"') para cada campo.
3	headers Es una lista de declaraciones de donde se pueden extraer los campos.
4	parse_row(response,row) Recibe una respuesta y cada fila junto con una clave para el encabezado.

Ejemplo de 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

Mapa del sitio

SitemapSpider, con la ayuda de Sitemaps, rastrea un sitio web localizando las URL de robots.txt. Tiene la siguiente clase:

class scrapy.spiders.SitemapSpider

La siguiente tabla muestra los campos de SitemapSpider -

No Señor	Campo Descripción
1	sitemap_urls Una lista de URL que desea rastrear apuntando a los mapas del sitio.
2	sitemap_rules Es una lista de tuplas (expresión regular, devolución de llamada), donde la expresión regular es una expresión regular y la devolución de llamada se utiliza para procesar URL que coinciden con una expresión regular.
3	sitemap_follow Es una lista de las expresiones regulares del mapa del sitio a seguir.
4	sitemap_alternate_links Especifica los enlaces alternativos que se seguirán para una única URL.

Mapa del sitioEjemplo de araña

El siguiente SitemapSpider procesa todas las 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

El siguiente SitemapSpider procesa algunas URL con devolución de llamada:

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

El siguiente código muestra mapas del sitio en el archivo robots.txt cuya URL tiene /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

Incluso puede combinar SitemapSpider con otras URL como se muestra en el siguiente 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...