Scrapy框架讲解

诉苦#

最近是我的期末实验课周

连续五天的早八四节连上，~~感觉有一点死~~，正好课上是做爬虫相关的东西我就来记录一下吧

下面是我的课表

期末课表

期末周的爬虫还是挺简单的，都是爬取一些电影评论，简介这些。基本的爬虫都大差不差，一个模板就能处理大部分的东西了，访问，cookie，html，取数据，保存数据。

scrapy#

Scrapy 是一个异步、高性能的 Python 爬虫框架，其实我认为这些小打小闹的爬虫用scrapy太大材小用了

架构#

1
┌─────────────────────────────────────────────────────────┐
2
│                      Scrapy Engine                      │
3
├─────────────────────────────────────────────────────────┤
4
│          调度器 (Scheduler)  ←─→ 下载器 (Downloader)      │
5
└─────────────────────────────────────────────────────────┘
6
         ↓                            ↓
7
┌─────────────────┐        ┌─────────────────────────┐
8
│    Spider       │        │   Downloader Middlewares│
9
│  (爬虫/解析器)    │        │    (下载器中间件)         │
10
└─────────────────┘        └─────────────────────────┘
11
         ↓
12
┌─────────────────┐        ┌─────────────────────────┐
13
│ Item Pipeline   │        │   Spider Middlewares    │
14
│ (项目管道)       │        │    (爬虫中间件)           │
15
└─────────────────┘        └─────────────────────────┘

引擎(Engine)
- 控制所有模块之间的数据流，并在条件触发时触发事件。
调度器(Scheduler)
- 接收引擎发过来的请求，并将其入队，以便在引擎请求时提供给引擎。
下载器(Downloader)
- 负责下载网页内容，并将内容返回给蜘蛛。
Spider类
- 用户自定义的类，用于解析响应并提取Item（即数据）或额外的请求。
Item Pipeline
- 负责处理爬虫提取的Item，典型的任务包括清理、验证和持久化（例如存储到数据库）。
下载器中间件(Downloader Middlewares)
- 位于引擎和下载器之间的钩子框架，主要用于处理请求和响应。
爬虫中间件(Spider Middlewares)
- 位于引擎和爬虫之间的钩子框架，能够处理爬虫的输入（响应）和输出（Items和请求）。

基本项目结构#

1
myproject/
2
├── scrapy.cfg                    # 项目配置文件
3
└── myproject/                    # 项目Python模块
4
    ├── __init__.py
5
    ├── items.py                  # 定义Item数据结构
6
    ├── middlewares.py            # 中间件定义
7
    ├── pipelines.py              # 管道处理 数据保存
8
    ├── settings.py               # 项目设置
9
    └── spiders/                  # 爬虫目录
10
        ├── __init__.py
11
        └── myspider.py           # 爬虫实现

案例讲解#

这里展示一个爬取当当网书籍信息，我会在这里面体现scrapy的异步，高性能，高解耦度

安装#

1
pip install scrapy

创建#

1
# 创建一个项目
2
scrapy startproject dangdang_spider
3
# 进入
4
cd dangdang_spider
5
# 生成爬虫 这里会在spider.py文件里生成一些相关的代码
6
scrapy genspider dangdang e.dangdang.com

以上都执行后会生成这样的项目结构

项目结构

定义数据结构#

1
# 文件在 item.py
2
import scrapy
3

4

5
class DangdangSpiderItem(scrapy.Item):
6
    book_name = scrapy.Field()
7
    author = scrapy.Field()
8
    book_price = scrapy.Field()
9
    book_profile = scrapy.Field()
10
    book_coverpic = scrapy.Field()
11
    book_contribution = scrapy.Field()
12
    catalogue = scrapy.Field()
13
    point_num = scrapy.Field()

编写主要得逻辑代码#

1
# 文件为 spiders/dangdang.py
2
import scrapy
3
import json
4
from lxml import etree
5

6
class DangdangSpider(scrapy.Spider):
7
    name = "dangdang"
8
    allowed_domains = ["e.dangdang.com"]
9
    heasers = {
10
        "user-agent":
11
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)"
12
    }
13
    def start_requests(self):
14
        '''设置翻页逻辑'''
15

16
        baseurl = '''https://e.dangdang.com/media/api.go?action=mediaCategoryLeaf&promotionType=1&deviceSerialNo=html5&macAddr=html5&channelType=html5&permanentId=20251224082506162502645867115466839&returnType=json&channelId=70000&clientVersionNo=6.8.0&platformSource=DDDS-P&fromPlatform=106&deviceType=pconline&token=&start={}&end={}&category=GLX&dimension=dd_sale&order=0'''
17
        for i in range(0,100,21):
18
            url = baseurl.format(i,i+20)
19
            yield scrapy.Request(url=url, callback=self.parse)
20

21
    def second_url_func(self, response):
22
        '''处理详情页面，获取更多信息'''
23
        # 处理html
24
        data_list = response.meta['data_list']
25
        res = response.text
26
        html = etree.HTML(res)
27
        # 使用xpath提取数据
28
        book_contribution = html.xpath('//div[@class="explain_box"]/p[2]/span/a/text()')
29
        book_contribution = book_contribution[0].strip() if book_contribution else ''
30
        catalogue = html.xpath('//div[@class="txt"]/p/text()')
31

32
        # 传给pipelines
33
        yield {
34
            'book_name': data_list['book_name'],
35
            'author': data_list['author'],
36
            'book_price': data_list['book_price'],
37
            'book_profile': data_list['book_profile'],
38
            'book_coverpic': data_list['book_coverpic'],
39
            'book_contribution': book_contribution,
40
            'catalogue': catalogue,
41

42
        }
43

44
    def parse(self, response):
45
        '''解析数据'''
46
        # 基本设置,这里的响应是json格式的数据
47
        second_url = "https://e.dangdang.com/products/{}.html"
48
        res = response.text
49
        data = json.loads(res)
50

51
        thing = data['data']
52
        salelist = thing['saleList']
53

54
        # 得到数据
55
        for i,book in enumerate(salelist):
56
            # point_num = count + i
57
            inter_msg = book['mediaList']
58
            data_list = {
59
                "inter_msg" : book['mediaList'],
60
                "book_name" : inter_msg[0]['title'],
61
                "author" : inter_msg[0]['authorPenname'],
62
                "book_price" : inter_msg[0]['salePrice'],
63
                "book_profile" : inter_msg[0]['descs'],
64
                "book_coverpic" : inter_msg[0]['coverPic'],
65

66
            }
67
            # 拿到id构造详情页url
68
            saleid = book['saleId']
69

70
            yield scrapy.Request(
71
                url=second_url.format(saleid),  # 详情页URL
72
                callback=self.second_url_func,  # 指定详情页处理函数
73
                meta={'data_list': data_list},  # 传递已获取的数据
74
                headers=self.heasers
75
            )

Ajax 访问#

这里我来详细讲解一下逻辑，在当当网上的书籍信息访问是使用的Ajax（AJAX（Asynchronous JavaScript and XML）是一种在不重新加载整个页面的情况下，与服务器交换数据并更新部分网页内容的技术。)

上面代码我们输入的关键词为“经管”

这样的话我们就可以伪造 ajax 的 url 就是上面代码的 baseurl，调试界面找到的url如下

1
baseurl = '''https://e.dangdang.com/media/api.go?action=mediaCategoryLeaf&promotionType=1&deviceSerialNo=html5&macAddr=html5&channelType=html5&permanentId=20251224082506162502645867115466839&returnType=json&channelId=70000&clientVersionNo=6.8.0&platformSource=DDDS-P&fromPlatform=106&deviceType=pconline&token=&start={}&end={}&category=GLX&dimension=dd_sale&order=0'''

ajax请求

这里的 start 和 end 参数表示该次请求的范围，我的代码里是仿造该网的格式

1
for i in range(0,100,21):
2
    url = baseurl.format(i,i+20)
3
    yield scrapy.Request(url=url, callback=self.parse)

信息提取#

该访问的响应如图

我们提取相关信息

1
res = response.text
2
        data = json.loads(res)
3

4
        thing = data['data']
5
        salelist = thing['saleList']
6

7
        # 得到数据
8
        for i,book in enumerate(salelist):
9
            # point_num = count + i
10
            inter_msg = book['mediaList']
11
            data_list = {
12
                "inter_msg" : book['mediaList'],
13
                "book_name" : inter_msg[0]['title'],
14
                "author" : inter_msg[0]['authorPenname'],
15
                "book_price" : inter_msg[0]['salePrice'],
16
                "book_profile" : inter_msg[0]['descs'],
17
                "book_coverpic" : inter_msg[0]['coverPic'],
18

19
            }

进一步提取和保存#

然后这里我我想要书籍的 出版社和目录信息 ，但是上面的请求没有，所以我做了一个新的url拼接和跳转

1
saleid = book['saleId']
2

3
            yield scrapy.Request(
4
                url=second_url.format(saleid),  # 详情页URL
5
                callback=self.second_url_func,  # 指定详情页处理函数
6
                meta={'data_list': data_list},  # 传递已获取的数据
7
                headers=self.heasers
8
            )

上面传输已经拿到的数据，在新的页面也拿到出版社和目录信息的信息并将信息传给pipelines

1
book_contribution = html.xpath('//div[@class="explain_box"]/p[2]/span/a/text()')
2
        book_contribution = book_contribution[0].strip() if book_contribution else ''
3
        catalogue = html.xpath('//div[@class="txt"]/p/text()')
4
        # 传给pipelines
5
yield {
6
    'book_name': data_list['book_name'],
7
    'author': data_list['author'],
8
    'book_price': data_list['book_price'],
9
    'book_profile': data_list['book_profile'],
10
    'book_coverpic': data_list['book_coverpic'],
11
    'book_contribution': book_contribution,
12
    'catalogue': catalogue,
13

14
}

pipelines保存#

1
import csv
2

3
class DangdangSpiderPipeline:
4
    def __init__(self):
5
        self.filename = 'dangdang_books.csv'
6
        self.file = None
7
        self.writer = None
8

9
    def open_spider(self, spider):
10
        """爬虫开始时调用"""
11
        # 创建文件并写入表头
12
        self.file = open(self.filename, 'w', newline='', encoding='utf-8-sig')
13

14
        # 定义CSV表头
15
        fieldnames = [
16
            '书名', '作者', '价格', '简介',
17
            '封面图', '出版社', '目录', #'序号'
18
        ]
19

20
        self.writer = csv.DictWriter(self.file, fieldnames=fieldnames)
21
        self.writer.writeheader()
22

23
    def process_item(self, item, spider):
24
        """处理每个item"""
25
        try:
26
            # 转换为字典
27
            book_data = dict(item)
28

29
            # 准备写入CSV的数据
30
            csv_data = {
31
                '书名': book_data.get('book_name', ''),
32
                '作者': book_data.get('author', ''),
33
                '价格': book_data.get('book_price', ''),
34
                '简介': book_data.get('book_profile', ''),
35
                '封面图': book_data.get('book_coverpic', ''),
36
                '出版社': book_data.get('book_contribution', ''),
37
                '目录': self._format_catalogue(book_data.get('catalogue', '')),
38
                # '序号': book_data.get('point_num', ''),
39
            }
40

41
            # 写入CSV
42
            self.writer.writerow(csv_data)
43

44
        except Exception as e:
45
            spider.logger.error(f'写入数据时出错: {e}')
46

47
        return item
48

49
    def _format_catalogue(self, catalogue):
50
        """格式化目录数据"""
51
        if isinstance(catalogue, list):
52
            return ' | '.join([str(item) for item in catalogue])
53
        return str(catalogue)
54

55
    def close_spider(self, spider):
56
        """爬虫结束时调用"""
57
        if self.file:
58
            self.file.close()
59
            spider.logger.info(f'数据已保存到 {self.filename}')

这里保存csv文件里

setting#

这里可能每个人都不一样我的配置是

1
BOT_NAME = "dangdang_spider"
2

3
SPIDER_MODULES = ["dangdang_spider.spiders"]
4
NEWSPIDER_MODULE = "dangdang_spider.spiders"
5

6
ADDONS = {}
7
DOWNLOAD_DELAY = 1
8
RANDOMIZE_DOWNLOAD_DELAY = True
9
CONCURRENT_REQUESTS = 8
10
CONCURRENT_REQUESTS_PER_DOMAIN = 4
11
CONCURRENT_REQUESTS_PER_IP = 4
12
CONCURRENT_REQUESTS_PER_DOMAIN = 1
13
DOWNLOAD_DELAY = 1
14
COOKIES_ENABLED = True
15
FEED_EXPORT_ENCODING = "utf-8"
16
ITEM_PIPELINES = {
17
   "dangdang_spider.pipelines.DangdangSpiderPipeline": 300,
18
}
19

20
EXTENSIONS = {
21
    'scrapy.extensions.telnet.TelnetConsole': None,
22
}

运行#

1
scrapy crawl dangdang

在终端执行，需要有相关的环境，需要额外下载 lxml，pip install lxml

一些细节#

具体的执行过程 start_requests ==> parse ==> second_url_func ==> piplines

整个过程是异步执行，高效，分工明确，解耦度高

数据流过程

1
┌─────────────┐   请求   ┌─────────────┐   请求   ┌─────────────┐
2
│  列表页API   │ ──────> │    Spider   │ ──────> │   详情页HTML │
3
│ (start_urls)│         │  (parse())  │         │(second_url_func())
4
└─────────────┘         └─────────────┘         └─────────────┘
5
       ↑                       ↑                       ↑
6
       │        JSON响应       │        HTML响应       │
7
       └───────────────────────┴───────────────────────┘
8
                                       ↓
9
                                ┌─────────────┐
10
                                │  提取合并数据  │
11
                                │   yield item │
12
                                └─────────────┘
13
                                       ↓
14
                                ┌─────────────┐
15
                                │Item Pipeline│
16
                                │ (清洗/存储)   │
17
                                └─────────────┘

小结#

这里的案例需要一些爬虫的基础，其实还有很多可以优化的，简单了解一下scrapy到是够了，等我后面有时间再写一篇爬虫的吧

上面的案例体现了scrapy的高性能，scrapy的作用远远不止如此，middlewares和pipeline还有很多可以玩的，可以去看看源码里是怎么实现的