Jak korzystać ze skrobaczki w celu przeszukiwania wielu stron?

Question

Wszystkie przykłady znalezione w Scrapy mówią o tym, jak zindeksować pojedynczą stronę, strony o tym samym schemacie URL lub wszystkie strony witryny. muszę pełzać serię stron A, B, C, gdzie w dostałeś linku do B i tak dalej .. Na przykład struktura serwisu jest:

A 
----> B 
---------> C 
D 
E 

muszę indeksować wszystkie strony C , ale aby uzyskać link do C muszę się czołgać przed A i B. Jakieś wskazówki?

Answer 1

zobaczyć scrapy Request structure, pełzać taki łańcuch musisz użyć parametru wywołania zwrotnego tak:

class MySpider(BaseSpider): 
    ... 
    # spider starts here 
    def parse(self, response): 
     ... 
     # A, D, E are done in parallel, A -> B -> C are done serially 
     yield Request(url=<A url>, 
         ... 
         callback=parseA) 
     yield Request(url=<D url>, 
         ... 
         callback=parseD) 
     yield Request(url=<E url>, 
         ... 
         callback=parseE) 

    def parseA(self, response): 
     ... 
     yield Request(url=<B url>, 
         ... 
         callback=parseB) 

    def parseB(self, response): 
     ... 
     yield Request(url=<C url>, 
         ... 
         callback=parseC) 

    def parseC(self, response): 
     ... 

    def parseD(self, response): 
     ... 

    def parseE(self, response): 
     ... 

Answer 2

Oto przykład pająk pisałem o projekcie kopalni:

from scrapy.contrib.spiders import CrawlSpider 
from scrapy.selector import HtmlXPathSelector 
from scrapy.http import Request 
from yoMamaSpider.items import JokeItem 
from yoMamaSpider.striputils import stripcats, stripjokes 
import re 

class Jokes4UsSpider(CrawlSpider): 
    name = 'jokes4us' 
    allowed_domains = ['jokes4us.com'] 
    start_urls = ["http://www.jokes4us.com/yomamajokes/"] 

    def parse(self, response): 
     hxs = HtmlXPathSelector(response) 
     links = hxs.select('//a') 
     for link in links: 
      url = ''.join(link.select('./@href').extract()) 
      relevant_urls = re.compile(
       'http://www\.jokes4us\.com/yomamajokes/yomamas([a-zA-Z]+)') 
      if relevant_urls.match(url): 
       yield Request(url, callback=self.parse_page) 

    def parse_page(self, response): 
     hxs = HtmlXPathSelector(response) 
     categories = stripcats(hxs.select('//title/text()').extract()) 
     joke_area = hxs.select('//p/text()').extract() 
     for joke in joke_area: 
      joke = stripjokes(joke) 
      if len(joke) > 15: 
       yield JokeItem(joke=joke, categories=categories) 

Myślę, że metoda parsowania jest tym, czego szukasz: Sprawdza każdy link na stronie start_urls, następnie używa jakiegoś wyrażenia regularnego, aby zdecydować, czy jest to releve_url (czyli URL, który chciałbym zeskrobać), jeśli jest to istotne - zeskrobuje stronę za pomocą Żądania zysku (url, callback = self.parse_page), który wywołuje metodę parse_page.

Czy tego właśnie szukasz?