Scrapy - Araignées

La description

Spider est une classe chargée de définir comment suivre les liens via un site Web et extraire les informations des pages.

Les araignées par défaut de Scrapy sont les suivantes -

tremblante.

C'est une araignée dont toutes les autres araignées doivent hériter. Il a la classe suivante -

class scrapy.spiders.Spider

Le tableau suivant montre les champs de la classe scrapy.Spider -

Sr. Non	Champ et description
1	name C'est le nom de votre araignée.
2	allowed_domains C'est une liste de domaines sur lesquels l'araignée rampe.
3	start_urls C'est une liste d'URL, qui seront les racines des analyses ultérieures, d'où l'araignée commencera à explorer.
4	custom_settings Ce sont les paramètres, lors de l'exécution de l'araignée, qui seront remplacés par la configuration à l'échelle du projet.
5	crawler C'est un attribut lié à l'objet Crawler auquel l'instance d'araignée est liée.
6	settings Ce sont les paramètres pour exécuter une araignée.
sept	logger C'est un enregistreur Python utilisé pour envoyer des messages de journal.
8	*from_crawler(crawler,args,kwargs) C'est une méthode de classe, qui crée votre araignée. Les paramètres sont - crawler - Un robot auquel l'instance spider sera liée. args(list)- Ces arguments sont passés à la méthode _init_ () . kwargs(dict)- Ces arguments de mot-clé sont passés à la méthode _init_ () .
9	start_requests() Lorsqu'aucune URL particulière n'est spécifiée et que l'araignée est ouverte pour la mise au rebut, Scrapy appelle la méthode start_requests () .
dix	make_requests_from_url(url) C'est une méthode utilisée pour convertir les URL en requêtes.
11	parse(response) Cette méthode traite la réponse et renvoie les données supprimées à la suite d'autres URL.
12	log(message[,level,component]) C'est une méthode qui envoie un message de journal via un enregistreur d'araignées.
13	closed(reason) Cette méthode est appelée lorsque l'araignée se ferme.

Arguments d'araignée

Les arguments Spider sont utilisés pour spécifier les URL de démarrage et sont transmis à l'aide de la commande d'exploration avec -a option, illustrée comme suit -

scrapy crawl first_scrapy -a group = accessories

Le code suivant montre comment une araignée reçoit des arguments -

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]

Araignées génériques

Vous pouvez utiliser des araignées génériques pour sous-classer vos araignées. Leur objectif est de suivre tous les liens sur le site Web en fonction de certaines règles pour extraire les données de toutes les pages.

Pour les exemples utilisés dans les araignées suivantes, supposons que nous ayons un projet avec les champs suivants -

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

CrawlSpider

CrawlSpider définit un ensemble de règles pour suivre les liens et supprimer plus d'une page. Il a la classe suivante -

class scrapy.spiders.CrawlSpider

Voici les attributs de la classe CrawlSpider -

règles

Il s'agit d'une liste d'objets de règle qui définit la manière dont le robot suit le lien.

Le tableau suivant montre les règles de la classe CrawlSpider -

Sr. Non	Règle et description
1	LinkExtractor Il spécifie comment spider suit les liens et extrait les données.
2	callback Il doit être appelé après chaque page est grattée.
3	follow Il spécifie s'il faut continuer à suivre les liens ou non.

parse_start_url (réponse)

Il retourne un élément ou un objet de requête en permettant d'analyser les réponses initiales.

Note - Assurez-vous de renommer la fonction d'analyse autre que parse lors de l'écriture des règles car la fonction d'analyse est utilisée par CrawlSpider pour implémenter sa logique.

Jetons un œil à l'exemple suivant, où spider commence à explorer la page d'accueil de demoexample.com, collectant toutes les pages, liens et analyses avec la méthode 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

C'est la classe de base pour les araignées qui grattent des flux XML et itèrent sur les nœuds. Il a la classe suivante -

class scrapy.spiders.XMLFeedSpider

Le tableau suivant montre les attributs de classe utilisés pour définir un itérateur et un nom de balise -

Sr. Non	Attribut et description
1	iterator Il définit l'itérateur à utiliser. Il peut s'agir de iternodes, html ou xml . La valeur par défaut est iternodes .
2	itertag C'est une chaîne avec le nom du nœud à itérer.
3	namespaces Il est défini par une liste de tuples (prefix, uri) qui enregistre automatiquement les espaces de noms en utilisant la méthode register_namespace () .
4	adapt_response(response) Il reçoit la réponse et modifie le corps de la réponse dès qu'il arrive du middleware spider, avant que spider ne commence à l'analyser.
5	parse_node(response,selector) Il reçoit la réponse et un sélecteur lorsqu'il est appelé pour chaque nœud correspondant au nom de balise fourni. Note - Votre araignée ne fonctionnera pas si vous ne remplacez pas cette méthode.
6	process_results(response,results) Il renvoie une liste de résultats et de réponse renvoyés par l'araignée.

CSVFeedSpider

Il parcourt chacune de ses lignes, reçoit un fichier CSV en réponse et appelle la méthode parse_row () . Il a la classe suivante -

class scrapy.spiders.CSVFeedSpider

Le tableau suivant montre les options qui peuvent être définies concernant le fichier CSV -

Sr. Non	Option et description
1	delimiter C'est une chaîne contenant une virgule (',') séparateur pour chaque champ.
2	quotechar Il s'agit d'une chaîne contenant des guillemets ('"') pour chaque champ.
3	headers Il s'agit d'une liste d'instructions d'où les champs peuvent être extraits.
4	parse_row(response,row) Il reçoit une réponse et chaque ligne avec une clé pour l'en-tête.

Exemple 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

Plan du siteSpider

SitemapSpider à l'aide de Sitemaps explore un site Web en localisant les URL à partir du fichier robots.txt. Il a la classe suivante -

class scrapy.spiders.SitemapSpider

Le tableau suivant montre les champs de SitemapSpider -

Sr. Non	Champ et description
1	sitemap_urls Une liste d'URL que vous souhaitez explorer pointant vers les plans de site.
2	sitemap_rules C'est une liste de tuples (regex, callback), où regex est une expression régulière, et le callback est utilisé pour traiter les URL correspondant à une expression régulière.
3	sitemap_follow C'est une liste d'expressions régulières de sitemap à suivre.
4	sitemap_alternate_links Spécifie les liens alternatifs à suivre pour une seule URL.

Exemple SitemapSpider

Le SitemapSpider suivant traite toutes les 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

Le SitemapSpider suivant traite certaines URL avec rappel -

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

Le code suivant montre des sitemaps dans le fichier robots.txt dont l'URL a /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

Vous pouvez même combiner SitemapSpider avec d'autres URL, comme indiqué dans la commande suivante.

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

↰ Previous page Next page ↱