系列文章索引

Python爬虫基础（一）：urllib库的使用详解
Python爬虫基础（二）：使用xpath与jsonpath解析爬取的数据
Python爬虫基础（三）：使用Selenium动态加载网页
Python爬虫基础（四）：使用更方便的requests库
Python爬虫基础（五）：使用scrapy框架

一、scrapy简介

1、什么是scrapy

Scrapy 是一个为了抓取网页数据、提取结构性数据而编写的应用框架，该框架是封装的，包含 request （异步调度和处理）、下载器（多线程的 Downloader）、解析器（selector）和 twisted（异步处理）等。对于网站的内容爬取，其速度非常快捷。

2、scrapy安装

# 进入到python安装目录的Scripts目录
d:
cd D:\python\Scripts
# 安装 可以使用国内源
pip install scrapy

3、scrapy架构组成

（1）引擎：自动运行，无需关注，会自动组织所有的请求对象，分发给下载器。
（2）下载器：从引擎处获取到请求对象后，请求数据。
（3）spiders：spider类定义了如何爬取某个（或某些）网站。包括了爬取的动作（例如：是否跟进链接）以及如何从网页的内容中提取结构化数据（爬取item）。换句话说，Spider就是定义爬取的动作及分析某个网页的地方。
（4）调度器：有自己的调度规则，无需关注。
（5）管道（Item pipeline）：最终处理数据的管道，会预留接口供我们处理数据。当Item在Spider中被收集之后，它将会被传递到Item pipeline，一些组件会按照一定的顺序执行对Item的处理。每个item pipeline组件是实现了简单方法的Python类，他们接收到Item并通过它执行一些行为，同时也决定此Item是否继续通过pipeline，或是被丢弃而不再进行处理。

以下是item pipeline的一些典型应用：
（1）清理HTML数据，（2）验证爬取的数据（检查item包含某些字段），（3）查重（并丢弃），（4）将爬取结果保存到数据库中。

4、scrapy工作原理

spiders->scheduler（调度器）->scrapy engine（引擎）->downloader（下载器）->互联网进行下载
->下载后的数据从引擎到spiders->通过引擎xpath进行数据解析->使用pipeline对数据进行存储

二、scrapy基本使用

1、创建项目

进入到项目目录，打开cmd：

# 创建scrapy_test_001项目，项目名不能以数字、汉字开头
scrapy startproject scrapy_test

2、创建爬虫文件

要在spiders文件夹中去创建爬虫文件

# cd 项目的名字\项目的名字\spiders
cd scrapy_test\scrapy_test\spiders

创建爬虫文件，注意，不需要添加http协议了：

# scrapy genspider 爬虫文件的名字  要爬取网页
scrapy genspider baidu  www.baidu.com

此时，在spiders目录中，会生成一个baidu.py：

我们看一下baidu.py的内容：

import scrapy

class BaiduSpider(scrapy.Spider):
    # 爬虫的名字  用于运行爬虫的时候 使用的值
    name = "baidu"
    # 允许访问的域名
    allowed_domains = ["www.baidu.com"]
    # 起始的url地址  指的是第一次要访问的域名
    start_urls = ["https://www.baidu.com"]

    # 是执行了start_urls之后 执行的方法   方法中的response 就是返回的那个对象
    # 相当于 response = urllib.request.urlopen()
    #       response  = requests.get()
    def parse(self, response):
        pass

后续我们可以在parse方法中，对response进行处理，这就是最终爬取的结果。

3、（附）项目组成

4、运行爬虫代码

（1）修改baidu.py

在parse方法中，自定义输出：

def parse(self,response):
    print('输出正确！')

在spiders目录中，执行以下命令，就可以运行爬虫代码：

# scrapy crawl 爬虫的名字
scrapy crawl baidu

会输出很多内容，但是并没有我们打印的东西。

（2）robots文件

控制台中，打印出了百度的robots协议：

每个网站都会有一个robots君子协议，里面定义了哪些不允许爬取，我们看百度的robots：
https://www.baidu.com/robots.txt

在项目的settings.py文件中，默认是ROBOTSTXT_OBEY=True，表示遵循这个君子协议。

我们只需要将这一行注释掉：

此时我们再执行爬虫代码：

# scrapy crawl 爬虫的名字
scrapy crawl baidu

此时在命令行中，会打印出我们自定义的那句话了。

5、response的属性和方法

response.xpath(xpath_expression)：根据XPath表达式选择并提取数据。
response.css(css_expression)：根据CSS选择器选择并提取数据。
response.follow(url)：根据给定的URL创建新的请求，并通过回调方法继续处理。
response.url：返回当前响应的URL。
response.status：返回当前响应的状态码。
response.headers：返回当前响应的头部信息。
response.body：返回当前响应的原始二进制内容。
response.text：返回当前响应的文本内容。
response.css(‘a::attr(href)’).getall()：使用CSS选择器提取所有匹配的元素属性值。
response.xpath(‘//a/@href’).extract()：使用XPath表达式提取所有匹配的元素属性值

6、实战：获取百度的【百度一下】按钮的内容

    def parse(self, response):
        print('=====================')
        input = response.xpath('//input[@id="su"]/@value')[0]
        print(input.extract()) # 百度一下
        print('=====================')

7、实战：获取汽车之家汽车价格表

import scrapy

class CarSpider(scrapy.Spider):
    name = 'car'
    allowed_domains = ['https://car.autohome.com.cn/price/brand-15.html']
    start_urls = ['https://car.autohome.com.cn/price/brand-15.html']

    def parse(self, response):
        print('=======================')
        name_list = response.xpath('//div[@class="main-title"]/a/text()')
        price_list = response.xpath('//div[@class="main-lever"]//span/span/text()')

        for i in range(len(name_list)):
            name = name_list[i].extract()
            price = price_list[i].extract()
            print(name,price)
        print('=======================')

三、使用scrapy shell

1、什么是scrapy shell

scrapy终端，是一个交互终端，供您在未启动spider的情况下尝试及调试您的爬取代码。 其本意是用来测试提取数据的代码，不过您可以将其作为正常的python终端，在上面测试任何的python代码。

该终端是用来测试xPath或css表达式，查看他们的工作方式及从爬取的网页中提取的数据。在编写您的spider时，该终端提供了交互性测试您的表达式代码的功能，免去了每次修改后运行spider的麻烦。一旦熟悉了scrapy终端后，您会发现其在开发和调试spider时发挥的巨大作用。

2、安装ipython（非必须）

# 进入到python安装目录的Scripts目录
d:
cd D:\python\Scripts
# 安装 可以使用国内源
pip install ipython

如果安装了 IPython，scrapy终端将使用 IPython (替代标准Python终端)。 IPython 终端与其他相比更为强大，提供智能的自动补全，高亮输出，及其他特性。

使用：命令行直接输入ipython，进入的新命令窗口自带高亮及自动补全：

3、使用scrapy shell

# 直接在window的终端中输入scrapy shell 域名
# 直接在命令终端（不需要进入python或者ipython终端），执行完毕之后，自动进入ipython终端
scrapy shell www.baidu.com

可以直接获取到response对象，可以直接在此进行调试。

四、实战：获取当当网商品数据

1、初始化项目

# 在自定义目录中创建项目
scrapy startproject scrapy_dangdang

# 创建爬虫文件
# cd 项目的名字\项目的名字\spiders
cd scrapy_dangdang\scrapy_dangdang\spiders

# scrapy genspider 爬虫文件的名字  要爬取网页
# 中国古典小说网址：http://category.dangdang.com/cp01.03.32.00.00.00.html
scrapy genspider dang http://category.dangdang.com/cp01.03.32.00.00.00.html

# 运行
scrapy crawl dang

2、定义item文件

在项目自动生成的item.py中，定义要爬取的数据格式：

import scrapy

class ScrapyDangdangItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    # 通俗的说就是你要下载的数据都有什么，固定写法：scrapy.Field()

    # 图片
    src = scrapy.Field()
    # 名字
    name = scrapy.Field()
    # 价格
    price = scrapy.Field()

3、爬取图片、名字、价格

我们先分析这三者的xpath：
拿到图片的xpath：//ul[@id="component_59"]/li/a/img/@src 因为图片懒加载，应该取图片的data-original属性。

拿到标题的xpath：//ul[@id="component_59"]/li/p[@class="name"]/a/@title

拿到价格的xpath：//ul[@id="component_59"]/li/p[@class="price"]/span[1]/text()

import scrapy

class DangSpider(scrapy.Spider):
    name = "dang"
    allowed_domains = ["category.dangdang.com"]
    start_urls = ["http://category.dangdang.com/cp01.03.32.00.00.00.html"]

    def parse(self, response):
        #         src = //ul[@id="component_59"]/li/a/img/@src
        #         name = //ul[@id="component_59"]/li/p[@class="name"]/a/@title
        #         price = //ul[@id="component_59"]/li/p[@class="price"]/span[1]/text()
        #         所有的seletor的对象 都可以再次调用xpath方法
        li_list = response.xpath('//ul[@id="component_59"]/li')

        for li in li_list:
            src = li.xpath('./a/img/@data-original').extract_first()
            # 第一张图片和其他的图片的标签的属性是不一样的
            # 第一张图片的src是可以使用的  其他的图片的地址是data-original
            if src:
                src = src
            else:
                src = li.xpath('./a/img/@src').extract_first()

            name = li.xpath('./p[@class="name"]/a/@title').extract_first()
            price = li.xpath('./p[@class="price"]/span[1]/text()').extract_first()
            # 拿到所有信息
            print(src + name + price)

4、管道封装

（1）熟悉yield

带有tield的函数不再是一个普通函数，而是一个生成器generator，可用于迭代。

yield是一个类似return的关键字，迭代一次遇到yield时就返回yield后面（右边）的值。重点是：下一次迭代时，从上一次迭代器遇到的yield后面的代码（下一行）开始执行。

简单理解：yield就是return返回一个值，并且记住这个返回的位置，下次迭代就从这个位置后（下一行）开始。

（2）构造item对象并交给pipeline

上面我们已经获取到图片、名称和价格了，继续在parse方法中构造item对象并交给pipeline：

from scrapy_dangdang.items import ScrapyDangdangItem
            # 构造item对象
            book = ScrapyDangdangItem(src=src,name=name,price=price)

            # 获取一个book就将book交给pipelines
            yield book

（3）在settings.py中开启pipeline

管道可以有很多个 那么管道是有优先级的 优先级的范围是1到1000 值越小优先级越高。

ITEM_PIPELINES = {
    #  管道可以有很多个  那么管道是有优先级的  优先级的范围是1到1000   值越小优先级越高
   "scrapy_dangdang.pipelines.ScrapyDangdangPipeline": 300,
}

（4）编辑pipeline.py

# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: https://docs.scrapy.org/en/latest/topics/item-pipeline.html

# useful for handling different item types with a single interface
from itemadapter import ItemAdapter

# 如果想使用管道的话 那么就必须在settings中开启管道
class ScrapyDangdangPipeline:
    # 在爬虫文件开始的之前就执行的一个方法 ：open_spider
    def open_spider(self,spider):
        self.fp = open('book.json','w',encoding='utf-8')

    # 执行过程：process_item
    # item就是yield后面的book对象
    def process_item(self, item, spider):
        # 以下这种模式不推荐  因为每传递过来一个对象 那么就打开一次文件  对文件的操作过于频繁

        # # (1) write方法必须要写一个字符串 而不能是其他的对象
        # # (2) w模式 会每一个对象都打开一次文件 覆盖之前的内容
        # with open('book.json','a',encoding='utf-8')as fp:
        #     fp.write(str(item))

        self.fp.write(str(item))
        self.fp.write('\n')

        return item

    # 在爬虫文件执行完之后  执行的方法 ： close_spider
    def close_spider(self,spider):
        self.fp.close()

（5）执行，查看写入的json文件

scrapy crawl dang

5、多条管道使用

（1）pipelines.py定义管道类

pipelines.py中可以定义多个类，直接写即可。
类中有三个默认的方法，可以直接使用。

import urllib.request
class ScrapyDangdangDownloadPipeline:
    def process_item(self, item, spider):
        url = 'http:' + item.get('src')
        filename = './books/' + item.get('name') + '.jpg'
        urllib.request.urlretrieve(url = url, filename= filename)
        # 有返回值
        return item

（2）settings.py开启管道

ITEM_PIPELINES = {
    #  管道可以有很多个  那么管道是有优先级的  优先级的范围是1到1000   值越小优先级越高
   "scrapy_dangdang.pipelines.ScrapyDangdangPipeline": 300,

   'scrapy_dangdang.pipelines.ScrapyDangdangDownloadPipeline':301
}

（5）执行，查看写入的json文件与图片

先在spiders下创建books目录。

# 执行
scrapy crawl dang

6、获取多页数据

import scrapy
from scrapy_dangdang.items import ScrapyDangdangItem


class DangSpider(scrapy.Spider):
    name = "dang"
    allowed_domains = ["category.dangdang.com"]
    start_urls = ["http://category.dangdang.com/cp01.03.32.00.00.00.html"]

    base_url = 'http://category.dangdang.com/cp'
    page = 1
    def parse(self, response):
		# 。。。省略


#       每一页的爬取的业务逻辑全都是一样的，所以我们只需要将执行的那个页的请求再次调用parse方法
# 就可以了
#         http://category.dangdang.com/pg2-cp01.03.32.00.00.00.html
#         http://category.dangdang.com/pg3-cp01.03.32.00.00.00.html
#         http://category.dangdang.com/pg4-cp01.03.32.00.00.00.html

        if self.page < 100:
            self.page = self.page + 1

            url = self.base_url + str(self.page) + '-cp01.03.32.00.00.00.html'

#             怎么去调用parse方法
#             scrapy.Request就是scrpay的get请求
#             url就是请求地址
#             callback是你要执行的那个函数  注意不需要加（）
            yield scrapy.Request(url=url,callback=self.parse)

五、实战：获取电影天堂不同页面的数据

1、效果

获取电影天堂，第一页列表的电影名：

然后点击电影详情，再从第二页获取到详情中的图片：

2、核心代码

mv.py核心代码

import scrapy

from scrapy_movie_099.items import ScrapyMovie099Item

class MvSpider(scrapy.Spider):
    name = 'mv'
    allowed_domains = ['www.dygod.net']
    start_urls = ['https://www.dygod.net/html/gndy/china/index.html']

    def parse(self, response):
#         要第一个的名字 和 第二页的图片
        a_list = response.xpath('//div[@class="co_content8"]//td[2]//a[2]')

        for a in a_list:
            # 获取第一页的name 和 要点击的链接
            name = a.xpath('./text()').extract_first()
            href = a.xpath('./@href').extract_first()

            # 第二页的地址是
            url = 'https://www.dygod.net' + href

            # 对第二页的链接发起访问 并将name参数传入
            yield  scrapy.Request(url=url,callback=self.parse_second,meta={'name':name})

    def parse_second(self,response):
        # 注意 如果拿不到数据的情况下  一定检查你的xpath语法是否正确
        src = response.xpath('//div[@id="Zoom"]//img/@src').extract_first()
        # 接受到请求的那个meta参数的值
        name = response.meta['name']

        movie = ScrapyMovie099Item(src=src,name=name)

        yield movie

pipelines.py：

from itemadapter import ItemAdapter

class ScrapyMovie099Pipeline:

    def open_spider(self,spider):
        self.fp = open('movie.json','w',encoding='utf-8')

    def process_item(self, item, spider):

        self.fp.write(str(item))
        return item

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

settings.py中开启pipeline：

ITEM_PIPELINES = {
   'scrapy_movie_099.pipelines.ScrapyMovie099Pipeline': 300,
}

六、实战：使用CrawlSpider获取读书网的数据

1、CrawlSpider简介

CrawlSpider继承自scrapy.Spider，可以定义规则，再解析html内容的时候，可以根据链接规则提取出指定的链接，然后再向这些链接发送请求。

所以，如果有需要跟进链接的需求，就是爬取了网页之后，需要提取链接再次爬取，使用CrawlSpider是非常合适的。

提取链接常用语法：
链接提取器，在这里就可以写规则提取指定链接：

scrapy.linkextractors.LinkExtractor(
	allow = (), # 正则表达式，提取符合正则的链接
	deny = (), # （不用）正则表达式 不提取符合正则的链接
	allow_domains = (), # （不用）允许的域名
	deny_domains = (), # （不用）不允许的域名
	restrict_xpaths = (), # xpath，提取符合xpath规则的链接
	restrict_css = () # 提取符合选择器规则的链接
)

# 使用实例
# 正则用法：
links = LinkExtractor(allow = r'list_23_\d+\.html')
# xpath：
links = LinkExtractor(restrict_xpaths = r'//div[@class="x"]')
# css用法：
links = LinkExtractor(restrict_css='.x')

# 提取链接
links.extract_links(response)

2、创建项目

# 创建项目：scrapy startproject 项目的名字
scrapy startproject readbook

# 创建爬虫文件
# cd 项目名字\项目名字\spiders
cd readbook/readbook/Spiders
# scrapy genspider -t crawl 爬虫文件的名字  爬取的域名
scrapy genspider -t crawl read www.dushu.com/book/1188_1.html

我们发现，read.py内容和我们之前不太一样了：

3、定义item

class ReadbookItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    name = scrapy.Field()
    src = scrapy.Field()

4、提取数据

read.py：

import scrapy
from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule
from readbook.items import ReadbookItem

class ReadSpider(CrawlSpider):
    name = "read"
    allowed_domains = ["www.dushu.com"]
    # 注意，第一个url也要匹配规则！不然会跳过第一页
    start_urls = ["https://www.dushu.com/book/1188_1.html"]

    # 规则
    rules = (Rule(LinkExtractor(allow=r"/book/1188_\d+.html"), callback="parse_item", follow=True),)

    # 解析
    def parse_item(self, response):
        img_list = response.xpath('//div[@class="bookslist"]//img')

        for img in img_list:
            name = img.xpath('./@data-original').extract_first()
            src = img.xpath('./@alt').extract_first()

            book = ReadbookItem(name=name,src=src)
            yield book

5、定义pipeline

# settings.py
ITEM_PIPELINES = {
   "readbook.pipelines.ReadbookPipeline": 300,
}

# pipelines.py
from itemadapter import ItemAdapter

class ReadbookPipeline:
    def open_spider(self,spider):
        self.fp = open('book.json','w',encoding='utf-8')

    def process_item(self, item, spider):
        self.fp.write(str(item))
        return item

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

6、启动

 scrapy crawl read

执行完毕之后，查看book.json文件。

7、保存至mysql

安装pymysql：

# 进入到python安装目录的Scripts目录
d:
cd D:\python\Scripts
# 安装 可以使用国内源
pip install pymysql

添加一个pipeline：

# settings.py
ITEM_PIPELINES = {
   "readbook.pipelines.ReadbookPipeline": 300,
   # MysqlPipeline
   'readbook.pipelines.MysqlPipeline':301
}
# 参数中一个端口号 一个是字符集 都要注意
DB_HOST = '192.168.1.1'
# 端口号是一个整数
DB_PORT = 3306
DB_USER = 'root'
DB_PASSWROD = '123'
DB_NAME = 'spider01'
# utf-8的杠不允许写
DB_CHARSET = 'utf8'

pipelines.py：

# 加载settings文件
from scrapy.utils.project import get_project_settings
import pymysql


class MysqlPipeline:

    def open_spider(self,spider):
        settings = get_project_settings()
        self.host = settings['DB_HOST']
        self.port =settings['DB_PORT']
        self.user =settings['DB_USER']
        self.password =settings['DB_PASSWROD']
        self.name =settings['DB_NAME']
        self.charset =settings['DB_CHARSET']

        self.connect()

    def connect(self):
        self.conn = pymysql.connect(
                            host=self.host,
                            port=self.port,
                            user=self.user,
                            password=self.password,
                            db=self.name,
                            charset=self.charset
        )

        self.cursor = self.conn.cursor()


    def process_item(self, item, spider):

        sql = 'insert into book(name,src) values("{}","{}")'.format(item['name'],item['src'])
        # 执行sql语句
        self.cursor.execute(sql)
        # 提交
        self.conn.commit()
        return item

    def close_spider(self,spider):
        self.cursor.close()
        self.conn.close()

七、实战：发送post请求

关键代码：

import scrapy

import json

class TestpostSpider(scrapy.Spider):
    name = 'testpost'
    allowed_domains = ['https://fanyi.baidu.com/sug']
    # post请求 如果没有参数 那么这个请求将没有任何意义
    # 所以start_urls 也没有用了
    # parse方法也没有用了
    # start_urls = ['https://fanyi.baidu.com/sug/']
    #
    # def parse(self, response):
    #     pass



	# start_requests是一个固定方法
    def start_requests(self):
        url = 'https://fanyi.baidu.com/sug'

        data = {
            'kw': 'final'
        }

        yield scrapy.FormRequest(url=url,formdata=data,callback=self.parse_second)

    def parse_second(self,response):

        content = response.text
        obj = json.loads(content,encoding='utf-8')

        print(obj)