三、scrapy后续

CrawlSpiders

通过下面的命令可以快速创建 CrawlSpider模板 的代码：

scrapy genspider -t crawl tencent tencent.com

我们通过正则表达式，制作了新的url作为Request请求参数，现在我们可以用这个...

class scrapy.spiders.CrawlSpider

它是Spider的派生类，Spider类的设计原则是只爬取start_url列表中的网页，而CrawlSpider类定义了一些规则(rule)来提供跟进link的方便的机制，从爬取的网页中获取link并继续爬取的工作更适合。

在网上找了一段源码参考：

 class CrawlSpider(Spider):
     rules = ()
     def __init__(self, *a, **kw):
         super(CrawlSpider, self).__init__(*a, **kw)
         self._compile_rules()

     #首先调用parse()来处理start_urls中返回的response对象
     #parse()则将这些response对象传递给了_parse_response()函数处理，并设置回调函数为parse_start_url()
     #设置了跟进标志位True
     #parse将返回item和跟进了的Request对象
     def parse(self, response):
         return self._parse_response(response, self.parse_start_url, cb_kwargs={}, follow=True)

     #处理start_url中返回的response，需要重写
     def parse_start_url(self, response):
         return []

     def process_results(self, response, results):
         return results

     #从response中抽取符合任一用户定义'规则'的链接，并构造成Resquest对象返回
     def _requests_to_follow(self, response):
         if not isinstance(response, HtmlResponse):
             return
         seen = set()
         #抽取之内的所有链接，只要通过任意一个'规则'，即表示合法
         for n, rule in enumerate(self._rules):
             links = [l for l in rule.link_extractor.extract_links(response) if l not in seen]
             #使用用户指定的process_links处理每个连接
             if links and rule.process_links:
                 links = rule.process_links(links)
             #将链接加入seen集合，为每个链接生成Request对象，并设置回调函数为_repsonse_downloaded()
             for link in links:
                 seen.add(link)
                 #构造Request对象，并将Rule规则中定义的回调函数作为这个Request对象的回调函数
                 r = Request(url=link.url, callback=self._response_downloaded)
                 r.meta.update(rule=n, link_text=link.text)
                 #对每个Request调用process_request()函数。该函数默认为indentify，即不做任何处理，直接返回该Request.
                 yield rule.process_request(r)

     #处理通过rule提取出的连接，并返回item以及request
     def _response_downloaded(self, response):
         rule = self._rules[response.meta['rule']]
         return self._parse_response(response, rule.callback, rule.cb_kwargs, rule.follow)

     #解析response对象，会用callback解析处理他，并返回request或Item对象
     def _parse_response(self, response, callback, cb_kwargs, follow=True):
         #首先判断是否设置了回调函数。（该回调函数可能是rule中的解析函数，也可能是 parse_start_url函数）
         #如果设置了回调函数（parse_start_url()），那么首先用parse_start_url()处理response对象，
         #然后再交给process_results处理。返回cb_res的一个列表
         if callback:
             #如果是parse调用的，则会解析成Request对象
             #如果是rule callback，则会解析成Item
             cb_res = callback(response, **cb_kwargs) or ()
             cb_res = self.process_results(response, cb_res)
             for requests_or_item in iterate_spider_output(cb_res):
                 yield requests_or_item

         #如果需要跟进，那么使用定义的Rule规则提取并返回这些Request对象
         if follow and self._follow_links:
             #返回每个Request对象
             for request_or_item in self._requests_to_follow(response):
                 yield request_or_item

     def _compile_rules(self):
         def get_method(method):
             if callable(method):
                 return method
             elif isinstance(method, basestring):
                 return getattr(self, method, None)

         self._rules = [copy.copy(r) for r in self.rules]
         for rule in self._rules:
             rule.callback = get_method(rule.callback)
             rule.process_links = get_method(rule.process_links)
             rule.process_request = get_method(rule.process_request)

     def set_crawler(self, crawler):
         super(CrawlSpider, self).set_crawler(crawler)
         self._follow_links = crawler.settings.getbool('CRAWLSPIDER_FOLLOW_LINKS', True)

CrawlSpider继承于Spider类，除了继承过来的属性外（name、allow_domains），还提供了新的属性和方法:

LinkExtractors

class scrapy.linkextractors.LinkExtractor

Link Extractors 的目的很简单: 提取链接｡

每个LinkExtractor有唯一的公共方法是 extract_links()，它接收一个 Response 对象，并返回一个 scrapy.link.Link 对象。

Link Extractors要实例化一次，并且 extract_links 方法会根据不同的 response 调用多次提取链接｡

 class scrapy.linkextractors.LinkExtractor(
     allow = (),
     deny = (),
     allow_domains = (),
     deny_domains = (),
     deny_extensions = None,
     restrict_xpaths = (),
     tags = ('a','area'),
     attrs = ('href'),
     canonicalize = True,
     unique = True,
     process_value = None
 )

主要参数：

 allow：满足括号中“正则表达式”的值会被提取，如果为空，则全部匹配。

 deny：与这个正则表达式(或正则表达式列表)不匹配的URL一定不提取。

 allow_domains：会被提取的链接的domains。

 deny_domains：一定不会被提取链接的domains。

 restrict_xpaths：使用xpath表达式，和allow共同作用过滤链接。

rules

在rules中包含一个或多个Rule对象，每个Rule对爬取网站的动作定义了特定操作。如果多个rule匹配了相同的链接，则根据规则在本集合中被定义的顺序，第一个会被使用。

 class scrapy.spiders.Rule(
         link_extractor,
         callback = None,
         cb_kwargs = None,
         follow = None,
         process_links = None,
         process_request = None
 )

• link_extractor：是一个Link Extractor对象，用于定义需要提取的链接。

• callback： 从link_extractor中每获取到链接时，参数所指定的值作为回调函数，该回调函数接受一个response作为其第一个参数。

• follow：是一个布尔(boolean)值，指定了根据该规则从response提取的链接是否需要跟进。 如果callback为None，follow 默认设置为True ，否则默认为False。

• process_links：指定该spider中哪个的函数将会被调用，从link_extractor中获取到链接列表时将会调用该函数。该方法主要用来过滤。

• process_request：指定该spider中哪个的函数将会被调用， 该规则提取到每个request时都会调用该函数。 (用来过滤request)

注意：当编写爬虫规则时，避免使用parse作为回调函数。由于CrawlSpider使用parse方法来实现其逻辑，如果覆盖了 parse方法，crawl spider将会运行失败。

---

Logging

Scrapy提供了log功能，可以通过 logging 模块使用。

可以修改配置文件settings.py，任意位置添加下面两行，效果会清爽很多。

LOG_FILE = "TencentSpider.log"
LOG_LEVEL = "INFO"

Log levels

Scrapy提供5层logging级别:

• CRITICAL - 严重错误(critical)

• ERROR - 一般错误(regular errors)
• WARNING - 警告信息(warning messages)
• INFO - 一般信息(informational messages)
• DEBUG - 调试信息(debugging messages)

logging设置

通过在setting.py中进行以下设置可以被用来配置logging:

1. LOG_ENABLED 默认: True，启用logging
2. LOG_ENCODING 默认: 'utf-8'，logging使用的编码
3. LOG_FILE 默认: None，在当前目录里创建logging输出文件的文件名
4. LOG_LEVEL 默认: 'DEBUG'，log的最低级别
5. LOG_STDOUT 默认: False 如果为 True，进程所有的标准输出(及错误)将会被重定向到log中。例如，执行 print "hello" ，其将会在Scrapy log中显示。

---

Request

 # 部分代码
 class Request(object_ref):

     def __init__(self, url, callback=None, method='GET', headers=None, body=None,
                  cookies=None, meta=None, encoding='utf-8', priority=0,
                  dont_filter=False, errback=None):

         self._encoding = encoding  # this one has to be set first
         self.method = str(method).upper()
         self._set_url(url)
         self._set_body(body)
         assert isinstance(priority, int), "Request priority not an integer: %r" % priority
         self.priority = priority

         assert callback or not errback, "Cannot use errback without a callback"
         self.callback = callback
         self.errback = errback

         self.cookies = cookies or {}
         self.headers = Headers(headers or {}, encoding=encoding)
         self.dont_filter = dont_filter

         self._meta = dict(meta) if meta else None

     @property
     def meta(self):
         if self._meta is None:
             self._meta = {}
         return self._meta

部分源代码

其中，比较常用的参数：

url: 就是需要请求，并进行下一步处理的url

callback: 指定该请求返回的Response，由那个函数来处理。

method: 请求一般不需要指定，默认GET方法，可设置为"GET", "POST", "PUT"等，且保证字符串大写

headers: 请求时，包含的头文件。一般不需要。内容一般如下：
        # 自己写过爬虫的肯定知道
        Host: media.readthedocs.org
        User-Agent: Mozilla/5.0 (Windows NT 6.2; WOW64; rv:33.0) Gecko/20100101 Firefox/33.0
        Accept: text/css,*/*;q=0.1
        Accept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3
        Accept-Encoding: gzip, deflate
        Referer: http://scrapy-chs.readthedocs.org/zh_CN/0.24/
        Cookie: _ga=GA1.2.1612165614.1415584110;
        Connection: keep-alive
        If-Modified-Since: Mon, 25 Aug 2014 21:59:35 GMT
        Cache-Control: max-age=0

meta: 比较常用，在不同的请求之间传递数据使用的。字典dict型

        request_with_cookies = Request(
            url="http://www.example.com",
            cookies={'currency': 'USD', 'country': 'UY'},
            meta={'dont_merge_cookies': True}
        )

encoding: 使用默认的 'utf-8' 就行。

dont_filter: 表明该请求不由调度器过滤。这是当你想使用多次执行相同的请求,忽略重复的过滤器。默认为False。

errback: 指定错误处理函数

Response

 # 部分代码
 class Response(object_ref):
     def __init__(self, url, status=200, headers=None, body='', flags=None, request=None):
         self.headers = Headers(headers or {})
         self.status = int(status)
         self._set_body(body)
         self._set_url(url)
         self.request = request
         self.flags = [] if flags is None else list(flags)

     @property
     def meta(self):
         try:
             return self.request.meta
         except AttributeError:
             raise AttributeError("Response.meta not available, this response " \
                 "is not tied to any request")

部分

大部分参数和上面的差不多：

status: 响应码
_set_body(body)： 响应体
_set_url(url)：响应url
self.request = request

发送POST请求

• 可以使用 yield scrapy.FormRequest(url, formdata, callback)方法发送POST请求。

• 如果希望程序执行一开始就发送POST请求，可以重写Spider类的start_requests(self) 方法，并且不再调用start_urls里的url。

 class mySpider(scrapy.Spider):
     # start_urls = ["http://www.example.com/"]

     def start_requests(self):
         url = 'http://www.renren.com/PLogin.do'

         # FormRequest 是Scrapy发送POST请求的方法
         yield scrapy.FormRequest(
             url = url,
             formdata = {"email" : "mr_mao_hacker@163.com", "password" : "axxxxxxxe"},
             callback = self.parse_page
         )
     def parse_page(self, response):
         # do something

---

Downloader Middlewares

下载中间件是处于引擎(crawler.engine)和下载器(crawler.engine.download())之间的一层组件，可以有多个下载中间件被加载运行。

1. 当引擎传递请求给下载器的过程中，下载中间件可以对请求进行处理 （例如增加http header信息，增加proxy信息等）；

2. 在下载器完成http请求，传递响应给引擎的过程中， 下载中间件可以对响应进行处理（例如进行gzip的解压等）

要激活下载器中间件组件，将其加入到 DOWNLOADER_MIDDLEWARES 设置中。 该设置是一个字典(dict)，键为中间件类的路径，值为其中间件的顺序(order)。

这里是一个例子:

DOWNLOADER_MIDDLEWARES = {
    'mySpider.middlewares.MyDownloaderMiddleware': 543,
}

编写下载器中间件十分简单。每个中间件组件是一个定义了以下一个或多个方法的Python类:

class scrapy.contrib.downloadermiddleware.DownloaderMiddleware

process_request(self, request, spider)

• 当每个request通过下载中间件时，该方法被调用。

• process_request() 必须返回以下其中之一：一个 None 、一个 Response 对象、一个 Request 对象或 raise IgnoreRequest:

  • 如果其返回 None ，Scrapy将继续处理该request，执行其他的中间件的相应方法，直到合适的下载器处理函数(download handler)被调用， 该request被执行(其response被下载)。

  • 如果其返回 Response 对象，Scrapy将不会调用 任何 其他的 process_request() 或 process_exception() 方法，或相应地下载函数； 其将返回该response。 已安装的中间件的 process_response() 方法则会在每个response返回时被调用。

  • 如果其返回 Request 对象，Scrapy则停止调用 process_request方法并重新调度返回的request。当新返回的request被执行后， 相应地中间件链将会根据下载的response被调用。

  • 如果其raise一个 IgnoreRequest 异常，则安装的下载中间件的 process_exception() 方法会被调用。如果没有任何一个方法处理该异常， 则request的errback(Request.errback)方法会被调用。如果没有代码处理抛出的异常， 则该异常被忽略且不记录(不同于其他异常那样)。

• 参数:

  • request (Request 对象) – 处理的request
  • spider (Spider 对象) – 该request对应的spider

process_response(self, request, response, spider)

当下载器完成http请求，传递响应给引擎的时候调用

• process_request() 必须返回以下其中之一: 返回一个 Response 对象、 返回一个 Request 对象或raise一个 IgnoreRequest 异常。

  • 如果其返回一个 Response (可以与传入的response相同，也可以是全新的对象)， 该response会被在链中的其他中间件的 process_response() 方法处理。

  • 如果其返回一个 Request 对象，则中间件链停止， 返回的request会被重新调度下载。处理类似于 process_request() 返回request所做的那样。

  • 如果其抛出一个 IgnoreRequest 异常，则调用request的errback(Request.errback)。 如果没有代码处理抛出的异常，则该异常被忽略且不记录(不同于其他异常那样)。

• 参数:

  • request (Request 对象) – response所对应的request
  • response (Response 对象) – 被处理的response
  • spider (Spider 对象) – response所对应的spider

 # middlewares.py

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 import random
 import base64

 from settings import USER_AGENTS
 from settings import PROXIES

 # 随机的User-Agent
 class RandomUserAgent(object):
     def process_request(self, request, spider):
         useragent = random.choice(USER_AGENTS)

         request.headers.setdefault("User-Agent", useragent)

 class RandomProxy(object):
     def process_request(self, request, spider):
         proxy = random.choice(PROXIES)

         if proxy['user_passwd'] is None:
             # 没有代理账户验证的代理使用方式
             request.meta['proxy'] = "http://" + proxy['ip_port']
         else:
             # 对账户密码进行base64编码转换
             base64_userpasswd = base64.b64encode(proxy['user_passwd'])
             # 对应到代理服务器的信令格式里
             request.headers['Proxy-Authorization'] = 'Basic ' + base64_userpasswd
             request.meta['proxy'] = "http://" + proxy['ip_port']

设置中间插件

---

Settings

Scrapy设置(settings)提供了定制Scrapy组件的方法。可以控制包括核心(core)，插件(extension)，pipeline及spider组件。比如 设置Json Pipeliine、LOG_LEVEL等。

参考文档：http://scrapy-chs.readthedocs.io/zh_CN/1.0/topics/settings.html#topics-settings-ref

内置设置参考手册

• BOT_NAME

  • 默认: 'scrapybot'

  • 当您使用 startproject 命令创建项目时其也被自动赋值。

• CONCURRENT_ITEMS

  • 默认: 100

  • Item Processor(即 Item Pipeline) 同时处理(每个response的)item的最大值。

• CONCURRENT_REQUESTS

  • 默认: 16

  • Scrapy downloader 并发请求(concurrent requests)的最大值。

• DEFAULT_REQUEST_HEADERS

  • 默认: 如下

    {
    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
    'Accept-Language': 'en',
    }
    

    Scrapy HTTP Request使用的默认header。

• DEPTH_LIMIT

  • 默认: 0

  • 爬取网站最大允许的深度(depth)值。如果为0，则没有限制。

• DOWNLOAD_DELAY

  • 默认: 0

  • 下载器在下载同一个网站下一个页面前需要等待的时间。该选项可以用来限制爬取速度， 减轻服务器压力。同时也支持小数:

  DOWNLOAD_DELAY = 0.25 # 250 ms of delay

  • 默认情况下，Scrapy在两个请求间不等待一个固定的值， 而是使用0.5到1.5之间的一个随机值 * DOWNLOAD_DELAY 的结果作为等待间隔。

• DOWNLOAD_TIMEOUT

  • 默认: 180

  • 下载器超时时间(单位: 秒)。

• ITEM_PIPELINES

  • 默认: {}

  • 保存项目中启用的pipeline及其顺序的字典。该字典默认为空，值(value)任意，不过值(value)习惯设置在0-1000范围内，值越小优先级越高。

    ITEM_PIPELINES = {
    'mySpider.pipelines.SomethingPipeline': 300,
    'mySpider.pipelines.ItcastJsonPipeline': 800,
    }
    

• LOG_ENABLED

  • 默认: True

  • 是否启用logging。

• LOG_ENCODING

  • 默认: 'utf-8'

  • logging使用的编码。

• LOG_LEVEL

  • 默认: 'DEBUG'

  • log的最低级别。可选的级别有: CRITICAL、 ERROR、WARNING、INFO、DEBUG 。

• USER_AGENT

  • 默认: "Scrapy/VERSION (+http://scrapy.org)"

  • 爬取的默认User-Agent，除非被覆盖。

• PROXIES： 代理设置

  • 示例：

    PROXIES = [
      {'ip_port': '111.11.228.75:80', 'password': ''},
      {'ip_port': '120.198.243.22:80', 'password': ''},
      {'ip_port': '111.8.60.9:8123', 'password': ''},
      {'ip_port': '101.71.27.120:80', 'password': ''},
      {'ip_port': '122.96.59.104:80', 'password': ''},
      {'ip_port': '122.224.249.122:8088', 'password':''},
    ]
    

• COOKIES_ENABLED = False

  • 禁用Cookies

---

爬取腾讯招聘所有页面的职位信息

先想好需要什么信息：

 # -*- coding: utf-8 -*-

 # Define here the models for your scraped items
 #
 # See documentation in:
 # https://doc.scrapy.org/en/latest/topics/items.html

 import scrapy

 '''Item 定义结构化数据字段，用来保存爬取到的数据，有点像Python中的dict，但是提供了一些额外的保护减少错误。

 可以通过创建一个 scrapy.Item 类， 并且定义类型为 scrapy.Field的类属性来定义一个Item（可以理解成类似于ORM的映射关系）。'''
 class MyspiderItem(scrapy.Item):
     # define the fields for your item here like:
     #职位名
     name = scrapy.Field()
     #详细链接
     detailLink = scrapy.Field()
     #职位信息
     positionInfo = scrapy.Field()
     #人数
     peopleNumber = scrapy.Field()
     #工作地点
     workLocation = scrapy.Field()
     #发布时间
     publishTime = scrapy.Field()

items.py

写爬虫代码：(使用框架很简单，其实主要是提取数据）

 # -*- coding: utf-8 -*-
 import scrapy
 from myspider.items import MyspiderItem
 from scrapy.linkextractors import LinkExtractor
 from scrapy.spiders import CrawlSpider, Rule

 class TencentSpider(CrawlSpider):
     name = 'tencent'
     allowed_domains = ['tencent.com']
     start_urls = ['http://hr.tencent.com/position.php?&start=0#a']
     rules = (
         Rule(LinkExtractor(allow=r'position\.php\?&start=\d+'), callback='parse_item', follow=True),
     )

     def parse_item(self, response):
         #i = {}
         #i['domain_id'] = response.xpath('//input[@id="sid"]/@value').extract()
         #i['name'] = response.xpath('//div[@id="name"]').extract()
         #i['description'] = response.xpath('//div[@id="description"]').extract()
         #return i
         for each in response.xpath('//*[@class="even"]'):
             name = each.xpath('./td[1]/a/text()').extract()[0]
             detailLink = each.xpath('./td[1]/a/@href').extract()[0]
             positionInfo = each.xpath('./td[2]/text()').extract()[0]

             peopleNumber = each.xpath('./td[3]/text()').extract()[0]
             workLocation = each.xpath('./td[4]/text()').extract()[0]
             publishTime = each.xpath('./td[5]/text()').extract()[0]
             # print name, detailLink, catalog,recruitNumber,workLocation,publishTime

             item = MyspiderItem()
             item['name'] = name
             item['detailLink'] = detailLink
             item['positionInfo'] = positionInfo
             item['peopleNumber'] = peopleNumber
             item['workLocation'] = workLocation
             item['publishTime'] = publishTime

             yield item

Tencent.py

 import json

 class BaiSispiderPipeline():
     def __init__(self):
         self.filename = open("tencent.json", "w")

     def process_item(self, item, spider):
         text = json.dumps(dict(item), ensure_ascii = False) + ",\n"
         self.filename.write(text.encode('utf8'))
         return item

     def close_spider(self, spider):
         self.filename.close()

Pipelines.py

之前爬取校花网图片的那个，用CrawlSpider，几行代码就可以匹配到所有页面的链接，自己有去重的功能，爬取多页乃至全部

 # -*- coding: utf-8 -*-
 import scrapy
 from scrapy.linkextractors import LinkExtractor
 from scrapy.spiders import CrawlSpider,Rule
 from myspider.items import MyspiderItem

 class BaisiSpider(CrawlSpider):
     name = 'xiaohua'
     allowed_domains = ['www.521609.com']
     page_list = LinkExtractor(allow=('list\\d+\.html'))
     start_urls = ['http://www.521609.com/daxuexiaohua/list35.html']
     rules = (
         Rule(page_list,callback='parseImg',follow=True),
     )
     def parseImg(self, response):

         # 将我们得到的数据封装到一个 `MyspiderItem` 对象
         item = MyspiderItem()

         #提取数据
         img_list = response.xpath('//div[@class="index_img list_center"]/ul/li')
         for img in img_list:
             img_name = img.xpath('./a/img/@alt')[0].extract()
             img_url = img.xpath('./a/img/@src')[0].extract()
             item['img_name'] = img_name
             item['img_url'] = img_url

             # 将获取的数据交给pipelines
             yield item

xiaohua.py