Scrapy 爬虫（Spider）

Spider 类定义了如何爬取某个（或某些）网站。包括了爬取的动作（例如，是否跟进链接）以及如何从网页的内容中提取结构化数据（爬取 item）。换句话说，Spider 就是您定义爬取的动作及分析某个网页（或者是有些网页）的地方。

对 spider 来说，爬取的循环类似下文：

1. 以初始的 URL 初始化 Request，并设置回调函数。当该 request 下载完毕并返回时，将生成 response，并作为参数传给该回调函数；spider 中初始的 request 是通过调用 start_requests() 来获取的。start_requests() 读取 start_urls 中的 URL， 并以 parse 为回调函数生成 Request；
2. 在回调函数内分析返回的（网页）内容，返回 Item 对象、dict、Request 或者一个包括三者的可迭代容器。返回的 Request 对象之后会经过 Scrapy 处理，下载相应的内容，并调用设置的 callback 函数（函数可相同）；
3. 在回调函数内，可以使用选择器（Selectors）（也可以使用 BeautifulSoup, lxml 或者您想用的任何解析器）来分析网页内容，并根据分析的数据生成 item；
4. 最后，由 spider 返回的 item 将被存到数据库（由某些 Item Pipeline 处理）或使用 Feed exports 存入到文件中。

虽然该循环对任何类型的 spider 都（多少）适用，但 Scrapy 仍然为了不同的需求提供了多种默认 spider。

scrapy.Spider

class scrapy.spiders.Spider

Spider 是最简单的 spider。每个其他的 spider 必须继承自该类（包括 Scrapy 自带的其他 spider 以及您自己编写的 spider）。Spider 并没有提供什么特殊的功能。其仅仅提供了 start_requests() 的默认实现，读取并请求 spider 属性中的 start_urls，并根据返回的结果（resulting responses）调用 spider 的 parse 方法。

CrawlSpider

class scrapy.spiders.CrawlSpider

爬取一般网站常用的 spider。其定义了一些规则（rule）来提供跟进 link 的方便的机制。也许该 spider 并不是完全适合您的特定网站或项目，但其对很多情况都适用。因此您可以以其为起点，根据需求修改部分方法。当然您也可以实现自己的 spider。

除了从 Spider 继承过来的（您必须提供的）属性外，其提供了一个新的属性：

爬取规则（Crawling rules）

class Rule(object):

    def __init__(self, link_extractor, callback=None, cb_kwargs=None, follow=None, process_links=None, process_request=identity):
        ...

LinkExtractor 类

该类是链接提取器，其唯一目的是从 scrapy.http.Response 最终将跟随的网页（对象）提取链接的对象。

你可以创建自己的自定义链接提取器，以满足自身的特定需求。

from .lxmlhtml import LxmlLinkExtractor as LinkExtractor

LinkExtractor 类的原名是 LxmlLinkExtractor，继承了 FilteringLinkExtractor。

class LxmlLinkExtractor(FilteringLinkExtractor):

    def __init__(self, allow=(), deny=(), allow_domains=(), deny_domains=(), restrict_xpaths=(),
                 tags=('a', 'area'), attrs=('href',), canonicalize=False,
                 unique=True, process_value=None, deny_extensions=None, restrict_css=(),
                 strip=True):

LxmlLinkExtractor 是推荐的链接提取器，其基于强大的网页提取库 lxml。

类的相关参数如下：

• allow（正则表达式（或列表）） - 一个单一的正则表达式（或正则表达式列表），（绝对）urls 必须匹配才能提取。如果没有给出（或为空），它将匹配所有链接。
• deny（正则表达式或正则表达式列表） - 一个正则表达式（或正则表达式列表），（绝对）urls 必须匹配才能排除（即不提取）。它优先于 allow 参数。如果没有给出（或为空），它不会排除任何链接。
• allow_domains（str 或 list） - 单个值或包含将被考虑用于提取链接的域的字符串列表。
• deny_domains（str 或 list） - 单个值或包含不会被考虑用于提取链接的域的字符串列表。
• deny_extensions（list） - 包含在提取链接时，应该忽略的扩展的单个值或字符串列表。如果没有给出，它将默认为 IGNORED_EXTENSIONS 在 scrapy.linkextractors 包中定义的列表。
• restrict_xpaths（str 或 list） - 是一个 XPath（或 XPath 的列表），它定义响应中应提取链接的区域。如果给出，只有那些 XPath 选择的文本将被扫描链接。参见下面的例子。
• restrict_css（str 或 list） - 一个 CSS 选择器（或选择器列表），用于定义响应中应提取链接的区域。类似于 restrict_xpaths 参数。
• tags（str 或 list） - 提取链接时指定的标签集合。默认为 ('a', 'area')。
• attrs（list） - 在查找要提取的链接时，应该考虑的属性或属性列表（仅适用于参数中指定的那些标签 tags）。默认为 ('href',)。
• canonicalize（boolean） - 规范化每个提取的 url（使用 w3lib.url.canonicalize_url）。默认为 False。
• unique（boolean） - 是否开启去重，即对提取的链接是否应用重复过滤。默认为 True。
• strip（boolean） - 是否从提取的属性值中把地址前后多余的空格删除。默认为 True。
• process_value（callable） - 这个作用比较强大了，他接受一个函数，可以对提取到的内容进行自定义处理，默认为 None，即不指定处理函数，相当于 lambda x: x。

针对 process_value 参数的相关示例如下：

要针对如下标签提取链接：

<a href="javascript:goToPage('../other/page.html'); return false">Link text</a>

您可以使用如下自定义函数：

def process_value(value):
    m = re.search("javascript:goToPage\('(.*?)'", value)
    if m:
        return m.group(1)

CrawlSpider 示例

接下来给出配合 rule 使用 CrawlSpider 的例子：

import scrapy
from scrapy.spiders import CrawlSpider, Rule
from scrapy.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.logger.info('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

class scrapy.spiders.XMLFeedSpider

XMLFeedSpider 被设计用于通过迭代各个节点来分析 XML 源（XML feed）。迭代器可以从 iternodes，xml，html 选择。鉴于 xml 以及 html 迭代器需要先读取所有 DOM 再分析而引起的性能问题，一般还是推荐使用 iternodes。不过使用 html 作为迭代器能有效应对错误的 XML。

您必须定义下列类属性来设置迭代器以及标签名：

XMLFeedSpider 示例

该 spider 十分易用。下边是其中一个例子：

from scrapy.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):
        self.logger.info('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

class scrapy.spiders.CSVFeedSpider

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

CSVFeedSpider 示例

下面的例子和之前的例子很像，但使用了 CSVFeedSpider：

from scrapy.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 = ';'
    quotechar = "'"
    headers = ['id', 'name', 'description']

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

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

SitemapSpider

class scrapy.spiders.SitemapSpider

SitemapSpider 使您爬取网站时可以通过 Sitemaps 来发现爬取的 URL。

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

SitemapSpider 示例

使用 parse 处理通过 sitemap 发现的所有 url：

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