Scrapy系列教程（3）------Spider（爬虫核心，定义链接关系和网页信息抽取）

Spiders

Spider类定义了怎样爬取某个(或某些)站点。包含了爬取的动作(比如:是否跟进链接)以及怎样从网页的内容中提取结构化数据(爬取item)。

换句话说。Spider就是您定义爬取的动作及分析某个网页(或者是有些网页)的地方。

对spider来说。爬取的循环类似下文:

1. 以初始的URL初始化Request，并设置回调函数。 当该request完成下载并返回时，将生成response，并作为參数传给该回调函数。

   spider中初始的request是通过调用 start_requests() 来获取的。 start_requests() 读取start_urls 中的URL，
   并以 parse 为回调函数生成 Request 。

2. 在回调函数内分析返回的(网页)内容。返回 Item 对象或者 Request 或者一个包含二者的可迭代容器。
   返回的Request对象之后会经过Scrapy处理，下载对应的内容，并调用设置的callback函数(函数可同样)。

3. 在回调函数内，您能够使用 选择器(Selectors) (您也能够使用BeautifulSoup,
   lxml 或者您想用的不论什么解析器) 来分析网页内容。并依据分析的数据生成item。

4. 最后，由spider返回的item将被存到数据库(由某些 Item
   Pipeline 处理)或使用 Feed exports 存入到文件里。

尽管该循环对不论什么类型的spider都(多少)适用。但Scrapy仍然为了不同的需求提供了多种默认spider。 之后将讨论这些spider。

Spider參数

Spider能够通过接受參数来改动其功能。 spider參数一般用来定义初始URL或者指定限制爬取站点的部分。 您也能够使用其来配置spider的不论什么功能。

在执行 crawl 时加入 -a 能够传递Spider參数:

scrapy crawl myspider -a category=electronics

Spider在构造器(constructor)中获取參数:

import scrapy

class MySpider(Spider):
    name = 'myspider'

    def __init__(self, category=None, *args, **kwargs):
        super(MySpider, self).__init__(*args, **kwargs)
        self.start_urls = ['http://www.example.com/categories/%s' % category]
        # ...

Spider參数也能够通过Scrapyd的 schedule.json API来传递。
參见 Scrapyd documentation.

内置Spider參考手冊

Scrapy提供多种方便的通用spider供您继承使用。 这些spider为一些经常使用的爬取情况提供方便的特性， 比如依据某些规则跟进某个站点的全部链接、依据 Sitemaps 来进行爬取，或者分析XML/CSV源。

以下spider的演示样例中，我们假定您有个项目在 myproject.items 模块中声明了 TestItem:

import scrapy

class TestItem(scrapy.Item):
    id = scrapy.Field()
    name = scrapy.Field()
    description = scrapy.Field()

Spider

classscrapy.spider.Spider

Spider是最简单的spider。

每一个其它的spider必须继承自该类(包含Scrapy自带的其它spider以及您自己编写的spider)。 Spider并没有提供什么特殊的功能。 其只请求给定的start_urls/start_requests ，并依据返回的结果(resulting
responses)调用spider的 parse 方法。

name

定义spider名字的字符串(string)。

spider的名字定义了Scrapy怎样定位(并初始化)spider，所以其必须是唯一的。 只是您能够生成多个同样的spider实例(instance)，这没有不论什么限制。

name是spider最重要的属性，并且是必须的。

假设该spider爬取单个站点(single domain)，一个常见的做法是以该站点(domain)(加或不加后缀 )来命名spider。
比如。假设spider爬取 mywebsite.com 。该spider一般会被命名为mywebsite 。

allowed_domains

可选。包括了spider同意爬取的域名(domain)列表(list)。 当 OffsiteMiddleware 启用时，
域名不在列表中的URL不会被跟进。

start_urls

URL列表。当没有制定特定的URL时，spider将从该列表中開始进行爬取。 因此。第一个被获取到的页面的URL将是该列表之中的一个。 兴许的URL将会从获取到的数据中提取。

start_requests()

该方法必须返回一个可迭代对象(iterable)。

该对象包括了spider用于爬取的第一个Request。

当spider启动爬取而且未制定URL时，该方法被调用。

当指定了URL时，make_requests_from_url() 将被调用来创建Request对象。
该方法只会被Scrapy调用一次。因此您能够将事实上现为生成器。

该方法的默认实现是使用 start_urls 的url生成Request。

假设您想要改动最初爬取某个站点的Request对象。您能够重写(override)该方法。

比如，假设您须要在启动时以POST登录某个站点，你能够这么写:

def start_requests(self):
    return [scrapy.FormRequest("http://www.example.com/login",
                               formdata={'user': 'john', 'pass': 'secret'},
                               callback=self.logged_in)]

def logged_in(self, response):
    # here you would extract links to follow and return Requests for
    # each of them, with another callback
    pass

make_requests_from_url(url)

该方法接受一个URL并返回用于爬取的 Request 对象。
该方法在初始化request时被start_requests() 调用。也被用于转化url为request。

默认未被复写(overridden)的情况下，该方法返回的Request对象中。 parse() 作为回调函数。dont_filter參数也被设置为开启。

(详情參见 Request).

parse(response)

当response没有指定回调函数时，该方法是Scrapy处理下载的response的默认方法。

parse 负责处理response并返回处理的数据以及(/或)跟进的URL。 Spider 对其它的Request的回调函数也有同样的要求。

该方法及其它的Request回调函数必须返回一个包括 Request 及(或) Item 的可迭代的对象。

參数:	response (Response) – 用于分析的response

log(message[, level, component])

使用 scrapy.log.msg() 方法记录(log)message。
log中自己主动带上该spider的 name 属性。

很多其它数据请參见 Logging 。

closed(reason)

当spider关闭时，该函数被调用。 该方法提供了一个替代调用signals.connect()来监听spider_closed 信号的快捷方式。

Spider例子

让我们来看一个样例:

import scrapy

class MySpider(scrapy.Spider):
    name = 'example.com'
    allowed_domains = ['example.com']
    start_urls = [
        'http://www.example.com/1.html',
        'http://www.example.com/2.html',
        'http://www.example.com/3.html',
    ]

    def parse(self, response):
        self.log('A response from %s just arrived!' % response.url)

还有一个在单个回调函数中返回多个Request以及Item的样例:

import scrapy
from myproject.items import MyItem

class MySpider(scrapy.Spider):
    name = 'example.com'
    allowed_domains = ['example.com']
    start_urls = [
        'http://www.example.com/1.html',
        'http://www.example.com/2.html',
        'http://www.example.com/3.html',
    ]

    def parse(self, response):
        sel = scrapy.Selector(response)
        for h3 in response.xpath('//h3').extract():
            yield MyItem(title=h3)

        for url in response.xpath('//a/@href').extract():
            yield scrapy.Request(url, callback=self.parse)

CrawlSpider

classscrapy.contrib.spiders.CrawlSpider

爬取一般站点经常使用的spider。其定义了一些规则(rule)来提供跟进link的方便的机制。 或许该spider并非全然适合您的特定站点或项目，但其对非常多情况都使用。

因此您能够以其为起点，依据需求改动部分方法。

当然您也能够实现自己的spider。

除了从Spider继承过来的(您必须提供的)属性外，其提供了一个新的属性:

rules

一个包括一个(或多个) Rule 对象的集合(list)。
每一个 Rule 对爬取站点的动作定义了特定表现。
Rule对象在下边会介绍。 假设多个rule匹配了同样的链接，则依据他们在本属性中被定义的顺序。第一个会被使用。

该spider也提供了一个可复写(overrideable)的方法:

parse_start_url(response)

当start_url的请求返回时，该方法被调用。

该方法分析最初的返回值并必须返回一个 Item对象或者
一个 Request 对象或者
一个可迭代的包括二者对象。

爬取规则(Crawling rules)

classscrapy.contrib.spiders.Rule(link_extractor, callback=None, cb_kwargs=None, follow=None,process_links=None, process_request=None)

link_extractor 是一个 Link
Extractor 对象。

其定义了怎样从爬取到的页面提取链接。

callback 是一个callable或string(该spider中同名的函数将会被调用)。
从link_extractor中每获取到链接时将会调用该函数。该回调函数接受一个response作为其第一个參数。 并返回一个包括Item 以及(或) Request 对象(或者这两者的子类)的列表(list)。

警告

当编写爬虫规则时，请避免使用 parse 作为回调函数。

因为 CrawlSpider 使用 parse 方法来实现其逻辑，假设
您覆盖了 parse 方法，crawl
spider 将会执行失败。

cb_kwargs 包括传递给回调函数的參数(keyword
argument)的字典。

follow 是一个布尔(boolean)值，指定了依据该规则从response提取的链接是否须要跟进。
假设callback 为None。 follow 默认设置为 True 。否则默觉得 False 。

process_links 是一个callable或string(该spider中同名的函数将会被调用)。
从link_extractor中获取到链接列表时将会调用该函数。该方法主要用来过滤。

process_request 是一个callable或string(该spider中同名的函数将会被调用)。

该规则提取到每一个request时都会调用该函数。该函数必须返回一个request或者None。 (用来过滤request)

CrawlSpider例子

接下来给出配合rule使用CrawlSpider的样例:

import scrapy
from scrapy.contrib.spiders import CrawlSpider, Rule
from scrapy.contrib.linkextractors import LinkExtractor

class MySpider(CrawlSpider):
    name = 'example.com'
    allowed_domains = ['example.com']
    start_urls = ['http://www.example.com']

    rules = (
        # 提取匹配 'category.php' (但不匹配 'subsection.php') 的链接并跟进链接(没有callback意味着follow默觉得True)
        Rule(LinkExtractor(allow=('category\.php', ), deny=('subsection\.php', ))),

        # 提取匹配 'item.php' 的链接并使用spider的parse_item方法进行分析
        Rule(LinkExtractor(allow=('item\.php', )), callback='parse_item'),
    )

    def parse_item(self, response):
        self.log('Hi, this is an item page! %s' % response.url)

        item = scrapy.Item()
        item['id'] = response.xpath('//td[@id="item_id"]/text()').re(r'ID: (\d+)')
        item['name'] = response.xpath('//td[@id="item_name"]/text()').extract()
        item['description'] = response.xpath('//td[@id="item_description"]/text()').extract()
        return item

该spider将从example.com的首页開始爬取，获取category以及item的链接并对后者使用 parse_item方法。
当item获得返回(response)时，将使用XPath处理HTML并生成一些数据填入 Item 中。

XMLFeedSpider

classscrapy.contrib.spiders.XMLFeedSpider

XMLFeedSpider被设计用于通过迭代各个节点来分析XML源(XML feed)。 迭代器能够从iternodes ， xml ， html 选择。
鉴于 xml 以及 html 迭代器须要先读取全部DOM再分析而引起的性能问题。
一般还是推荐使用 iternodes 。

只是使用 html 作为迭代器能有效应对错误的XML。

您必须定义下列类属性来设置迭代器以及标签名(tag name):

iterator

用于确定使用哪个迭代器的string。可选项有:

• 'iternodes' -
  一个高性能的基于正則表達式的迭代器
• 'html' -
  使用 Selector 的迭代器。
  须要注意的是该迭代器使用DOM进行分析，其须要将全部的DOM加载内存， 当数据量大的时候会产生问题。
• 'xml' -
  使用 Selector 的迭代器。
  须要注意的是该迭代器使用DOM进行分析，其须要将全部的DOM加载内存， 当数据量大的时候会产生问题。

默认值为 iternodes 。

itertag

一个包括開始迭代的节点名的string。比如:

itertag = 'product'

namespaces

一个由 (prefix, url) 元组(tuple)所组成的list。

其定义了在该文档中会被spider处理的可用的namespace。

prefix 及 uri 会被自己主动调用 register_namespace() 生成namespace。

您能够通过在 itertag 属性中制定节点的namespace。

比如:

class YourSpider(XMLFeedSpider):

    namespaces = [('n', 'http://www.sitemaps.org/schemas/sitemap/0.9')]
    itertag = 'n:url'
    # ...

除了这些新的属性之外，该spider也有下面能够覆盖(overrideable)的方法:

adapt_response(response)

该方法在spider分析response前被调用。您能够在response被分析之前使用该函数来改动内容(body)。

该方法接受一个response并返回一个response(能够同样也能够不同)。

parse_node(response, selector)

当节点符合提供的标签名时(itertag)该方法被调用。
接收到的response以及对应的Selector 作为參数传递给该方法。
该方法返回一个 Item 对象或者 Request 对象
或者一个包括二者的可迭代对象(iterable)。

process_results(response, results)

当spider返回结果(item或request)时该方法被调用。 设定该方法的目的是在结果返回给框架核心(framework core)之前做最后的处理， 比如设定item的ID。其接受一个结果的列表(list of results)及相应的response。

其结果必须返回一个结果的列表(list of results)(包括Item或者Request对象)。

XMLFeedSpider样例

该spider十分易用。

下边是当中一个样例:

from scrapy import log
from scrapy.contrib.spiders import XMLFeedSpider
from myproject.items import TestItem

class MySpider(XMLFeedSpider):
    name = 'example.com'
    allowed_domains = ['example.com']
    start_urls = ['http://www.example.com/feed.xml']
    iterator = 'iternodes' # This is actually unnecessary, since it's the default value
    itertag = 'item'

    def parse_node(self, response, node):
        log.msg('Hi, this is a <%s> node!: %s' % (self.itertag, ''.join(node.extract())))

        item = TestItem()
        item['id'] = node.xpath('@id').extract()
        item['name'] = node.xpath('name').extract()
        item['description'] = node.xpath('description').extract()
        return item

简单来说。我们在这里创建了一个spider。从给定的 start_urls 中下载feed。
并迭代feed中每一个item 标签。输出，并在 Item 中存储有些随机数据。

CSVFeedSpider

classscrapy.contrib.spiders.CSVFeedSpider

该spider除了其按行遍历而不是节点之外其它和XMLFeedSpider十分类似。 而其在每次迭代时调用的是 parse_row() 。

delimiter

在CSV文件里用于区分字段的分隔符。类型为string。 默觉得 ',' (逗号)。

headers

在CSV文件里包括的用来提取字段的行的列表。參考下边的样例。

parse_row(response, row)

该方法接收一个response对象及一个以提供或检測出来的header为键的字典(代表每行)。

该spider中，您也能够覆盖 adapt_response 及 process_results 方法来进行预处理(pre-processing)及后(post-processing)处理。

CSVFeedSpider样例

以下的样例和之前的样例非常像，但使用了 CSVFeedSpider:

from scrapy import log
from scrapy.contrib.spiders import CSVFeedSpider
from myproject.items import TestItem

class MySpider(CSVFeedSpider):
    name = 'example.com'
    allowed_domains = ['example.com']
    start_urls = ['http://www.example.com/feed.csv']
    delimiter = ';'
    headers = ['id', 'name', 'description']

    def parse_row(self, response, row):
        log.msg('Hi, this is a row!: %r' % row)

        item = TestItem()
        item['id'] = row['id']
        item['name'] = row['name']
        item['description'] = row['description']
        return item

SitemapSpider

classscrapy.contrib.spiders.SitemapSpider

SitemapSpider使您爬取站点时能够通过 Sitemaps 来发现爬取的URL。

其支持嵌套的sitemap，并能从 robots.txt 中获取sitemap的url。

sitemap_urls

包括您要爬取的url的sitemap的url列表(list)。 您也能够指定为一个 robots.txt 。spider会从中分析并提取url。

sitemap_rules

一个包括 (regex, callback) 元组的列表(list):

• regex 是一个用于匹配从sitemap提供的url的正則表達式。 regex 能够是一个字符串或者编译的正则对象(compiled
  regex object)。

• callback指定了匹配正則表達式的url的处理函数。 callback 能够是一个字符串(spider中方法的名字)或者是callable。

比如:

sitemap_rules = [('/product/', 'parse_product')]

规则按顺序进行匹配，之后第一个匹配才会被应用。

假设您忽略该属性。sitemap中发现的全部url将会被 parse 函数处理。

sitemap_follow

一个用于匹配要跟进的sitemap的正則表達式的列表(list)。其只被应用在 使用 Sitemap index files 来指向其它sitemap文件的网站。

默认情况下全部的sitemap都会被跟进。

sitemap_alternate_links

指定当一个 url 有可选的链接时。是否跟进。
有些非英文站点会在一个 url 块内提供其它语言的站点链接。

比如:

<url>
    <loc>http://example.com/</loc>
    <xhtml:link rel="alternate" hreflang="de" href="http://example.com/de"/>
</url>

当 sitemap_alternate_links 设置时，两个URL都会被获取。
当 sitemap_alternate_links 关闭时，仅仅有 http://example.com/ 会被获取。

默认 sitemap_alternate_links 关闭。

SitemapSpider例子

简单的样例: 使用 parse 处理通过sitemap发现的全部url:

from scrapy.contrib.spiders import SitemapSpider

class MySpider(SitemapSpider):
    sitemap_urls = ['http://www.example.com/sitemap.xml']

    def parse(self, response):
        pass # ... scrape item here ...

用特定的函数处理某些url。其它的使用另外的callback:

from scrapy.contrib.spiders import SitemapSpider

class MySpider(SitemapSpider):
    sitemap_urls = ['http://www.example.com/sitemap.xml']
    sitemap_rules = [
        ('/product/', 'parse_product'),
        ('/category/', 'parse_category'),
    ]

    def parse_product(self, response):
        pass # ... scrape product ...

    def parse_category(self, response):
        pass # ... scrape category ...

跟进 robots.txt 文件定义的sitemap并仅仅跟进包括有 ..sitemap_shop 的url:

from scrapy.contrib.spiders import SitemapSpider

class MySpider(SitemapSpider):
    sitemap_urls = ['http://www.example.com/robots.txt']
    sitemap_rules = [
        ('/shop/', 'parse_shop'),
    ]
    sitemap_follow = ['/sitemap_shops']

    def parse_shop(self, response):
        pass # ... scrape shop here ...

在SitemapSpider中使用其它url:

from scrapy.contrib.spiders import SitemapSpider

class MySpider(SitemapSpider):
    sitemap_urls = ['http://www.example.com/robots.txt']
    sitemap_rules = [
        ('/shop/', 'parse_shop'),
    ]

    other_urls = ['http://www.example.com/about']

    def start_requests(self):
        requests = list(super(MySpider, self).start_requests())
        requests += [scrapy.Request(x, self.parse_other) for x in self.other_urls]
        return requests

    def parse_shop(self, response):
        pass # ... scrape shop here ...

    def parse_other(self, response):
        pass # ... scrape other here ...