python(scrapy爬虫架构)

scrapy爬虫的基本流程：

• 确定url地址:http://www.imooc.com/course/list;(spider)
• 获取页面信息;(urllib, requests); —(scrapy中我们不要处理)—(Downloader)
• 解析页面提取需要的数据； (正则表达式， bs4， xpath)—: (spider)
  课程链接， 课程的图片url， 课程的名称， 学习人数， 课程描述
• 保存到本地(csv, json, pymysql, redis); ----(pipeline)

scrapy安装和使用

安装

# 在当前pycharm导入的虚拟环境中pip install scrapy

使用

在scrapy框架中，只需要用户自己编写解析方法和管道方法，爬取网页的任务scrapy会自动完成

# 创建scrapy项目工程
scrapy startproject mySpider

# 进入到该工程中生成一个爬虫任务
scrapy genspider mooc 'www.imooc.com'

scrapy框架的构建

1.在items.py文件的类中定义变量，该MyspiderItem类类似于字典，该变量类似于字典的key值，用来在Spider和Pipline之间的数据传输，

import scrapy


class CourseItem(scrapy.Item):
    # Item对象是一个简单容器， 保存爬取到的数据, 类似于字典的操作;
    # 实例化对象: course =  CourseItem()
    # course['title'] = "语文"
    # course['title']
    # course.keys()
    # course.values()
    # course.items()
    # define the fields for your item here like:
    # name = scrapy.Field()
    # 课程链接， 课程的图片url， 课程的名称， 学习人数， 课程描述
    # 课程标题
    title = scrapy.Field()
    # 课程的url地址
    url = scrapy.Field()
    # 课程图片url地址
    image_url = scrapy.Field()
    # 课程的描述
    introduction = scrapy.Field()
    # 学习人数
    student = scrapy.Field()

2.在mooc.py文件中定义parser解析方法，对获取的reponse对象进行解析

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

from mySpider.items import CourseItem



class MoocSpider(scrapy.Spider):
    # name: 用于区别爬虫, 必须是唯一的；
    name = 'mooc'
    # 允许爬取的域名；其他网站的页面直接跳过;
    allowed_domains = ['www.imooc.com', 'img3.mukewang.com']
    # 爬虫开启时第一个放入调度器的url地址;
    start_urls = ['http://www.imooc.com/course/list']

    # 被调用时， 每个出世url完成下载后， 返回一个响应对象,
    # 负责将响应的数据分析， 提取需要的数据items以及生成下一步需要处理的url地址请求;
    def parse(self, response):

        # 分析响应的内容
        # scrapy分析页面使用的是xpath语法
        # 1). 获取每个课程的信息: <div class="course-card-container">
        courseDetails = response.xpath('//div[@class="course-card-container"]')
        for courseDetail in courseDetails:
            
            # 课程的名称：
            # "htmlxxxx"
            
			# 2). 实例化对象， CourseItem
        	course = CourseItem()
        	
            # 爬取新的网站， Scrapy里面进行调试(parse命令logging)
            course['title'] = courseDetail.xpath('.//h3[@class="course-card-name"]/text()').extract()[0]
            # 学习人数
            course['student'] = courseDetail.xpath('.//span/text()').extract()[1]
            # 课程描述:
            course['introduction'] = courseDetail.xpath(".//p[@class='course-card-desc']/text()").extract()[0]
            # 课程链接， h获取/learn/9 ====》 http://www.imooc.com/learn/9
            course['url'] = "http://www.imooc.com" + courseDetail.xpath('.//a/@href').extract()[0]
            # 课程的图片url:
            course['image_url'] = 'http:' + courseDetail.xpath('.//img/@src').extract()[0]
			# 生成器，每产生一个数据就通过course对象传送给管道对象
			# 当管道对象处理完数据后返回item对象告诉调度器，让调度器启动生成器继续解析文本
            yield  course

3.在pipelines.py文件中定义存储方式

import json
class MyspiderPipeline(object):
    """将爬取的信息保存为Json格式"""
    def __init__(self):
        self.f = open(MOOCFilename, 'w')

    def process_item(self, item, spider):
        # 默认传过来的item是json格式
        import json
        # 读取item中的数据， 并转成json格式;
        line = json.dumps(dict(item), ensure_ascii=False, indent=4)
        self.f.write(line + '\n')
        # 一定要加， 返回给调度为器；
        return item
    def open_spider(self, spider):
        """开启爬虫时执行的函数"""
        pass

    def close_spider(self, spider):
        """当爬虫全部爬取结束的时候执行的函数"""
        self.f.close()

在这里插入代码片

# 保存每门课程的图片
import  scrapy

# scrapy框架里面，
class ImagePipeline(ImagesPipeline):
    def get_media_requests(self, item, info):
        # 返回一个request请求， 包含图片的url地址
        yield  scrapy.Request(item['image_url'])

    # 当下载请求完成后执行的函数/方法
    def item_completed(self, results, item, info):

        # open('mooc.log', 'w').write(results)
        #  获取下载的地址
        image_path = [x['path'] for ok,x in results if ok]
        if not image_path:
            raise  Exception("不包含图片")
        else:
            # img_path[0]表示的是图片的文件名
            # 可通过os模块来重写图片的文件名
            import os
            os.rename(IMAGES_STORE+img_path[0],IMAGES_STORE+item['title']+'.jpg')
            return  item

4.在settings.py文件中配置并开启管道

ITEM_PIPELINES = {
	# 管道的位置: 优先级， 0～1000, 数字越小， 优先级越高;
   'mySpider.pipelines.MyspiderPipeline': 300,
   'mySpider.pipelines.ImgPipeline': 400
}
# 图片保存在的本地路径
IMAGES_STORE='/home/kiosk/PycharmProjects/test/img/'

5.在shell环境中启动爬虫任务

scrapy crawl mooc

获取下一页的链接并且执行解析函数

在原有的解析函数中改进

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

from mySpider.items import CourseItem



class MoocSpider(scrapy.Spider):
    # name: 用于区别爬虫, 必须是唯一的；
    name = 'mooc'
    # 允许爬取的域名；其他网站的页面直接跳过;
    allowed_domains = ['www.imooc.com', 'img3.mukewang.com']
    # 爬虫开启时第一个放入调度器的url地址;
    start_urls = ['http://www.imooc.com/course/list']

    # 被调用时， 每个出世url完成下载后， 返回一个响应对象,
    # 负责将响应的数据分析， 提取需要的数据items以及生成下一步需要处理的url地址请求;
    def parse(self, response):

        
        # 分析响应的内容
        # scrapy分析页面使用的是xpath语法
        # 1). 获取每个课程的信息: <div class="course-card-container">
        courseDetails = response.xpath('//div[@class="course-card-container"]')
        for courseDetail in courseDetails:
            
            # 课程的名称：
            # "htmlxxxx"
            
			# 2). 实例化对象， CourseItem
        	course = CourseItem()
        	
            # 爬取新的网站， Scrapy里面进行调试(parse命令logging)
            course['title'] = courseDetail.xpath('.//h3[@class="course-card-name"]/text()').extract()[0]
            # 学习人数
            course['student'] = courseDetail.xpath('.//span/text()').extract()[1]
            # 课程描述:
            course['introduction'] = courseDetail.xpath(".//p[@class='course-card-desc']/text()").extract()[0]
            # 课程链接， h获取/learn/9 ====》 http://www.imooc.com/learn/9
            course['url'] = "http://www.imooc.com" + courseDetail.xpath('.//a/@href').extract()[0]
            # 课程的图片url:
            course['image_url'] = 'http:' + courseDetail.xpath('.//img/@src').extract()[0]
			# 生成器，每产生一个数据就通过course对象传送给管道对象
			# 当管道对象处理完数据后返回item对象告诉调度器，让调度器启动生成器继续解析文本
            yield  course

			# url跟进, 获取下一页是否有链接;href
            nextPage=response.xpath('//a[contains(text(),"下一页")]/@href')
            if nextPage:
                # 构建新的url地址
                url='http://www.imooc.com'+nextPage[0].extract()
                yield scrapy.Request(url,callback=self.parse)

在scrapy框架中设置调试断点

在解析函数中设置调试断点

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

from mySpider.items import CourseItem



class MoocSpider(scrapy.Spider):
    # name: 用于区别爬虫, 必须是唯一的；
    name = 'mooc'
    # 允许爬取的域名；其他网站的页面直接跳过;
    allowed_domains = ['www.imooc.com', 'img3.mukewang.com']
    # 爬虫开启时第一个放入调度器的url地址;
    start_urls = ['http://www.imooc.com/course/list']

    # 被调用时， 每个出世url完成下载后， 返回一个响应对象,
    # 负责将响应的数据分析， 提取需要的数据items以及生成下一步需要处理的url地址请求;
    def parse(self, response):

        # # 用来检测代码是否达到指定位置， 并用来调试并解析页面信息;
        from scrapy.shell import  inspect_response
     	inspect_response(response, self)

        
        # 分析响应的内容
        # scrapy分析页面使用的是xpath语法
        # 1). 获取每个课程的信息: <div class="course-card-container">
        courseDetails = response.xpath('//div[@class="course-card-container"]')
        for courseDetail in courseDetails:
            
            # 课程的名称：
            # "htmlxxxx"
            
			# 2). 实例化对象， CourseItem
        	course = CourseItem()
        	
            # 爬取新的网站， Scrapy里面进行调试(parse命令logging)
            course['title'] = courseDetail.xpath('.//h3[@class="course-card-name"]/text()').extract()[0]
            # 学习人数
            course['student'] = courseDetail.xpath('.//span/text()').extract()[1]
            # 课程描述:
            course['introduction'] = courseDetail.xpath(".//p[@class='course-card-desc']/text()").extract()[0]
            # 课程链接， h获取/learn/9 ====》 http://www.imooc.com/learn/9
            course['url'] = "http://www.imooc.com" + courseDetail.xpath('.//a/@href').extract()[0]
            # 课程的图片url:
            course['image_url'] = 'http:' + courseDetail.xpath('.//img/@src').extract()[0]
			# 生成器，每产生一个数据就通过course对象传送给管道对象
			# 当管道对象处理完数据后返回item对象告诉调度器，让调度器启动生成器继续解析文本
            yield  course

添加完调试断点后执行爬虫任务

在shell环境中会出现一些用户可以操作的对象，可供用户进行调试代码

个人博客的整理

在spider爬虫任务中的parse方法内

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

from mySpider.items import CsdnItem


class CsdnSpider(scrapy.Spider):
    name = 'csdn'
    allowed_domains = ['blog.csdn.net']
    start_urls = ['http://blog.csdn.net/qq_43194257']

    def parse(self, response):

        divs=response.xpath('//div[@class="article-item-box csdn-tracking-statistics"]')
        for div in divs[1:]:
            item = CsdnItem()
            item['title']=div.xpath('.//h4/a/text()')[1].extract()
            item['url']=div.xpath('.//h4/a/@href')[0].extract()
			# 通过scrapy.Request函数从获取的博客地址链接中
            # 将获得的内容通过自己定义的解析函数进行解析
            # meta表示传递给callback的函数的参数
            yield scrapy.Request(item['url'],meta={'item':item},callback=self.parser_content)


    def parser_content(self,response):

        content=response.xpath('//div[@class="blog-content-box"]').extract()[0]
        # 定义传递的item参数
        item=response.request.meta['item']
        # 将解析好的内容传给item对象中的content
        item['content']=content
        # 最后将获取完所有值的item对象传递给调度器
        return item

在pipelines.py文件中定义存储方式

import scrapy

from mySpider.settings import IMAGES_STORE


class CsvPipeline(object):
    def __init__(self):
        self.f=open('csdn.csv','w')

    def process_item(self, item, spider):
        item=dict(item)
        info="{0}:{1}".format(item['title'],item['url'])
        self.f.write(info+'\n')

        return item

    def open_spider(self,spider):
        pass

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

在settings.py文件中配置并开启管道

ITEM_PIPELINES = {
   'mySpider.pipelines.CsvPipeline': 300,
}

scrapy反爬虫_设置中间件

策略一：设置download_delay

• 作用:设置下载的等待时间，大规模集中的访问对服务器的影响最大，相当与短时间中增大服务器负载。

• 缺点: 下载等待时间长，不能满足段时间大规模抓取的要求，太短则大大增加了被ban的几率

策略二：禁止cookies

• Cookie，有时也用其复数形式 Cookies，指某些网站为了辨别用户身份、进行 session跟踪而储存在用户本地终端上的数据（通常经过加密）。
• 作用: 禁止cookies也就防止了可能使用cookies识别爬虫轨迹的网站得逞。
• 实现: COOKIES_ENABLES=False

策略三：使用user agent池(拓展: 用户代理中间件)

• 为什么使用? scrapy本身是使用Scrapy/0.22.2来表明自己身份的。这也就暴露了自己是爬虫的信息。
• user agent，是指包含浏览器信息、操作系统信息等的一个字符串，也称之为一种特殊的网络协议。服务器通过它判断当前访问对象是浏览器、邮件客户端还是网络爬虫。

策略四：使用代理IP中间件

web server应对爬虫的策略之一就是直接将你的IP或者是整个IP段都封掉禁止访问，
这时候，当IP封掉后，转换到其他的IP继续访问即可。

策略五: 分布式爬虫Scrapy+Redis+MySQL # 多进程

Scrapy-Redis则是一个基于Redis的Scrapy分布式组件。它利用Redis对用于爬取的请求(Requests)进行存储和调度(Schedule)，并对爬取产生rapy一些比较关键的代码，将scrapy变成一个可以在多个主机上同时运行的分布式爬虫。

在scrapy框架中有settings.py文件,在该文件中可以配置相应的设置

• 设置DOWNLOAD_DELAY = 3,
  设置下载的等待时间；每下载一个页面， 等待xxx秒。
• 禁止cookie信息；
  Disable cookies (enabled by default)
  COOKIES_ENABLED = False
• 设置用户代理
  USER_AGENT = ‘Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Firefox/45.0’
• 设置User-Agent的中间键
• 设置代理IP的中间键
  DOWNLOADER_MIDDLEWARES = {
  ‘mySpider.middlewares.MyspiderDownloaderMiddleware’: 543,
  ‘mySpider.middlewares.UserAgentMiddleware’: 200,
  ‘mySpider.middlewares.ProxiesMiddleware’: 300

}

在scrapy框架中有middlewares.py文件，在该文件中设置相应的中间件

1.设置user agent池

import random

from scrapy import signals



class UserAgentMiddleware(object):
    def __init__(self):
        # 设置user agent池
        self.user_agent=[
            "Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Firefox/45.0",
            "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.109 Safari/537.36"
        ]
    def process_request(self,request,spider):
    	 # 每次访问网站时会随机选取user agent池中的用户代理设置成头部信息
        user_agent=random.choice(self.user_agent)
        if user_agent:
        	# 此行仅为了测试, 真实场景不要打印， 会影响爬虫的效率
            print('当前用户的代理为：%s' %(user_agent))
        request.headers.setdefault('User-Agent',user_agent)

在settings.py文件中开启中间件配置

DOWNLOADER_MIDDLEWARES = {
   'mySpider.middlewares.MyspiderDownloaderMiddleware': 543,
   'mySpider.middlewares.UserAgentMiddleware': 200,
}

执行结果:

2.设置代理ip

class ProxiesMiddleware(object):
    def __init__(self):
       

        self.proxies = [
            'http://116.209.54.221:9999',
            "https://111.177.183.212:9999"
        ]
    def process_request(self, request, spider):
        """当发起请求"""
        # 3). 从ip池里面随即获取一个代理IP；
        proxy = random.choice(self.proxies)

        if proxy:
            # 此行仅为了测试, 真实场景不要打印， 会影响爬虫的效率
            # print("当前使用的代理IP： %s" %(proxy))
            request.meta['proxy'] = proxy

在settings.py文件中开启中间件配置

DOWNLOADER_MIDDLEWARES = {
   'mySpider.middlewares.MyspiderDownloaderMiddleware': 543,
   'mySpider.middlewares.ProxiesMiddleware': 300
}

执行结果: