二、Item Pipeline和Spider-----基于scrapy取校花网的信息

Item Pipeline

当Item在Spider中被收集之后，它将会被传递到Item Pipeline，这些Item Pipeline组件按定义的顺序处理Item。

每个Item Pipeline都是实现了简单方法的Python类，比如决定此Item是丢弃而存储。以下是item pipeline的一些典型应用：

• 验证爬取的数据(检查item包含某些字段，比如说name字段)
• 查重(并丢弃)
• 将爬取结果保存到文件或者数据库中

编写item pipeline

编写item pipeline很简单，item pipiline组件是一个独立的Python类，其中process_item()方法必须实现

 class SomethingPipeline(object):
     def __init__(self):
         # 可选实现，做参数初始化等
         # doing something

     def process_item(self, item, spider):
         # item (Item 对象) – 被爬取的item
         # spider (Spider 对象) – 爬取该item的spider
         # 这个方法必须实现，每个item pipeline组件都需要调用该方法，
         # 这个方法必须返回一个 Item 对象，被丢弃的item将不会被之后的pipeline组件所处理。
         return item

     def open_spider(self, spider):
         # spider (Spider 对象) – 被开启的spider
         # 可选实现，当spider被开启时，这个方法被调用。

     def close_spider(self, spider):
         # spider (Spider 对象) – 被关闭的spider
         # 可选实现，当spider被关闭时，这个方法被调用

启用一个Item Pipeline组件

为了启用Item Pipeline组件，必须将它的类添加到 settings.py文件ITEM_PIPELINES 配置，就像下面这个例子:

 # See http://scrapy.readthedocs.org/en/latest/topics/item-pipeline.html
 ITEM_PIPELINES = {
     #'mySpider.pipelines.SomePipeline': 300,
     "mySpider.pipelines.ItcastJsonPipeline":300
 }

分配给每个类的整型值，确定了他们运行的顺序，item按数字从低到高的顺序，通过pipeline，通常将这些数字定义在0-1000范围内（0-1000随意设置，数值越低，组件的优先级越高）。

Spider

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

class scrapy.Spider是最基本的类，所有编写的爬虫必须继承这个类。

__init__() : 初始化爬虫名字和start_urls列表

start_requests() 调用make_requests_from url():生成Requests对象交给Scrapy下载并返回response

parse() : 解析response，并返回Item或Requests（需指定回调函数）。Item传给Item pipline持久化 ， 而Requests交由Scrapy下载，并由指定的回调函数处理（默认parse())，一直进行循环，直到处理完所有的数据为止。

 # -*- coding: utf-8 -*-
 import scrapy

 class BaiduSpider(scrapy.Spider):
     name = 'baidu'
     allowed_domains = ['baidu.com']
     start_urls = ['http://baidu.com/']

     def parse(self, response):
         pass

 源码：

  1 class Spider(object_ref):
     """Base class for scrapy spiders. All spiders must inherit from this
     class.
     """
     # 定义spider名字的字符串(string)。spider的名字定义了Scrapy如何定位(并初始化)spider，所以其必须是唯一的。
     # name是spider最重要的属性，而且是必须的。
     # 一般做法是以该网站(domain)(加或不加 后缀 )来命名spider。

     name = None
     custom_settings = None

     # 初始化，提取爬虫名字，start_ruls
     def __init__(self, name=None, **kwargs):
         if name is not None:
             self.name = name
         # 如果爬虫没有名字，中断后续操作则报错
         elif not getattr(self, 'name', None):
             raise ValueError("%s must have a name" % type(self).__name__)

         # python 对象或类型通过内置成员__dict__来存储成员信息
         self.__dict__.update(kwargs)

         # URL列表。当没有指定的URL时，spider将从该列表中开始进行爬取。 因此，第一个被获取到的页面的URL将是该列表之一。 后续的URL将会从获取到的数据中提取。
         if not hasattr(self, 'start_urls'):
             self.start_urls = []

     @property
     def logger(self):
         logger = logging.getLogger(self.name)
         return logging.LoggerAdapter(logger, {'spider': self})

     #打印Scrapy执行后的log信息
     def log(self, message, level=logging.DEBUG, **kw):
         """Log the given message at the given log level

         This helper wraps a log call to the logger within the spider, but you
         can use it directly (e.g. Spider.logger.info('msg')) or use any other
         Python logger too.
         """
         self.logger.log(level, message, **kw)

     @classmethod
     def from_crawler(cls, crawler, *args, **kwargs):
         spider = cls(*args, **kwargs)
         spider._set_crawler(crawler)
         return spider

     # 判断对象object的属性是否存在，不存在做断言处理
     def set_crawler(self, crawler):
         warnings.warn("set_crawler is deprecated, instantiate and bound the "
                       "spider to this crawler with from_crawler method "
                       "instead.",
                       category=ScrapyDeprecationWarning, stacklevel=2)
         assert not hasattr(self, 'crawler'), "Spider already bounded to a " \
                                              "crawler"
         self._set_crawler(crawler)

     def _set_crawler(self, crawler):
         self.crawler = crawler
         self.settings = crawler.settings
         crawler.signals.connect(self.close, signals.spider_closed)

     # 该方法将读取start_urls内的地址，并为每一个地址生成一个Request对象，交给Scrapy下载并返回Response
     def start_requests(self):
         cls = self.__class__
         if method_is_overridden(cls, Spider, 'make_requests_from_url'):
             warnings.warn(
                 "Spider.make_requests_from_url method is deprecated; it "
                 "won't be called in future Scrapy releases. Please "
                 "override Spider.start_requests method instead (see %s.%s)." % (
                     cls.__module__, cls.__name__
                 ),
             )
             for url in self.start_urls:
                 yield self.make_requests_from_url(url)
         else:
             for url in self.start_urls:
                 yield Request(url, dont_filter=True)

     # start_requests()中调用，实际生成Request的函数。
     # Request对象默认的回调函数为parse()，提交的方式为get
     def make_requests_from_url(self, url):
         """ This method is deprecated. """
         return Request(url, dont_filter=True)

     # 默认的Request对象回调函数，处理返回的response。
     # 生成Item或者Request对象。用户必须实现这个类
     def parse(self, response):
         raise NotImplementedError('{}.parse callback is not defined'.format(self.__class__.__name__))

     @classmethod
     def update_settings(cls, settings):
         settings.setdict(cls.custom_settings or {}, priority='spider')

     @classmethod
     def handles_request(cls, request):
         return url_is_from_spider(request.url, cls)

     @staticmethod
     def close(spider, reason):
         closed = getattr(spider, 'closed', None)
         if callable(closed):
             return closed(reason)

     def __str__(self):
         return "<%s %r at 0x%0x>" % (type(self).__name__, self.name, id(self))

     __repr__ = __str__

每天 一个小实例：（我取得是图片和图片名）

 items.py

 # -*- 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:
     img_name = scrapy.Field()
     img_url = scrapy.Field()

 xiaohua.py

 # -*- coding: utf-8 -*-
 import scrapy
 from myspider.items import MyspiderItem

 class BaisiSpider(scrapy.Spider):
     name = 'xiaohua'
     allowed_domains = ['www.521609.com']
     start_urls = ['http://www.521609.com/daxuexiaohua/list31.html']
     #   page = 31
     def parse(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

         # if self.page < 35:
         #     self.page += 1
         #     curpage_url = 'http://www.521609.com/daxuexiaohua/list' + str(self.page) + '.html'
         #
         #  # 发送新的url请求加入待爬队列，并调用回调函数 self.parse
         #     yield scrapy.Request(curpage_url, callback=self.parse)

 pipelines.py

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

 # Define your item pipelines here
 #
 # Don't forget to add your pipeline to the ITEM_PIPELINES setting
 # See: https://doc.scrapy.org/en/latest/topics/item-pipeline.html
 import urllib.request
 import os
 class BaiSispiderPipeline():

     def process_item(self, item, spider):
         base_url = 'http://www.521609.com'
         file_name = item['img_name'] + '.png'
         file_path = os.path.join("F:\\myspider\\myspider\\imgs", file_name)
         if item['img_url']:
              urllib.request.urlretrieve(base_url + item['img_url'],file_path)
         # with open(file_path, 'wb') as file:
         #     # 2. 获取图片里的内容
         #     images = requests.get(base_url + item['img_url'])
         #
         #     # 3. 调用文件对象write() 方法，将page_html的内容写入到文件里
         #     file.write(images.content)
         return item

结果：