ToB企服应用市场:ToB评测及商务社交产业平台

标题: 【爬虫】利用 Scrapy 框架爬取豆瓣电影 Top 250 数据的完整教程 [打印本页]
作者: 小秦哥    时间: 昨天 04:36
标题: 【爬虫】利用 Scrapy 框架爬取豆瓣电影 Top 250 数据的完整教程
前言

在大数据和网络爬虫范畴，Scrapy 是一个功能强大且广泛利用的开源爬虫框架。它可以或许帮助我们快速地构建爬虫项目，并高效地从各种网站中提取数据。在本篇文章中，我将带大家从零开始利用 Scrapy 框架，构建一个简单的爬虫项目，爬取 豆瓣电影 Top 250 的电影信息。
Scrapy 官方文档：Scrapy Documentation
豆瓣电影 Top 250 ：豆瓣电影 Top 250
本文的爬虫项目设置如下：

如果你利用的是其他体系或 IDE，也可以按照本文的步骤进行操纵，只需根据自己的情况做出相应调整即可。
情况准备

1. 安装 Python

在利用 Scrapy 之前，确保你已经安装了 Python。如果没有，请先安装 Python 3.6+ 版本。你可以访问 Python 官方网站 下载并安装最新版的 Python。
安装完成后，打开下令行窗口，输入以下下令查抄是否安装成功：
  1. python --version
复制代码
2. 安装 Scrapy

确认安装了 Python 后，你可以利用 pip 安装 Scrapy。pip 是 Python 的包管理工具，它可以或许帮助我们安装各种第三方库。
在下令行窗口输入以下下令：
  1. pip install scrapy
复制代码
安装完成后，可以通过以下下令查抄 Scrapy 是否安装成功：
  1. scrapy version
复制代码
3. 安装 Anaconda（可选）

如果你更喜欢利用假造情况管理工具，可以选择安装 Anaconda，它可以或许帮助你更方便地管理项目中的 Python 依赖。你可以从 Anaconda 官方网站 下载并安装 Anaconda。
利用 Anaconda 创建一个假造情况，并激活情况后再安装 Scrapy：
  1. conda create -n scrapy_env python=3.8
  2. conda activate scrapy_env
  3. pip install scrapy
复制代码
4. 创建 Scrapy 项目

安装 Scrapy 完成后，我们可以开始创建一个新的 Scrapy 项目。在终端中，进入你希望存放项目的目录，然后运行以下下令：
  1. scrapy startproject DoubanProject
复制代码
这将创建一个名为 DoubanProject 的 Scrapy 项目，此中包罗 Scrapy 默认的文件夹和文件结构：
  1. DoubanProject/
  2. ├── DoubanProject/
  3. │   ├── __init__.py
  4. │   ├── items.py
  5. │   ├── middlewares.py
  6. │   ├── pipelines.py
  7. │   ├── settings.py
  8. └── spiders/
  9.     ├── __init__.py
  10.     └── douban.py
复制代码
爬虫的编写

1. 编写 items.py

在 items.py 文件中定义我们要爬取的数据字段。豆瓣 Top 250 页面包罗电影的排名、名称、简介、评分、评价人数和电影海报链接等信息，因此我们必要定义相应的数据字段。
  1. import scrapy
  3. class DoubanprojectItem(scrapy.Item):
  4.     rank = scrapy.Field()  # 电影排名
  5.     movie_name = scrapy.Field()  # 电影名称
  6.     movie_introduction = scrapy.Field()  # 电影简介
  7.     picture = scrapy.Field()  # 电影海报链接
  8.     movie_rating = scrapy.Field()  # 电影评分
  9.     evaluators = scrapy.Field()  # 评价人数
复制代码
2. 编写爬虫文件 douban.py

在 spiders 目录下，我们必要创建一个爬虫文件 douban.py 来定义具体的爬虫逻辑。Scrapy 通过 Spider 类来定义爬虫，它包罗了爬虫的名称、答应访问的域名、起始 URL，以及如何解析和处理抓取到的数据。
2.1 定义爬虫文件

首先，在 spiders 目录下创建 douban.py 文件，编写代码如下：
  1. import scrapy
  2. from scrapy import Selector, Request
  3. from ..items import DoubanprojectItem  # 导入之前定义的 item 数据结构
复制代码
2.2 创建 DoubanSpider 类

在 douban.py 文件中定义一个爬虫类 DoubanSpider，继承自 scrapy.Spider。name 是爬虫的名字，用于在下令行中启动爬虫，allowed_domains 是答应爬虫访问的域名，start_urls 是爬虫开始爬取的页面 URL 列表。
  1. class DoubanSpider(scrapy.Spider):
  2.     name = "douban"  # 爬虫的唯一名称
  3.     allowed_domains = ["movie.douban.com"]  # 允许的域名范围
  4.     start_urls = ["https://movie.douban.com/top250"]  # 爬虫从这个 URL 开始抓取
复制代码
2.3 编写 parse 方法

parse 是 Scrapy 中的默认解析方法，爬虫启动后，Scrapy 会自动下载 start_urls 中的页面，并将相应传递给这个方法。在这里，我们会利用 XPath 来提取电影信息。
2.4 提取电影信息

接下来，我们必要提取每部电影的具体信息。我们定义了 DoubanprojectItem 来存储每部电影的字段信息，并通过 XPath 提取页面中的对应字段。
  1.         for movie in movie_items:
  2.             item = DoubanprojectItem()  # 创建 DoubanprojectItem 实例
  3.             # 提取电影的各个字段
  4.             item['rank'] = movie.xpath('.//div[@class="pic"]/em/text()').extract_first()  # 电影排名
  5.             item['movie_name'] = movie.xpath('.//div[@class="hd"]//span[1]/text()').extract_first()  # 电影名称
  6.             item['movie_introduction'] = movie.xpath('.//div[@class="bd"]//span[@class="inq"]/text()').extract_first(default='无')  # 电影简介
  7.             item['picture'] = movie.xpath('.//div[@class="pic"]/a/img/@src').extract_first()  # 电影海报链接
  8.             item['movie_rating'] = movie.xpath('.//div[@class="star"]/span[2]/text()').extract_first()  # 电影评分
  9.             item['evaluators'] = movie.xpath('.//div[@class="star"]/span[4]/text()').extract_first()  # 评价人数
  10.             # 返回提取到的 item
  11.             yield item
复制代码
2.5 处理分页

豆瓣电影的 Top 250 列表分成了 10 页，每页显示 25 部电影。在爬取完第一页后，我们必要继续爬取剩下的页面。通过提取页面底部的“下一页”链接，来实现分页抓取。
  1.         # 获取下一页的链接
  2.         next_link = sel.xpath('//span[@class="next"]/link/@href').extract_first()
  3.         if next_link:
  4.             # 如果存在下一页链接，构造请求并递归调用 parse 方法
  5.             yield Request(url=response.urljoin(next_link), callback=self.parse)
复制代码
2.6 完整的 douban.py 文件

完整的爬虫文件 douban.py 如下：
  1. import scrapy
  2. from scrapy import Selector, Request
  3. from ..items import DoubanprojectItem  # 导入 item 数据结构
  5. class DoubanSpider(scrapy.Spider):
  6.     name = "douban"  # 爬虫的名称
  7.     allowed_domains = ["movie.douban.com"]  # 允许的域名
  8.     start_urls = ["https://movie.douban.com/top250"]  # 爬虫起始页面
  10.     def parse(self, response):
  11.         sel = Selector(response)  # 解析页面
  12.         movie_items = sel.xpath('//div[@class="article"]//ol[@class="grid_view"]/li')  # 获取电影条目列表
  14.         for movie in movie_items:
  15.             item = DoubanprojectItem()  # 创建 item 实例
  16.             # 提取电影信息
  17.             item['rank'] = movie.xpath('.//div[@class="pic"]/em/text()').extract_first()
  18.             item['movie_name'] = movie.xpath('.//div[@class="hd"]//span[1]/text()').extract_first()
  19.             item['movie_introduction'] = movie.xpath('.//div[@class="bd"]//span[@class="inq"]/text()').extract_first(default='无')
  20.             item['picture'] = movie.xpath('.//div[@class="pic"]/a/img/@src').extract_first()
  21.             item['movie_rating'] = movie.xpath('.//div[@class="star"]/span[2]/text()').extract_first()
  22.             item['evaluators'] = movie.xpath('.//div[@class="star"]/span[4]/text()').extract_first()
  23.             
  24.             yield item  # 返回 item
  26.         # 处理分页
  27.         next_link = sel.xpath('//span[@class="next"]/link/@href').extract_first()
  28.         if next_link:
  29.             yield Request(url=response.urljoin(next_link), callback=self.parse)
复制代码
具体表明：


3. 编写 pipelines.py

在 Scrapy 中，pipelines.py 文件用于处理爬取到的数据。这里，我们要将抓取到的豆瓣电影数据生存到 Excel 文件中。为了实现这一点，我们会利用 Python 的 openpyxl 库，它是一个专门用于处理 Excel 文件的库。
3.1 安装 openpyxl

首先，确保你已经安装了 openpyxl，如果没有安装，可以通过 pip 进行安装：
  1. pip install openpyxl
复制代码
3.2 创建 DoubanprojectPipeline 类

DoubanprojectPipeline 类将处理从爬虫传递过来的数据，并将这些数据写入 Excel 文件。Scrapy 中的 Pipeline 类通常有三个方法：open_spider、process_item 和 close_spider。

以下是具体的代码表明：
  1. import openpyxl  # 导入处理 Excel 文件的库
  2. from .items import DoubanprojectItem  # 导入定义好的 Item 数据结构
  4. class DoubanprojectPipeline:
  5.     def __init__(self):
  6.         """
  7.         初始化方法，在爬虫开始时被调用，初始化 Excel 工作簿和表格。
  8.         """
  9.         self.wb = openpyxl.Workbook()  # 创建一个新的 Excel 工作簿
  10.         self.sheet = self.wb.active  # 获取工作簿的活动表格
  11.         self.sheet.title = '豆瓣电影Top250'  # 设置表格的标题
  12.         # 在第一行写入表头，表示每列的意义
  13.         self.sheet.append(('电影排名', '电影名称', '电影简介', '电影海报', '电影评分', '观影人数'))
  15.     def open_spider(self, spider):
  16.         """
  17.         当爬虫被启动时调用该方法。
  18.         :param spider: 当前运行的爬虫对象
  19.         """
  20.         print('开始爬虫...')  # 可以选择在控制台输出提示信息，表示爬虫开始运行
  22.     def process_item(self, item: DoubanprojectItem, spider):
  23.         """
  24.         处理每个爬取到的数据项（item），将其保存到 Excel 文件中。
  25.         :param item: 爬取到的电影数据
  26.         :param spider: 当前运行的爬虫对象
  27.         :return: 返回处理后的 item
  28.         """
  29.         # 将每部电影的信息以一行的形式写入 Excel
  30.         self.sheet.append((
  31.             item['rank'],  # 电影排名
  32.             item['movie_name'],  # 电影名称
  33.             item['movie_introduction'],  # 电影简介
  34.             item['picture'],  # 电影海报链接
  35.             item['movie_rating'],  # 电影评分
  36.             item['evaluators']  # 观影人数
  37.         ))
  38.         # 返回 item 是 Scrapy Pipeline 的标准流程，方便后续可能有其他 pipeline 处理
  39.         return item
  41.     def close_spider(self, spider):
  42.         """
  43.         当爬虫关闭时调用，保存 Excel 文件。
  44.         :param spider: 当前运行的爬虫对象
  45.         """
  46.         print("爬虫结束....")  # 输出爬虫结束的提示
  47.         # 保存 Excel 文件到指定路径
  48.         self.wb.save('豆瓣电影数据.xlsx')
复制代码
3.3 具体表明代码

3.4 设置 pipelines

为了让 Scrapy 利用我们的 DoubanprojectPipeline，我们必要在 settings.py 中启用该 Pipeline。
打开 settings.py 文件，并添加以下代码：
  1. # 启用我们定义的 Pipeline
  2. ITEM_PIPELINES = {
  3.    "DoubanProject.pipelines.DoubanprojectPipeline": 300,
  4. }
复制代码
300 是该 Pipeline 的优先级，数字越小优先级越高。这里我们设置为 300，表示优先处理该 Pipeline。
通过这个 pipelines.py 文件，爬取到的豆瓣电影数据将会被逐条写入 Excel 文件。当爬虫竣事时，完整的 Excel 文件就已经生成好了，内里包罗了所有抓取到的电影信息。
4. 设置 settings.py

为了确保爬虫可以或许顺利地抓取豆瓣的电影数据并避免触发反爬机制，我们必要对 settings.py 文件进行设置。settings.py 文件是 Scrapy 项目的全局设置文件，所有的爬虫举动（如哀求频率、哀求头信息、爬虫管道等）都在这里进行设置。下面我们具体表明如何设置 settings.py。
4.1 设置 BOT_NAME

BOT_NAME 定义了 Scrapy 项目的名称，Scrapy 会根据这个名称来辨认项目。你可以将其保持默认或根据你的项目需求进行修改：
  1. BOT_NAME = "DoubanProject"
复制代码
4.2 设置 SPIDER_MODULES 和 NEWSPIDER_MODULE

SPIDER_MODULES 和 NEWSPIDER_MODULE 定义了爬虫的存放路径和默认新爬虫生成位置。

4.3 设置 User-Agent

User-Agent 是 HTTP 哀求头中的一个重要字段，它告诉目标服务器你的哀求来自哪个浏览器或客户端。很多网站会通过检测 User-Agent 来区分正常用户和爬虫。为了避免被辨认为爬虫，我们可以将 User-Agent 字段伪装成常见的浏览器。
  1. USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.61 Safari/537.36'
复制代码
在上面的设置中，我们将 User-Agent 伪装成了 Google Chrome 浏览器。这有助于进步爬虫的潜伏性，避免被目标网站的反爬虫机制辨认和封禁。
4.4 禁用 robots.txt 规则

很多网站利用 robots.txt 文件来限制爬虫访问某些页面。为了可以或许抓取豆瓣的内容，我们必要将 Scrapy 的 ROBOTSTXT_OBEY 设置为 False，忽略 robots.txt 规则。
  1. ROBOTSTXT_OBEY = False
复制代码
  注意：只管我们在这里禁用了 robots.txt，实际开发时应尽量遵循网站的爬虫规则，避免给网站带来过多负担。
  4.5 设置下载延迟 DOWNLOAD_DELAY

为了避免触发网站的反爬虫机制，建议设置一个下载延迟。DOWNLOAD_DELAY 定义了每个哀求之间的时间隔断，防止爬虫哀求频率过高，给服务器带来过大压力。通常，1-3 秒的延迟是公道的选择。
  1. DOWNLOAD_DELAY = 2  # 设置每个请求之间的时间间隔为 2 秒
复制代码
你还可以设置 RANDOMIZE_DOWNLOAD_DELAY 为 True，让每次哀求之间的延迟时间随机变革，这样可以进一步避免被反爬虫机制发现。
  1. RANDOMIZE_DOWNLOAD_DELAY = True
复制代码
4.6 启用 Cookies

有些网站会利用 Cookies 来跟踪用户的举动和状态。如果不启用 Cookies，有时会导致爬取数据不完整或被限制访问。我们在这里启用 Scrapy 的 COOKIES_ENABLED 设置：
  1. COOKIES_ENABLED = True
复制代码
这将答应爬虫在哀求过程中自动处理 Cookies。
4.7 启用 Item Pipelines

Item Pipelines 负责处理爬虫提取到的数据，并将其生存到不同的输出格式中。在这里，我们已经在 pipelines.py 中编写了一个 Pipeline 来将电影数据生存到 Excel 文件中。接下来必要在 settings.py 中启用这个 Pipeline。
  1. ITEM_PIPELINES = {
  2.    "DoubanProject.pipelines.DoubanprojectPipeline": 300,
  3. }
复制代码
数字 300 代表优先级，Scrapy 会根据优先级的数字巨细依次执行不同的 Pipelines。数字越小，优先级越高。
4.8 设置其他默认设置

最后，确保 Scrapy 的其他设置与最新版本兼容。这里我们设置了 REQUEST_FINGERPRINTER_IMPLEMENTATION 和 TWISTED_REACTOR，它们是 Scrapy 的内部设置，用于确保兼容性和性能优化。
  1. # 设置未来兼容性
  2. REQUEST_FINGERPRINTER_IMPLEMENTATION = "2.7"
  3. TWISTED_REACTOR = "twisted.internet.asyncioreactor.AsyncioSelectorReactor"
  4. FEED_EXPORT_ENCODING = "utf-8"  # 确保导出文件的编码为 UTF-8
复制代码
修改后的 settings.py 文件完整代码：

  1. BOT_NAME = "DoubanProject"
  2. SPIDER_MODULES = ["DoubanProject.spiders"]NEWSPIDER_MODULE = "DoubanProject.spiders"# 伪装成正常的浏览器USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.61 Safari/537.36'
  3. # 不服从 robots.txt 规则ROBOTSTXT_OBEY = False
  4. # 启用 CookiesCOOKIES_ENABLED = True
  5. # 设置下载延迟，避免被封禁DOWNLOAD_DELAY = 2  # 每次哀求隔断2秒RANDOMIZE_DOWNLOAD_DELAY = True
  6.   # 随机化下载延迟# 设置默认哀求头，模仿真实用户DEFAULT_REQUEST_HEADERS = {    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',    'Accept-Language': 'zh-CN,zh;q=0.9',    'Referer': 'https://www.douban.com/',}# 启用下载中间件DOWNLOADER_MIDDLEWARES = {    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,    'scrapy.downloadermiddlewares.cookies.CookiesMiddleware': 700,}# 启用 Item PipelinesITEM_PIPELINES = {
  7.    "DoubanProject.pipelines.DoubanprojectPipeline": 300,
  8. }
  9. # 启用 AutoThrottle 扩展，控制并发哀求速度AUTOTHROTTLE_ENABLED = TrueAUTOTHROTTLE_START_DELAY = 5  # 初始延迟AUTOTHROTTLE_MAX_DELAY = 60  # 最大延迟AUTOTHROTTLE_TARGET_CONCURRENCY = 1.0  # 每个服务器的并发哀求数目AUTOTHROTTLE_DEBUG = False  # 禁用调试信息显示# HTTP缓存设置（可选）HTTPCACHE_ENABLED = False# 设置未来兼容性REQUEST_FINGERPRINTER_IMPLEMENTATION = "2.7"TWISTED_REACTOR = "twisted.internet.asyncioreactor.AsyncioSelectorReactor"FEED_EXPORT_ENCODING = "utf-8"
复制代码
终端运行爬虫 douban ：

  1. scrapy crawl douban
复制代码
运行后，爬虫将抓取豆瓣电影 Top 250 的数据并生存到 豆瓣电影数据.xlsx 文件中。
导入 MySQL 数据库

在本节中，我们将先容如何将抓取的豆瓣电影数据生存到 MySQL 数据库中。Scrapy 提供了灵活的管道机制，可以将抓取的数据导入到多种存储平台。通过下面的步骤，我们将爬取的数据存储到 MySQL 数据库中。
1. 在 MySQL 中创建数据库

首先，确保你已经安装并启动了 MySQL 数据库。在 MySQL 中，我们必要创建一个数据库和对应的数据表来存储抓取到的电影信息。
创建数据库：
  1. -- MySQL 8.0 及以上版本
  2. create database douban_movie;
  4. -- 如果你使用的是 MySQL 8.0 以下版本，请使用以下命令指定编码为 utf8mb4
  5. create database douban_movie default charset=utf8mb4;
复制代码
切换到你创建的数据库：
  1. use douban_movie;
复制代码
2. 在数据库中创建数据表

在刚刚创建的 douban_movie 数据库中，我们必要创建一个表 movie_data 来存储爬取到的电影信息。表结构如下：
  1. CREATE TABLE movie_data(
  2.     rank varchar(20),                  -- 电影排名
  3.     movie_name varchar(30),            -- 电影名称
  4.     movie_introduction varchar(100),   -- 电影简介
  5.     picture varchar(100),              -- 电影海报链接
  6.     movie_rating varchar(100),         -- 电影评分
  7.     evaluators varchar(100)            -- 评价人数
  8. ) character set=utf8;
复制代码
3. 修改 pipelines.py，将数据生存到 MySQL

接下来，我们必要在 pipelines.py 文件中编写代码，将爬取到的数据生存到 MySQL 数据库中。我们会利用 pymysql 库来操纵 MySQL。
安装 pymysql：
  1. pip install pymysql
复制代码
然后，在 pipelines.py 文件中添加如下代码：
  1. import pymysql
  2. from .items import DoubanprojectItem  # 导入定义好的 item 数据结构
  4. class MysqlPipeline:
  5.     def __init__(self, host, database, user, password, port):
  6.         """
  7.         初始化 MySQL 数据库连接配置
  8.         """
  9.         self.host = host
  10.         self.database = database
  11.         self.user = user
  12.         self.password = password
  13.         self.port = port
  15.     @classmethod
  16.     def from_crawler(cls, crawler):
  17.         """
  18.         从 Scrapy 项目的 settings.py 文件中读取 MySQL 的连接信息
  19.         """
  20.         return cls(
  21.             host=crawler.settings.get('MYSQL_HOST'),
  22.             database=crawler.settings.get('MYSQL_DATABASE'),
  23.             user=crawler.settings.get('MYSQL_USER'),
  24.             password=crawler.settings.get('MYSQL_PASSWORD'),
  25.             port=crawler.settings.get('MYSQL_PORT')
  26.         )
  28.     def open_spider(self, spider):
  29.         """
  30.         爬虫启动时打开数据库连接
  31.         """
  32.         print('打开数据库连接....')
  33.         self.db = pymysql.connect(host=self.host, user=self.user, password=self.password, database=self.database,
  34.                                   port=self.port, charset='utf8')
  35.         self.cursor = self.db.cursor()
  37.     def close_spider(self, spider):
  38.         """
  39.         爬虫结束时关闭数据库连接
  40.         """
  41.         print('关闭数据库连接...')
  42.         self.db.close()
  44.     def process_item(self, item, spider):
  45.         """
  46.         将爬取到的 item 存储到 MySQL 数据库
  47.         """
  48.         data = dict(item)
  49.         keys = ', '.join(data.keys())  # 获取字段名
  50.         values = ', '.join(['%s'] * len(data))  # 构建 SQL 中的值部分
  51.         sql = "insert into movie_data (%s) values (%s)" % (keys, values)
  52.         self.cursor.execute(sql, tuple(data.values()))  # 执行 SQL 插入语句
  53.         self.db.commit()  # 提交事务
  54.         return item  # 继续传递给下一个 pipeline（如果有的话）
复制代码
4. 设置 settings.py 文件

为了让 Scrapy 可以或许将数据写入 MySQL，我们必要在 settings.py 文件中进行一些设置。首先，启用 MysqlPipeline，然后设置 MySQL 数据库的连接信息。
在 settings.py 中添加如下内容：
  1. # 启用 MysqlPipeline 管道，将数据存入 MySQL
  2. ITEM_PIPELINES = {
  3.     "DoubanProject.pipelines.MysqlPipeline": 301,
  4. }
  6. # 配置 MySQL 数据库的连接信息
  7. MYSQL_HOST = 'localhost'           # MySQL 服务器的地址
  8. MYSQL_DATABASE = 'douban_movie'    # 使用的数据库名
  9. MYSQL_PORT = 3306                  # MySQL 端口号，默认是3306
  10. MYSQL_USER = 'root'                # 你的 MySQL 用户名
  11. MYSQL_PASSWORD = 'your password'   # 你的 MySQL 密码
复制代码
5. 运行爬虫并将数据导入 MySQL

如今你可以通过以下下令运行爬虫：
  1. scrapy crawl douban
复制代码
等待爬虫运行完毕后，打开你的 MySQL 数据库，利用以下 SQL 查询下令检察爬取到的数据：
  1. SELECT * FROM movie_data;
复制代码
你也可以利用 MySQL Workbench 或 Navicat 等图形化工具检察数据。
终端运行爬虫 douban

在所有的代码编写和设置完成后，我们就可以运行爬虫来抓取数据并生存到 Excel 文件和 MySQL 数据库中。以下是运行爬虫的步骤：
1. 进入项目目录

首先，确保你的终端已经定位到项目的根目录，也就是包罗 scrapy.cfg 文件的目录。可以通过下令行进入项目根目录：
  1. cd path/to/your/DoubanProject
复制代码
将 path/to/your/DoubanProject 更换为你实际的项目路径。
2. 运行爬虫

在项目目录下，通过以下下令启动爬虫：
  1. scrapy crawl douban
复制代码
此时，爬虫将开始访问豆瓣电影的 Top 250 页面，逐页抓取电影信息。抓取到的数据将被同时生存到 Excel 文件 (豆瓣电影数据.xlsx) 中，以及 MySQL 数据库（如果设置了 MySQL 管道）。
3. 检察生成的 Excel 文件

在爬虫运行完成后，Excel 文件将会生存在项目目录下，文件名为 豆瓣电影数据.xlsx。
你可以利用 WPS Office、Microsoft Excel 或任何支持 Excel 文件的软件来打开这个文件。

Excel 文件的内容应该类似如下：
电影排名
电影名称
电影简介
电影海报
电影评分
观影人数
1
肖申克的救赎
自由万岁！
图片链接
9.7
5000000+
2
霸王别姬
风华绝代
图片链接
9.6
4000000+
…
…
…
…
…
…
4. 查抄数据库中的数据

如果你设置了 MySQL 管道，数据也会被存入 MySQL 数据库。你可以通过以下下令在 MySQL 中查抄数据：
  1. USE douban_movie;
  2. SELECT * FROM movie_data;
复制代码
此时，终端将展示爬虫生存到数据库中的数据内容。
5. 爬虫运行提示信息

当你在终端运行爬虫时，你还会在终端中看到相关的运行日志，这些日志会提示爬虫的当前状态，好比：

注意：利用爬虫工具时，请务必服从目标网站的 robots.txt 文件以及相关法律法规，避免对网站造成太过负载。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4