python学习笔记(scrapy)

scrapy架构流程

• Scrapy,Python开发的一个快速、高层次的屏幕抓取和web抓取框架,用
于抓取web站点并从页面中提取结构化的数据。
• Scrapy吸引人的地方在于它是一个框架,任何人都可以根据需求方便的修改。
它也提供了多种类型爬虫的基类,如BaseSpider、sitemap爬虫等,最新版
本又提供了web2.0爬虫的支持。
• Scrap,是碎片的意思,这个Python的爬虫框架叫Scrapy。
优势:

1. 用户只需要定制开发几个模块, 就可以轻松实现爬虫, 用来抓取 网页内容和图片, 非常方便;
2. Scrapy使用了Twisted异步网络框架来处理网络通讯, 加快网页 下载速度, 不需要自己实现异步框架和多线程等, 并且包含了各
   种中间件接口, 灵活完成各种需求
   
   Scrapy主要包括了以下组件:
   • 引擎(Scrapy):
   用来处理整个系统的数据流, 触发事务(框架核心)
   • 调度器(Scheduler):
   用来接受引擎发过来的请求, 压入队列中, 并在引擎再次请求的时候返
   回. 可以想像成一个URL(抓取网页的网址或者说是链接)的优先队列, 由它来决定下一个要抓取的
   网址是什么, 同时去除重复的网址
   • 下载器(Downloader):
   用于下载网页内容, 并将网页内容返回给蜘蛛(Scrapy下载器是建立
   在twisted这个高效的异步模型上的)
   • 爬虫(Spiders):
   爬虫是主要干活的, 用于从特定的网页中提取自己需要的信息, 即所谓的实体
   (Item)。用户也可以从中提取出链接,让Scrapy继续抓取下一个页面
   • 项目管道(Pipeline): 负责处理爬虫从网页中抽取的实体,主要的功能是持久化实体、验证实
   体的有效性、清除不需要的信息。当页面被爬虫解析后,将被发送到项目管道,并经过几个特定的
   次序处理数据。
   • 下载器中间件(Downloader Middlewares):
   位于Scrapy引擎和下载器之间的框架,
   主要是处理Scrapy引擎与下载器之间的请求及响应。
   • 爬虫中间件(Spider Middlewares): 介于Scrapy引擎和爬虫之间的框架,主要工作是处
   理蜘蛛的响应输入和请求输出
   • 调度中间件(Scheduler Middewares):
   介于Scrapy引擎和调度之间的中间件,从
   Scrapy引擎发送到调度的请求和响应。

使用

# 爬取的步骤
    - 确定url地址;
    - 获取页面信息;(urllib, requests);
    - 解析页面提取需要的数据； (正则表达式， bs4， xpath)
    - 保存到本地(csv, json, pymysql, redis);
    - 清洗数据(删除不必要的内容 -----正则表达式);
    - 分析数据(词云wordcloud + jieba)

有没有用到多线程?    -----
获取页面信息每个爬虫都会使用， 重复去写----
设置头部信息 ---- user-agent, proxy....





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



# 环境
    - Scrapy 1.6.0




# 实现步骤：
1. 工程创建
 scrapy  startproject mySpider
 cd mySpider
 tree
├── mySpider
│   ├── __init__.py
│   ├── items.py            # 提取的数据信息
│   ├── middlewares.py      # 中间键
│   ├── pipelines.py        # 管道， 如何存储数据
│   ├── __pycache__
│   ├── settings.py         # 设置信息
│   └── spiders             # 爬虫(解析页面的信息)
│       ├── __init__.py
│       └── __pycache__
└── scrapy.cfg



2. 创建一个爬虫
scrapy  genspider  mooc "www.imooc.com"
cd mySpider/spiders/
vim mooc.py
# start_url



3. 定义爬取的items内容
class CourseItem(scrapy.Item):
    # 课程标题
    title = scrapy.Field()
    # 课程的url地址
    url = scrapy.Field()
    # 课程图片url地址
    image_url = scrapy.Field()
    # 课程的描述
    introduction = scrapy.Field()
    # 学习人数
    student = scrapy.Field()



# 4. 编写spider代码, 解析

新建项目

明确目标

1.在items.py中定义变量
用于保存爬取到的数据，类似于python中的字典，提供了额外的一些保护

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.定义解析方法
name = “” ：这个爬虫的识别名称，必须是唯一的，在不同的爬虫必须定义不同的名字。

allow_domains = [] 是搜索的域名范围，也就是爬虫的约束区域，规定爬虫只爬取这个域名下的网页，不存在的URL会被忽略。

start_urls = () ：爬取的URL元祖/列表。爬虫从这里开始抓取数据，所以，第一次下载的数据将会从这些urls开始。其他子URL将会从这些起始URL中继承性生成。

parse(self, response) ：解析的方法，每个初始URL完成下载后将被调用，调用的时候传入从每一个URL传回的Response对象来作为唯一参数，主要作用如下：

负责解析返回的网页数据(response.body)，提取结构化数据(生成item)
生成需要下一页的URL请求

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

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)

        # 1). 实例化对象， CourseItem
        course = CourseItem()
        # 分析响应的内容
        # scrapy分析页面使用的是xpath语法
        # 2). 获取每个课程的信息: 

        courseDetails = response.xpath('//div[@class="course-card-container"]')
        for courseDetail in courseDetails:
            # 课程的名称：
            # "htmlxxxx"


            # 爬取新的网站， 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]

            yield  course

储存数据

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

from  scrapy.pipelines.images import ImagesPipeline

from teach.day29.mySpider.mySpider.settings import MOOCFilename


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:
            return  item

开启管道

MOOCFilename =  "mooc.txt"
ITEM_PIPELINES = {
    # 管道的位置: 优先级， 0～1000, 数字越小， 优先级越高;
   'mySpider.pipelines.MyspiderPipeline': 300,
   'mySpider.pipelines.CsvPipeline': 400,
   'mySpider.pipelines.MysqlPipeline': 500,
   'mySpider.pipelines.ImagePipeline': 200,

}


IMAGES_STORE =  '/root/PycharmProjects/day29/mySpider/img'

获取下一页再执行parse函数

import scrapy

from mySpider.items import CourseItem


class MoocSpider(scrapy.Spider):
    name = 'mooc'
    allowed_domains = ['www.imooc.com']
    start_urls = ['http://www.imooc.com/course/list']
    def parse(self, response):
        #断点调试
        # from scrapy.shell import inspect_response
        # inspect_response(response,self)

        courseDetails = response.xpath('//div[@class="course-card-container"]')
        for courseDetail in courseDetails:
            course = CourseItem()
            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]
            course['url'] = 'http://www.imooc.com'+courseDetail.xpath('.//a/@href').extract()[0]
            course['image_url'] = 'http:'+courseDetail.xpath('.//img/@src').extract()[0]

            yield course

            #
            url = response.xpath('.//a[contains(text(),"下一页")]/@href')[0].extract()
            if url:
                page = 'http://www.imooc.com'+url
                yield scrapy.Request(page,callback=self.parse)

个人博客整理

解析

import scrapy
from scrapy.shell import inspect_response

from mySpider.items import csdnItem
from mySpider.settings import CsdnPage


class CsdnSpider(scrapy.Spider):
    name = 'csdn'
    allowed_domains = ['csdn.net']
    start_urls = [
        'https://blog.csdn.net/mkgdjing',
        # 'https://blog.csdn.net/gf_lvah',
    ]

    def parse(self, response):
        # 类似于字典的对象

        boxs = response.xpath('//div[@class="article-item-box csdn-tracking-statistics"]')

        for box in boxs:
            # 打印仅为了测试;
            # ************将item对象实例化在for循环里面， 否则每次会覆盖之前item的信息;*******
            item = csdnItem()
            item['title'] = box.xpath('./h4/a/text()')[1].extract().strip()
            item['url'] = box.xpath('./h4/a/@href')[0].extract()
            # print("1. *****************", item['title'])
            yield scrapy.Request(item['url'], meta={'item': item}, callback=self.parse_article)


        for page in range(2, 3):
            url = "https://blog.csdn.net/mkgdjing/article/list/%s" %(page)
            yield  scrapy.Request(url, callback=self.parse)

    def parse_article(self, response):
        item = response.request.meta['item']
        # 打印仅仅为了测试:出现问题的部分.
        # print("2.************************", item['title'])
        # inspect_response(response, self)
        content = response.xpath('//div[@id="article_content"]').extract()[0]
        item['content'] = 'aaa'
        yield item

管道

class MyspiderPipeline(object):
    def process_item(self, item, spider):
        return item



class CsvPipeline(object):
    """将爬取的信息保存为csv格式"""

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

    def process_item(self, item, spider):
        # xxxx:xxxxx:xxxx
        item = dict(item)
        self.f.write("{0}:{1}:{2}\n".format(item['title'],  item['url'], item['content']))
        # 一定要加， 返回给调度为器；
        return item

    def open_spider(self, spider):
        """开启爬虫时执行的函数"""
        pass

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

setting开启管道

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变成一个可以在多个主
机上同时运行的分布式爬虫。

setting.py中设置:
1. 设置DOWNLOAD_DELAY = 3,
设置下载的等待时间；每下载一个页面， 等待xxx秒。
2. 禁止cookie信息；
Disable cookies (enabled by default)
COOKIES_ENABLED = False
3. 设置用户代理
USER_AGENT = ‘Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Firefox/45.0’
4. 设置User-Agent的中间键
5. 设置代理IP的中间键

Use-Agent:

class UserAgentMiddleware(object):
    def __init__(self):
        self.user_agent = [
            'Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Firefox/45.0',
            "Mozilla/5.0 (Windows NT 6.0) AppleWebKit/536.5 "
        ]
    def process_request(self, request, spider):
        ua = random.choice(self.user_agent)
        if ua:
            # 此行仅为了测试, 真实场景不要打印， 会影响爬虫的效率
            print("当前使用的用户代理: %s" %(ua))
            request.headers.setdefault('User-Agent', ua)

代理ip：

class ProxiesMiddleware(object):
    # 留下练习:
    #       - 1). 从西刺代理IP网站获取所有的代理IP并存储到mysql/redis;
    def __init__(self):
        # 2). 连接redis/mysql数据库；

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

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