scrapy爬虫框架

最新推荐文章于 2022-11-25 21:45:12 发布
最新推荐文章于 2022-11-25 21:45:12 发布
阅读量304 收藏
点赞数
文章标签： 爬虫 python json
原文链接：http://www.cnblogs.com/LXP-Never/p/11391283.html
版权

scrapy框架是异步处理框架，可配置和可扩展程度非常高，Python中使用最广泛的爬虫框架。

安装

Ubuntu安装

1、安装依赖包

  1. sudo apt-get install libffi-dev
  2. sudo apt-get install libssl-dev
  3. sudo apt-get install libxml2-dev
  4. sudo apt-get install python3-dev
  5. sudo apt-get install libxslt1-dev
  6. sudo apt-get install zlib1g-dev
  7. sudo pip3 install -I -U service_identity

2、安装scrapy框架

  1. sudo pip3 install Scrapy

Windows安装

　　cmd命令行(管理员): python -m pip install Scrapy

Scrapy框架五大组件

  1. 引擎(Engine)      ：整个框架核心
  2. 调度器(Scheduler)   ：维护请求队列
  3. 下载器(Downloader)  ：获取响应对象，下载器是基于多线程的
  4. 爬虫文件(Spider)   ：数据解析提取
  5. 项目管道(Pipeline)  ：数据入库处理

下载器中间件(Downloader Middlewares) : 引擎->下载器,包装请求(随机代理等)

蜘蛛中间件(Spider Middlewares) : 引擎->爬虫文件,可修改响应对象属性

scrapy爬虫工作流程

爬虫项目启动

1、由引擎向爬虫程序索要第一个要爬取的URL，交给调度器去入队列

2、调度器处理请求后出队列，通过下载器中间件交给下载器去下载

3、下载器得到响应对象后，通过蜘蛛中间件交给爬虫程序

4、爬虫程序进行数据提取：

  1、数据交给管道文件去入库处理

  2、对于需要继续跟进的URL，再次交给调度器入队列，依次循环

scrapy常用命令

1、创建爬虫项目　　scrapy startproject 项目名

2、创建爬虫文件　　scrapy genspider 爬虫名 域名

　　　　　　　　　　域名为协议后面的名字

3、运行爬虫　　　　scrapy crawl 爬虫名

在cmd窗口运行上面指令后，会在当前文件夹自动创建如下目录结构。

scrapy项目目录结构

Baidu                   # 项目文件夹
├── Baidu               # 项目目录
│   ├── items.py        # 定义数据结构
│   ├── middlewares.py    # 中间件
│   ├── pipelines.py     # 数据处理
│   ├── settings.py      # 全局配置
│   └── spiders
│       ├── baidu.py    # 爬虫文件
└── scrapy.cfg           # 项目基本配置文件

全局配置文件settings.py详解

1、定义User-Agent

　　USER_AGENT = 'Mozilla/5.0'

2、是否遵循robots协议，一定要设置为False

　　ROBOTSTXT_OBEY = False

3、最大并发量，默认为16

　　CONCURRENT_REQUESTS = 32

4、下载延迟时间

　　DOWNLOAD_DELAY = 1

5、请求头，此处也可以添加User-Agent

　　DEFAULT_REQUEST_HEADERS={}

6、项目管道，运行管道函数

　　ITEM_PIPELINES={

　　'项目目录名.pipelines.类名':300

　　}

创建爬虫项目步骤

  1. 新建项目 ：scrapy startproject 项目名
  2. cd 项目文件夹
  3. 新建爬虫文件 ：scrapy genspider 文件名 域名
  4. 明确目标(items.py)
  5. 写爬虫程序(文件名.py)
  6. 管道文件(pipelines.py)
  7. 全局配置(settings.py)
  8. 运行爬虫 ：scrapy crawl 爬虫名

pycharm运行爬虫项目

1、创建一个脚本文件，比如：begin.py(和scrapy.cfg文件同目录)

2、begin.py中内容：

from scrapy import cmdline
cmdline.execute('scrapy crawl maoyan'.split())

导入cmd命令行模块，在python中写cmd命令，之所以用split()是因为把字符串按空格切割，这样cmd才能识别是3个参数。

百度

目标：打开百度首页，把 '百度一下，你就知道' 抓取下来，从终端输出

实现步骤

1、创建项目Baidu 和 爬虫文件baidu

1、scrapy startproject Baidu
2、cd Baidu
3、scrapy genspider baidu www.baidu.com

2、编写爬虫文件baidu.py，xpath提取数据

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


class BaiduSpider(scrapy.Spider):
    name = 'baidu'      # 爬虫名 : scrapy crawl 爬虫名
    allowed_domains = ['www.baidu.com']     # 允许爬取的域名
    start_urls = ['http://www.baidu.com/']      # 起始URL地址

    def parse(self, response):
        # response为百度的响应对象,提取"百度一下,你就知道"
        # r_list: [<selector xpath='',data=''>]
        # extract(): ["百度一下,你就知道"]
        # extract_first(): "百度一下,你就知道"
        # 1.6版本后可使用get(): "百度一下,你就知道"
        r_list = response.xpath('/html/head/title/text()').get()

        print('*'*50)
        print(r_list)
        print('*'*50)

3、全局配置settings.py

USER_AGENT = 'Mozilla/5.0'
ROBOTSTXT_OBEY = False
DEFAULT_REQUEST_HEADERS = {
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language': 'en',
}

或者把USER_AGENT文件写道头文件里面

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

4、创建begin.py（和scrapy.cfg同目录）

from scrapy import cmdline

cmdline.execute('scrapy crawl baidu'.split())

5、启动爬虫

直接运行 begin.py 文件即可

猫眼电影案例

目的

  • URL: 百度搜索 -> 猫眼电影 -> 榜单 -> top100榜
  • 爬取内容：电影名称、电影主演、上映时间

实现步骤

1、创建项目和爬虫文件

创建爬虫项目　　scrapy startproject Maoyan
　　　　　　　　cd Maoyan
创建爬虫文件　　scrapy genspider maoyan maoyan.com

2、定义要爬取的数据结构（items.py）

name = scrapy.Field()
star = scrapy.Field()
time = scrapy.Field()

3、编写爬虫文件（maoyan.py）

1、基准xpath，匹配每个电影信息节点对象列表
　　dd_list = response.xpath('//dl[@class="board-wrapper"]/dd')
2、for dd in dd_list:
　　电影名称 = dd.xpath('./a/@title')
　　电影主演 = dd.xpath('.//p[@class="star"]/text()')
　　上映时间 = dd.xpath('.//p[@class="releasetime"]/text()')

代码实现一

下载速度慢，爬了一页再爬第二页，调度器里面只有一个地址。

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


class MaoyanSpider(scrapy.Spider):
    name = 'maoyan'  # 爬虫名
    allowed_domains = ['maoyan.com']  # 允许爬虫的域名
    start_urls = ['https://maoyan.com/board/4?offset=0']  # 起始的URL地址
    offset = 0

    def parse(self, response):
        # 给items.py中的类:MaoyanItem(scrapy.Item)实例化
        item = MaoyanItem()

        # 基准xpath，匹配每个电影信息节点对象列表
        dd_list = response.xpath('//dl[@class="board-wrapper"]/dd')
        # 依次遍历
        for dd in dd_list:
            # [<selector xpath='' data='霸王别姬'>]
            # dd.xpath('')结果为[选择器1,选择器2]
            # .extract() 把[选择器1,选择器2]所有选择器序列化为unicode字符串
            # .extract_first() : 取第一个字符串
            # 是在给items.py中那些类变量赋值
            item['name'] = dd.xpath('./a/@title').get().strip()
            item['star'] = dd.xpath('.//p[@class="star"]/text()').get().strip()
            item['time'] = dd.xpath('.//p[@class="releasetime"]/text()').get().strip()

            # 把item对象交给管道文件处理
            yield item

        # 此方法不推荐,效率低
        self.offset += 10
        if self.offset <= 91:
            url = 'https://maoyan.com/board/4?offset={}'.format(self.offset)
            # 交给调度器入队列
            yield scrapy.Request(
                url=url,
                callback=self.parse)

代码实现二，基于下载器是多线程的，把多个地址，一次性的都给调度器，请求指纹，第一个地址爬了两次

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


class MaoyanSpider(scrapy.Spider):
    name = 'maoyan2'  # 爬虫名
    allowed_domains = ['maoyan.com']  # 允许爬取的域名
    start_urls = ['https://maoyan.com/board/4?offset=0']  # 起始的URL地址

    def parse(self, response):
        for offset in range(0, 91, 10):
            url = 'https://maoyan.com/board/4?offset={}'.format(offset)
            # 把地址交给调度器入队列
            yield scrapy.Request(url=url,
                                 callback=self.parse_page)

    def parse_page(self, response):
        # 给items.py中的类:MaoyanItem(scrapy.Item)实例化
        item = MaoyanItem()

        # 基准xpath,匹配每个电影信息节点对象列表
        dd_list = response.xpath('//dl[@class="board-wrapper"]/dd')
        # dd_list : [<element dd at xxx>,<...>]

        for dd in dd_list:
            # [<selector xpath='' data='霸王别姬'>]
            # dd.xpath('')结果为[选择器1,选择器2]
            # .extract() 把[选择器1,选择器2]所有选择器序列化为
            # unicode字符串
            # .extract_first() : 取第一个字符串
            # 是在给items.py中那些类变量赋值
            item['name'] = dd.xpath('./a/@title').get().strip()
            item['star'] = dd.xpath('.//p[@class="star"]/text()').get().strip()
            item['time'] = dd.xpath('.//p[@class="releasetime"]/text()').get().strip()

            # 把item对象交给管道文件处理
            yield item

代码实现三

# 重写start_requests()方法，直接把多个地址都交给调度器去处理
import scrapy
from ..items import MaoyanItem


class MaoyanSpider(scrapy.Spider):
    name = 'maoyan3'  # 爬虫名
    allowed_domains = ['maoyan.com']  # 允许爬取的域名

    # 去掉start_urls变量

    # 重写start_requests()方法，把所有URL地址都交给调度器
    # 去掉start_urls

    def start_requests(self):
        for offset in range(0, 91, 10):
            url = 'https://maoyan.com/board/4?offset={}'.format(offset)
            yield scrapy.Request(url=url, callback=self.parse)  # 把地址交给调度器入队列

    def parse(self, response):
        item = MaoyanItem()  # 给items.py中的类:MaoyanItem(scrapy.Item)实例化

        # 基准xpath
        dd_list = response.xpath('//dl[@class="board-wrapper"]/dd')
        # 依次遍历
        for dd in dd_list:
            # [<selector xpath='' data='霸王别姬'>]
            # dd.xpath('')结果为[选择器1,选择器2]
            # .extract() 把[选择器1,选择器2]所有选择器序列化为
            # unicode字符串
            # .extract_first() : 取第一个字符串
            # 是在给items.py中那些类变量赋值
            item['name'] = dd.xpath('./a/@title').get().strip()
            item['star'] = dd.xpath('.//p[@class="star"]/text()').get().strip()
            item['time'] = dd.xpath('.//p[@class="releasetime"]/text()').get().strip()

            yield item  # 把item对象交给pipline管道文件处理

3、定义管道文件（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 pymysql
from .settings import *


class MaoyanPipeline(object):
    # item: 从爬虫文件maoyan.py中yield的item数据
    def process_item(self, item, spider):
        print(item['name'], item['time'], item['star'])

        return item


# 新建自定义管道 - 存入MySQL数据库
class MaoyanMysqlPipeline(object):
    # 爬虫项目开始运行时执行此函数
    def open_spider(self, spider):
        print('我是open_spider函数输出')
        # 一般用于建立数据库连接
        self.db = pymysql.connect(
            host=MYSQL_HOST,
            user=MYSQL_USER,
            password=MYSQL_PWD,
            database=MYSQL_DB,
            charset=MYSQL_CHAR)
        self.cursor = self.db.cursor()

    def process_item(self, item, spider):
        # 因为execute()的第二个参数为列表
        L = [item['name'].strip(),
             item['star'].strip(),
             item['time'].strip()]
        self.cursor.execute('insert into filmtab values(%s,%s,%s)', L)
        self.db.commit()  # 提交到数据库

        return item

    # 爬虫项目结束时执行此函数，只执行一次
    def close_spider(self, spider):
        print('我是close_spider函数输出')
        # 一般用于断开数据库连接
        self.cursor.close()
        self.db.close()

5、全局配置文件（settings.py）

ROBOTSTXT_OBEY = False
DEFAULT_REQUEST_HEADERS = {
    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
    'Accept-Language': 'en',
    '’USER_AGENT' = 'Mozilla/5.0'
}
ITEM_PIPELINES = {
# 300表示优先级(1-1000)，数字越小，优先级越高
    'Maoyan.pipelines.MaoyanPipeline': 300,
    'Maoyan.pipelines.MaoyanMysqlPipeline': 200}

6、创建并运行文件（begin.py）

from scrapy import cmdline
cmdline.execute('scrapy crawl maoyan'.split())

爬虫项目启动方式

方式一

从爬虫文件(spider)的start_urls变量中遍历URL地址，把下载器返回的响应对象（response）交给爬虫文件的parse()函数处理

# start_urls = ['http://www.baidu.com/']

方式二

重写start_requests()方法，从此方法中获取URL，交给指定的callback解析函数处理

1、去掉start_urls变量

2、def start_requests(self):

     # 生成要爬取的URL地址，利用scrapy.Request()方法交给调度器 **

知识点汇总

response.xpath('')调用方法

结果：列表,元素为选择器 ['<selector xpath='' data='A'>]

.extract() ：提取文本内容，序列化列表中所有选择器为Unicode字符串 ['A','B','C']

.extract_first() 或者 get() :获取列表中第1个序列化的元素(字符串)

.get()：提取列表中第1个文本内容

response.text：获取响应内容

response.body：获取bytes数据类型

response.xpath('')

pipelines.py中必须由1个函数叫process_item

def process_item(self,item,spider):
    return item ( * 此处必须返回 item )

日志变量及日志级别(settings.py)

# 日志相关变量

LOG_LEVEL = ''

LOG_LEVEL = 'INFO'　　# 表示终端只显示INFO和INF日志级别以上的信息，DEBUG就不会显示了

LOG_FILE ：　　　　　　本来应该输出在终端的信息，写入到了log日志文件中

LOG_FILE = '文件名.log'

 

# 日志级别

5 CRITICAL ：严重错误

4 ERROR    ：普通错误

3 WARNING  ：警告

2 INFO     ：一般信息

1 DEBUG    ：调试信息

settings.py常用变量

LOG_LEVEL = ''              # 1、设置日志级别
LOG_FILE = ''               # 2、保存到日志文件(不在终端输出)
FEED_EXPORT_ENCODING = ''   # 3、设置数据导出编码(主要针对于json文件)
IMAGES_STORE = '路径'        # 4、非结构化数据存储路径
USER_AGENT = ''             # 5、设置User-Agent
CONCURRENT_REQUESTS = 32    # 6、设置最大并发数(默认为16)

# 7、下载延迟时间(每隔多长时间请求一个网页)
# DOWNLOAD_DELAY 会影响 CONCURRENT_REQUESTS，不能使并发显现
# 有CONCURRENT_REQUESTS，没有DOWNLOAD_DELAY： 服务器会在同一时间收到大量的请求
# 有CONCURRENT_REQUESTS，有DOWNLOAD_DELAY 时，服务器不会在同一时间收到大量的请求
DOWNLOAD_DELAY = 3

DEFAULT_REQUEST_HEADERS = {}    # 8、请求头
ITEM_PIPELINES = {}             # 9、添加项目管道
DOWNLOADER_MIDDLEWARES = {}     # 10、添加下载器中间件

 

管道处理数据流程

1、在爬虫文件中为items.py中类做实例化，用爬下来的数据给对象赋值

from ..items import MaoyanItem

item = MaoyanItem()

item['name'] = xxx

2、管道文件（pipelines.py）
3、开启管道（settings.py）
ITEM_PIPELINES = { '项目目录名.pipelines.类名':优先级 }

优先级1-1000，数字越小优先级越高

scrapy.Request()参数

1、url

2、callback

3、meta：传递数据，定义代理

数据持久化存储(MySQL)

实现步骤

1、在setting.py中定义MYSQL相关变量

# 定义MySQL相关变量
MYSQL_HOST = '127.0.0.1'
MYSQL_USER = 'root'
MYSQL_PWD = '123456'
MYSQL_DB = 'maoyandb'
MYSQL_CHAR = 'utf8'

2、pipelines.py中新建管道类，并导入settings模块from .settings import *

# 新建自定义管道 - 存入MySQL数据库
class MaoyanMysqlPipeline(object):
    # 爬虫程序启动时，只执行1次,一般用于数据库连接
    def open_spider(self, spider):
        print('我是open_spider函数输出')
        # 一般用于建立数据库连接
        self.db = pymysql.connect(
            host=MYSQL_HOST,
            user=MYSQL_USER,
            password=MYSQL_PWD,
            database=MYSQL_DB,
            charset=MYSQL_CHAR)
        self.cursor = self.db.cursor()

    def process_item(self, item, spider):
        # 用于处理爬取的item数据，这个函数一定要有
        # 因为execute()的第二个参数为列表
        L = [item['name'].strip(),
             item['star'].strip(),
             item['time'].strip()]
        self.cursor.execute('insert into filmtab values(%s,%s,%s)', L)
        self.db.commit()    # 提交到数据库

        return item

    # 爬虫项目结束时执行此函数，只执行一次，一般用于断开数据库连接
    def close_spider(self, spider):
        print('我是close_spider函数输出')
        # 一般用于断开数据库连接
        self.cursor.close()
        self.db.close()

注意 ：process_item() 函数中一定要 return item

3、settings.py中添加此管道

ITEM_PIPELINES = {
    'Maoyan.pipelines.MaoyanPipeline': 300,
    'Maoyan.pipelines.MaoyanMysqlPipeline': 200　　# 数据库的管道
 }

注意 ：process_item() 函数中一定要 return item，因为第一个管道返回的item会继续交由下一个管道处理，否则返回并传入下一个管道的值为None

 

保存为csv、json文件

scrapy crawl maoyan -o maoyan.csv
scrapy crawl maoyan -o maoyan.json

# 在存json文件的时候，要在setting.py设置到处编码 FEED_EXPORT_ENCODING = 'utf-8'

盗墓笔记小说抓取案例（三级页面）

目标

# 抓取目标网站中盗墓笔记1-8中所有章节的所有小说的具体内容，保存到本地文件
1、网址 ：http://www.daomubiji.com/

准备工作xpath

1、一级页面xpath（此处响应做了处理）：

　　盗墓笔记1-8的链接：//ul[@class="sub-menu"]/li/a/@href

2、二级页面xpath：/html/body/section/div[2]/div/article

　　基准xpath ：//article

　　链接：./a/@href

　　标题：./a/text()　　# 七星鲁王 第一章 血尸

3、三级页面xpath：

　　response.xpath('//article[@class="article-content"]//p/text()').extract()

项目实现

1、创建项目及爬虫文件

创建项目 ：scrapy startproject Daomu
创建爬虫 ：scrapy genspider daomu www.daomubiji.com

2、定义要爬取的数据结构（把数据交给管道）items.py

import scrapy
​
class DaomuItem(scrapy.Item):
    juan_name = scrapy.Field()    # 卷名
    zh_num = scrapy.Field()       # 章节数
    zh_name = scrapy.Field()      # 章节名
    zh_link = scrapy.Field()      # 章节链接
    zh_content = scrapy.Field()   # 小说内容

3、爬虫文件实现数据抓取 daomu.py

# -*- coding: utf-8 -*-
import scrapy
from ..items import DaomuItem
​
class DaomuSpider(scrapy.Spider):
    name = 'daomu'
    allowed_domains = ['www.daomubiji.com']
    start_urls = ['http://www.daomubiji.com/']
​
    # 解析一级页面,提取 盗墓笔记1 2 3 ... 链接
    def parse(self, response):
        one_link_list = response.xpath('//ul[@class="sub-menu"]/li/a/@href').extract()
        print(one_link_list)
        # 把链接交给调度器入队列
        for one_link in one_link_list:
            yield scrapy.Request(url=one_link, callback=self.parse_two_link, dont_filter=True)
​
    # 解析二级页面
    def parse_two_link(self,response):
        # 基准xpath,匹配所有章节对象列表
        article_list = response.xpath('/html/body/section/div[2]/div/article')
        # 依次获取每个章节信息
        for article in article_list:
            # 创建item对象
            item = DaomuItem()
            info = article.xpath('./a/text()').extract_first().split()
            # info : ['七星鲁王','第一章','血尸']
            item['juan_name'] = info[0]
            item['zh_num'] = info[1]
            item['zh_name'] = info[2]
            item['zh_link'] = article.xpath('./a/@href').extract_first()
            # 把章节链接交给调度器
            yield scrapy.Request(
                url=item['zh_link'],
                # 把item传递到下一个解析函数
                meta={'item':item},
                callback=self.parse_three_link,
                dont_filter=True
            )
​
    # 解析三级页面
    def parse_three_link(self,response):
        # 获取上一个函数传递过来的item对象
        item = response.meta['item']
        # 获取小说内容
        # ['段落1','段落2','段落3',....]
        item['zh_content'] = '\n'.join(response.xpath(
          '//article[@class="article-content"]//p/text()'
        ).extract())

​        # 所有的数据都爬完了，再yield
        yield item
​
        # '\n'.join(['第一段','第二段','第三段'])

4、管道文件实现数据处理pipline.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
​
​
class DaomuPipeline(object):
    def process_item(self, item, spider):
        filename = '/home/tarena/aid1902/{}-{}-{}.txt'.format(
            item['juan_name'],
            item['zh_num'],
            item['zh_name']
        )
​
        f = open(filename,'w')
        f.write(item['zh_content'])
        f.close()
        return item

5、setting

　　打开通道

腾讯招聘

MySQL数据库--建库建表

create database tencentdb charset utf8;
use tencentdb;
create table tencenttab(
        name varchar(100),
        type varchar(100),
        duty varchar(5000),
        requirement varchar(5000)
        )charset=utf8;

1、创建项目+爬虫文件

scrapy startproject Tencent
cd Tencent
scrapy genspider tencent hr.tencent.com

2、定义爬取的数据结构 items.py

job_name = scrapy.Field()
job_type = scrapy.Field()    # 类别
job_duty = scrapy.Field()    # 职责
job_require = scrapy.Field()    # 要求
job_address = scrapy.Field()    # 地址

3、爬虫文件

class TencentSpider(scrapy.Spider):
    name = 'tencent'
    allowed_domains = ['careers.tencent.com']
    one_url = 'https://careers.tencent.com/tencentcareer/api/post/Query?timestamp=1563912271089&countryId=&cityId=&bgIds=&productId=&categoryId=&parentCategoryId=&attrId=&keyword=&pageIndex={}&pageSize=10&language=zh-cn&area=cn'
    two_url = 'https://careers.tencent.com/tencentcareer/api/post/ByPostId?timestamp=1563912374645&postId={}&language=zh-cn'
    # 1. 去掉start_urls
    # 2. 重新start_requests()方法
    def start_requests(self):
        total_page = self.get_total_page()
        for page_index in range(1,total_page):
            url = self.one_url.format(page_index)
            yield scrapy.Request(
                url = url,
                callback = self.parse_one
            )
​
    # 获取总页数
    def get_total_page(self):
        url = self.one_url.format(1)
        html = requests.get(url=url).json()
        total_page = int(html['Data']['Count']) // 10 + 1
​
        return total_page
​
    # 解析一级页面函数
    def parse_one(self,response):
        html = json.loads(response.text)
        for job in html['Data']['Posts']:
            item = TencentItem()
            # postId: 拼接二级页面的地址
            post_id = job['PostId']
            two_url = self.two_url.format(post_id)
            # 交给调度器
            yield scrapy.Request(
                url = two_url,
                meta = {'item':item},
                callback = self.parse_two_page
            )
​
    def parse_two_page(self,response):
        item = response.meta['item']
        html = json.loads(response.text)
        item['job_name'] = html['Data']['RecruitPostName']
        item['job_type'] = html['Data']['CategoryName']
        item['job_duty'] = html['Data']['Responsibility']
        item['job_require'] = html['Data']['Responsibility']
        item['job_address'] = html['Data']['LocationName']
​
​
        yield item

4、管道文件

create database tencentdb charset utf8;
use tencentdb;
create table tencenttab(
        job_name varchar(500),
        job_type varchar(100),
        job_duty varchar(1000),
        job_require varchar(1000),
        job_address varchar(100)
        )charset=utf8;

管道文件pipelines实现

import pymysql
class TencentMysqlPipeline(object):
    def open_spider(self,spider):
        self.db = pymysql.connect(
            '127.0.0.1','root','123456','tencentdb',
            charset='utf8'
        )
        self.cursor = self.db.cursor()
​
    def process_item(self,item,spider):
        ins = 'insert into tencenttab values(%s,%s,%s,%s,%s)'
        job_list = [
            item['job_name'],item['job_type'],item['job_duty'],
            item['job_require'],item['job_address']
        ]
        self.cursor.execute(ins,job_list)
        self.db.commit()
        return item
​
    def close_spider(self,spider):
        self.cursor.close()
        self.db.close()

5、settings.py

定义常用变量，添加管道即可

图片管道(360图片抓取案例)

目标：www.so.com -> 图片 -> 美女

抓取网络数据包

2、F12抓包,抓取到json地址 和 查询参数(QueryString)
     url = 'http://image.so.com/zj?ch=beauty&sn={}&listtype=new&temp=1'.format(str(sn))
     ch: beauty
     sn: 90
     listtype: new
     temp: 1

项目实现

1、创建爬虫项目和爬虫文件

scrapy startproject So
cd So
scrapy genspider so image.so.com

2、定义要爬取的数据结构(items.py)

img_link = scrapy.Field()

3、爬虫文件实现图片链接抓取

# -*- coding: utf-8 -*-
import scrapy
import json
from ..items import SoItem
​
class SoSpider(scrapy.Spider):
    name = 'so'
    allowed_domains = ['image.so.com']
​
    # 重写Spider类中的start_requests方法
    # 爬虫程序启动时执行此方法,不去找start_urls
    def start_requests(self):
        for page in range(5):
            url = 'http://image.so.com/zj?ch=beauty&sn={}&listtype=new&temp=1'.format(str(page*30))
            # 把url地址入队列
            yield scrapy.Request(
                url = url,
                callback = self.parse_img
            )
​
    def parse_img(self, response):
        html = json.loads(response.text)
​
        for img in html['list']:
            item = SoItem()
            # 图片链接
            item['img_link'] = img['qhimg_url']
​
            yield item

4、管道文件（pipelines.py）

from scrapy.pipelines.images import ImagesPipeline
import scrapy
​
class SoPipeline(ImagesPipeline):
    # 重写get_media_requests方法
    def get_media_requests(self, item, info):
        yield scrapy.Request(item['img_link'])

5、设置settings.py

IMAGES_STORE = '/home/tarena/images/'

6、创建run.py运行爬虫

scrapy shell的使用

基本使用

  1. scrapy shell URL地址
  2. request.headers ：请求头(字典)
  3. reqeust.meta    ：item数据传递，定义代理(字典)
  4. response.text    ：字符串
  5. response.body    ：bytes
  6. response.xpath('')

scrapy.Request()

  1. url
  2. callback
  3. headers
  4. meta ：传递数据,定义代理
  5. dont_filter ：是否忽略域组限制，默认False检查域组限制allowed_domains['']

设置中间件(随机User-Agent)

少量User-Agent切换

方法一

# settings.py
USER_AGENT = ''
DEFAULT_REQUEST_HEADERS = {}

方法二

# spider
yield scrapy.Request(url,callback=函数名,headers={})

大量User-Agent切换（中间件）

middlewares.py设置中间件

1、获取User-Agent

  # 方法1 ：新建useragents.py,存放大量User-Agent，random模块随机切换

  # 方法2 ：安装fake_useragent模块(sudo pip3 install fack_useragent)

from fake_useragent import UserAgent

ua_obj = UserAgent()
ua = ua_obj.random

2、middlewares.py新建中间件类，拦截传给下载器的请求内容

class RandomUseragentMiddleware(object):
    def process_request(self,reuqest,spider):
        ua = UserAgent()
        request.headers['User-Agent'] = ua.random

3、settings.py添加此下载器中间件

DOWNLOADER_MIDDLEWARES = {
    'Baidu.middlewares.TestDownloaderMiddleware': 543,
    'Baidu.middlewares.RandomUaDownloaderMiddleware': 300,
    'Baidu.middlewares.TestRandomProxyMiddleware': 400,
}

设置中间件(随机代理)

import random
from fake_useragent import UserAgent


# 随机User-Agent下载器中间件
class RandomUaDownloaderMiddleware(object):
    def process_request(self, request, spider):
        # 给每一个拦截下来的请求包装随机User-Agent
        ua = UserAgent()
        useragent = ua.random
        # request.headers: 字典
        request.headers['User-Agent'] = useragent

        print('我是中间件:', useragent)  # 测试

proxy_list = ['http://1.1.1.1:1111', 'http://2.2.2.2:2222']

# 随机代理IP下载器中间件
class TestRandomProxyMiddleware(object):
    def process_request(self, request, spider):
        proxy = random.choice(proxy_list)  # 1. 随机选择并定义好代理
        request.meta['proxy'] = proxy  # 2. 如何包装
        print('我是中间件2:', proxy)  # 测试

    # 处理异常,一旦代理不能用,则返回请求再次执行下载器中间件，把请求扔回调度器
    def process_exception(self, request, exception, spider):
        return request

 

转载于:https://www.cnblogs.com/LXP-Never/p/11391283.html

weixin_30642267
关注
crawler:一个基本的 ruby​​ 网络爬虫
07-11
一个非常基本的网络爬虫 给定一个 url，将对所有链接页面（在同一域和方案上）执行广度优先爬网，并构建每个页面所依赖的静态资产列表。 它需要一个完整的 url，带有方案（http 或 https）。 给定一个子域，它不会离开它。 即如果给定developer.google.com它将不会抓取developer.google.com之外的任何页面。 它也不会跟随重定向。 ＃＃要求 能切里 在 2.1.1 MRI 上测试 ＃＃用法： require './crawler.rb' # A scheme (http or https) is required. # The crawler will not leave the subdomain (e.g. www) it is assigned # To see a list of urls as they are being crawle
Ruby 如何实现爬虫抓取
weixin_42800181的博客
04-06 734
Ruby中实现网页抓取，一般用的是mechanize，使用非常简单。 安装 sudo gem install mechanize 抓取网页 require ‘rubygems’ require ‘mechanize’ agent = Mechanize.new page = agent.get(‘http://google.com/’) 模拟点击事件 page = agent.page.link_with(:text => ‘News’).click 模拟表单提交 google_form
简单网络爬虫Ruby版
Jeremy_W的专栏
06-30 3406
这个程序写的很简单，主要完成的功能是到斯坦福大学的网站上去收集email地址，默认是10个线程，策略是广度优先，$debug=true时开启调试信息。附件中包含代码和批处理文件。
Python爬虫基本框架
让技术没有门槛
03-01 4408
☞☞☞点击查看更多优秀Python博客☜☜☜    Hello大家好，我是你们的朋友JamesBin这篇文章我们一起学习一下学习Python到爬虫的一个基本框架。 Python爬虫基本框架爬虫的基本思路：代码实现代码分析 爬虫的基本思路： #1、发起请求 使用http库向目标站点发起请求，即发送一个Request Request包含：请求头、请求体等 #2、获取响应内容 如果服务...
完整版Python网络爬虫之Scrapy爬虫框架使用案例教程含源代码共18页.pdf
06-19
Scratch，是抓取的意思，这个Python的爬虫框架叫Scrapy，大概也是这个意思吧，就叫它：小刮刮吧。 小刮刮是一个为遍历爬行网站、分解获取数据而设计的应用程序框架，它可以应用在广泛领域：数据挖掘、信息处理和或者...
【保姆级教学】Python爬虫、Selenium、Scrapy爬虫框架、反爬与反反爬、Appium
03-06
视频课程分享——【保姆级教学】Python爬虫、Selenium、Scrapy爬虫框架、反爬与反反爬、Appium，附源码+文档下载
基于Python的Scrapy爬虫框架设计源码
最新发布
04-11
本源码提供了一个基于Python的Scrapy爬虫框架设计。项目包含20个文件，其中包括6个Python字节码文件、6个Python源文件、3个XML文件、1个Gitignore文件、1个IML文件、1个CSV文件、1个TXT文件和1个CFG文件。这个项目是...
网络爬虫之框架 5-1 Scrapy爬虫框架
yky__xukai的博客
07-03 209
文章截图均来自中国大学mooc Python网络爬虫与信息提取的教程，以上仅作为我的个人学习笔记。下面是教程链接： https://www.icourse163.org/learn/BIT-1001870001?tid=1450316449#/learn/content?type=detail&id=1214620493&cid=1218397635&replay=true Scrapy爬虫框架介绍： 使用：pipinstall srcapy进行安装 安装后小测：执行s...
爬虫--scrapy框架
weixin_34362875的博客
04-25 1353
爬虫--scrapy框架 一、scrapy框架的简介和基础使用 二、scrapy框架--parse方法解析示例 三、scrapy框架--基于终端指令的持久化存储 四、scrapy框架--基于管道的持久化存储 五、scrapy框架--基于MySQL数据库的持久化存储 六、scrapy框架-...
玩转 Scrapy 框架 (一)：Item Pipeline 的使用
Amo Xiang的博客
09-12 1764
Scrapy 框架之 Item Pipeline 使用详解，包括数据存储、图片下载、文件下载
Scrapy基本概念——Item Pipeline
激情人生，美好生活
11-25 1640
蜘蛛抓取的每一个Item都会被发送到Item Pipeline。根据ITEM_PIPELINES的优先级设置，不同的Item Pipeline依次处理每一个Item，最后可删除该Item不做处理，也可将该Item发送到下一个Item Pipeline。Item Pipeline的主要用途有：1、清洗数据2、验证数据（检查Item某些字段是否为空）3、数据查重4、存储数据。
运维学python之爬虫高级篇（四）Item Pipeline介绍(附爬取网站获取图片到本地代码)...
weixin_33806509的博客
02-03 269
1 Item Pipeline 当spider爬取到item后，它被发送到项目管道（Item Pipeline），通过几个组件按顺序进行处理。每一个Item Pipeline是一个实现了简单方法的Python类，它接收到一个item并对其执行一个操作，也要决定该item是否应该继续通过管道，或者被丢弃，不再进行处理。Item Pipeline典型的用途是：1.清理HTML数据2.验证爬取的数据(检...
Item Pipeline
qq_37797316的博客
01-22 335
    在一个项目被蜘蛛抓取后，它被发送到项目管道，该项目管道通过顺序执行的几个组件处理它。 每个项目管道组件（有时简称为“项目管道”）是一个实现简单方法的Python类。 他们收到一个项目并对其执行操作，同时决定该项目是否应该继续通过管道或被丢弃并且不再处理。 项目管道的典型用途是： 清理HTML数据 验证已删除的数据（检查项目是否包含某些字段） 检查重复项（并删除它们） 将已删...
Scrapy框架学习（二）----Item Pipeline(管道)和Scrapy Shell
Widsom的博客
11-29 5206
Scrapy框架学习（二）—-Item Pipeline(管道)和Scrapy ShellItem Pipeline（管道）当Item在Spider中被收集之后，它将会被传递到Item Pipeline，一些组件会按照一定的顺序执行对Item进行处理。每个Item Pipeline都是实现了简单方法的Python类，比如决定此Item是丢弃而存储。以下是Item Pipeline的典型应用： 验证爬
chapter 5 使用Item Pipeline处理数据
lee's的博客
11-01 624
第5章 使用Item Pipeline处理数据    在之前的章节中，我们学习了提取数据以及封装数据的方法，这一章来学习如何对爬取到的数据进行处理。在Scrapy中，Item Pipeline是处理数据的组件，一个Item Pipeline就是一个包含特定接口的类，通常只负责一种功能的数据处理，在一个项目中可以同时启用多个Item Pipeline，它们按指定次序级联起来，形成一条数据处理流水线。    以下是Item Pipeline的几种典型应用： ●　清洗数据。 ●　验证数据的有效性。 ●　过滤掉重复
scrapy框架开发爬虫实战——Item Pipeline管道
万锦
10-10 858
Item Pipeline简介 在Scrapy中， ItemPipeline是处理数据的组件， 一个Item Pipeline就是一个包含特定接口的类， 通常只负责一种功能的数据处理， 在一个项目中可以同时启用多个Item Pipeline， 它们按指定次序级联起来， 形成一条数据处理流水线。 以下是Item Pipeline的几种典型应用： ● 清洗数据。 ● 验证数据的有效性。 ● 过滤...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值