Scrapy入门指南：如何用Python爬取网页数据

# 1. 简介

## 1.1 什么是Scrapy?

Scrapy是一个开源的Python框架，用于快速、高效地构建网络爬虫。它提供了强大的数据提取和处理工具，可以帮助用户从互联网上获取感兴趣的数据。

## 1.2 Scrapy的优点和用途

Scrapy具有以下几个优点和常见的使用场景：

- 高效性：Scrapy采用异步处理和并发机制，可以快速地爬取大量页面数据。
- 灵活性：Scrapy提供了丰富的配置选项和可扩展性，可以根据不同需求进行定制化开发。
- 数据提取能力：Scrapy内置了强大的数据提取器，可以方便地从HTML或JSON等文档中提取有用的数据。
- 支持多种存储方式：Scrapy可以将爬取到的数据存储到不同类型的数据库中，如MySQL、MongoDB等。
- 应用广泛：Scrapy广泛应用于数据挖掘、搜索引擎、价格比较、舆情监控等领域，帮助用户快速获取和分析大量网络数据。

## 1.3 安装Scrapy

在开始使用Scrapy之前，我们首先需要安装Scrapy及其依赖项。可以通过以下命令使用pip进行安装：

pip install scrapy

安装完成后，我们可以使用以下命令来验证是否安装成功：

scrapy --version

如果输出Scrapy的版本信息，则说明安装成功。

接下来，我们将深入了解Scrapy的基本用法，包括项目创建、Item定义、Spider编写、数据提取和存储等内容。

# 2. 基本用法

### 2.1 创建Scrapy项目

在使用Scrapy之前，首先需要创建一个Scrapy项目。在命令行中执行以下命令：

scrapy startproject myproject

这将会创建一个名为`myproject`的新目录，包含了Scrapy项目的基本结构。项目结构大致如下：

myproject/
    scrapy.cfg
    myproject/
        __init__.py
        items.py
        middlewares.py
        pipelines.py
        settings.py
        spiders/
            __init__.py

其中`scrapy.cfg`是Scrapy项目的配置文件，`myproject`目录下的`items.py`用于定义数据模型，`middlewares.py`用于定义中间件，`pipelines.py`用于数据的后续处理，`settings.py`包含了项目的设置，`spiders`目录用于存放爬虫代码。

### 2.2 定义Item

在`items.py`文件中定义数据模型，例如：

import scrapy

class Product(scrapy.Item):
    title = scrapy.Field()
    price = scrapy.Field()
    description = scrapy.Field()

这里定义了一个名为`Product`的Item，包括了`title`、`price`和`description`三个字段。

### 2.3 编写Spider

在`spiders`目录下创建一个新的Spider，例如`example_spider.py`：

import scrapy
from myproject.items import Product

class ExampleSpider(scrapy.Spider):
    name = 'example'
    allowed_domains = ['example.com']
    start_urls = ['http://www.example.com']

    def parse(self, response):
        product = Product()
        product['title'] = response.css('h1.title::text').get()
        product['price'] = response.css('div.price::text').get()
        product['description'] = response.css('p.description::text').get()
        yield product

在这个Spider中，我们定义了爬虫的名称`example`，允许爬取的域名`example.com`，以及起始URL。在`parse`方法中，我们使用CSS选择器来提取页面中的产品信息，并将其保存为`Product`对象。

### 2.4 数据提取

使用Scrapy提供的选择器可以方便地提取网页数据，包括CSS选择器、XPath表达式等。这些选择器可以在Spider的`parse`方法中使用。

### 2.5 存储数据

提取到的数据可以通过Scrapy的Pipeline进行存储，例如保存到数据库或者写入文件。在`pipelines.py`文件中可以定义数据存储的逻辑，通过开启或关闭Pipeline来控制数据的存储流程。

以上是Scrapy的基本用法，通过定义Item和Spider，并使用选择器提取数据，可以实现简单的网页数据爬取和存储。

# 3. 网页数据爬取

在这一章节中，我们将介绍使用Scrapy进行网页数据爬取的方法和技巧。

#### 3.1 发送HTTP请求

在Scrapy中，发送HTTP请求是非常简单的。首先，我们需要创建一个Spider来定义爬取的逻辑和规则。然后，在Spider的`start_requests`方法中创建一个`Request`对象，并指定要爬取的URL以及回调函数。下面是一个发送GET请求的示例代码：

import scrapy

class MySpider(scrapy.Spider):
    name = 'example'
    def start_requests(self):
        urls = ['http://www.example.com/page1', 'http://www.example.com/page2']
        for url in urls:
            yield scrapy.Request(url=url, callback=self.parse)
    def parse(self, response):
        # 处理响应数据的逻辑
        pass

如果要发送POST请求，则可以通过在`Request`对象中设置`method`参数为"POST"来实现。同时，还可以通过`formdata`参数来指定POST请求的表单数据。

#### 3.2 解析响应

收到响应后，我们需要解析响应数据，提取出目标数据。Scrapy内置了多种解析响应的方法，包括XPath、CSS选择器、正则表达式等。

使用XPath解析响应数据的示例代码如下所示：

def parse(self, response):
    # 使用XPath选择器提取所有的标题
    titles = response.xpath('//h1/text()').getall()
    # 使用XPath选择器提取第一个链接的文本和URL
    link = response.xpath('//a').get()
    text = link.xpath('text()').get()
    url = link.xpath('@href').get()
    # 处理提取到的数据的逻辑
    pass

类似地，使用CSS选择器和正则表达式也非常简单。Scrapy提供了相应的方法和函数来支持这些操作。

#### 3.3 处理链接

在网页爬取中，链接是非常重要的一部分。Scrapy针对链接提供了一些方便的功能，例如自动提取链接、过滤重复链接等。

在Spider的`parse`方法中，Scrapy会自动提取响应中的链接，并将其逐个传递给回调函数。同时，我们还可以通过正则表达式或XPath选择器来手动提取链接。

另外，为了避免重复爬取相同的链接，Scrapy会使用一个集合来记录已经爬取过的链接。当需要发送新的请求时，Scrapy会检查该集合，如果链接已经存在，则不会继续爬取。

#### 3.4 数据提取技巧

在网页数据爬取过程中，有时可能遇到一些特殊情况，如动态生成的内容、异步加载的数据等。为了有效地提取目标数据，我们可以采用一些技巧。

其中，使用浏览器的开发者工具来查看网页结构，找出目标数据所在的位置是一种常用的方法。此外，还可以通过观察网络请求和响应来分析数据的加载和传输过程，从而获取目标数据的URL或接口。

#### 3.5 避免对目标网站造成压力

在进行网页数据爬取时，我们需要注意不要对目标网站造成过大的压力，以免被封IP或触发反爬措施。为此，我们可以采取以下几种策略：

- 设置合理的下载延迟，避免过快地发送请求。
- 使用随机的User Agent，模拟不同的浏览器。
- 启用HTTP缓存，避免重复发送相同的请求。
- 使用代理IP进行爬取，隐藏真实IP地址。
- 遵守网站的Robots协议，尊重对方的爬取规则。

通过合理地设置爬取策略和参数，可以最大限度地减少对目标网站的干扰和负担。

以上就是网页数据爬取的基本方法和技巧。在实际应用中，可能会遇到一些特殊情况和问题，需要结合具体的情况进行处理。 Scrapy提供了灵活且强大的工具和接口，可以帮助我们实现各种复杂的爬取需求。

# 4. 数据清洗与处理

数据爬取回来后，往往需要进行数据清洗和处理，以便后续的分析和应用。本章将介绍如何使用Scrapy进行数据清洗和处理的方法和技巧。

## 4.1 清洗数据

在爬取的数据中，往往包含很多冗余或者无效的信息，需要将其清洗掉。数据清洗的主要过程包括去除空值、去除重复值、处理缺失值等。

### 4.1.1 去除空值

空值是指字段中没有实际值的情况。在进行数据分析和处理时，空值往往会带来问题，因此需要将其清洗掉。

下面是一个示例，演示如何使用Scrapy去除空值：

import scrapy

class MySpider(scrapy.Spider):
    name = 'myspider'
    start_urls = ['http://example.com']

    def parse(self, response):
        # 获取所有的数据
        data = response.xpath('//div[@class="data"]/text()').extract()

        # 去除空值
        cleaned_data = [item.strip() for item in data if item.strip()]

        yield {
            'cleaned_data': cleaned_data
        }

在上述代码中，通过XPath提取了网页中的所有数据，并使用列表推导式去除了空值。最后，使用`yield`语句将清洗后的数据返回。

### 4.1.2 去除重复值

重复值是指字段中存在多个相同的值的情况。在进行分析和处理时，重复值可能会导致结果不准确，因此需要将其清洗掉。

下面是一个示例，演示如何使用Scrapy去除重复值：

import scrapy
from scrapy import SelectorList

class MySpider(scrapy.Spider):
    name = 'myspider'
    start_urls = ['http://example.com']

    def parse(self, response):
        # 获取所有的数据
        data = response.xpath('//div[@class="data"]/text()').extract()

        # 去除重复值
        cleaned_data = list(set(data))

        # 将数据封装到Item中
        for item in cleaned_data:
            yield {
                'cleaned_data': item
            }

在上述代码中，通过XPath提取了网页中的所有数据，并使用`set`函数去除了重复值。最后，使用`yield`语句将清洗后的数据返回。

### 4.1.3 处理缺失值

缺失值是指字段中的某些值缺失或者不完整的情况。在进行分析和处理时，缺失值可能会导致结果不全面，因此需要进行处理。

下面是一个示例，演示如何使用Scrapy处理缺失值：

import scrapy

class MySpider(scrapy.Spider):
    name = 'myspider'
    start_urls = ['http://example.com']

    def parse(self, response):
        # 获取所有的数据
        data = response.xpath('//div[@class="data"]/text()').extract()

        # 处理缺失值
        cleaned_data = [item if item else 'N/A' for item in data]

        yield {
            'cleaned_data': cleaned_data
        }

在上述代码中，通过XPath提取了网页中的所有数据，并使用列表推导式将缺失值替换为'N/A'。最后，使用`yield`语句将处理后的数据返回。

## 4.2 数据处理方法

数据清洗完毕后，往往需要进行进一步的处理，以便后续的分析和应用。常见的数据处理方法包括数据转换、数据运算、数据合并等。

### 4.2.1 数据转换

数据转换指将数据从一种形式转换为另一种形式的过程。常见的数据转换包括日期格式转换、文本转换、数字转换等。

下面是一个示例，演示如何使用Scrapy进行数据转换：

import scrapy
from datetime import datetime

class MySpider(scrapy.Spider):
    name = 'myspider'
    start_urls = ['http://example.com']

    def parse(self, response):
        # 获取日期数据
        date_str = response.xpath('//div[@class="date"]/text()').extract_first()

        # 将日期数据转换为日期对象
        date = datetime.strptime(date_str, '%Y-%m-%d')

        yield {
            'date': date.strftime('%Y年%m月%d日')
        }

在上述代码中，通过XPath提取了网页中的日期数据，并使用`strptime`函数将其转换为日期对象，然后使用`strftime`函数将日期对象转换为指定格式的字符串。

### 4.2.2 数据运算

数据运算指对数据进行数学运算或逻辑运算的过程。常见的数据运算包括加减乘除、求和、平均值、最大值、最小值等。

下面是一个示例，演示如何使用Scrapy进行数据运算：

import scrapy
import numpy as np

class MySpider(scrapy.Spider):
    name = 'myspider'
    start_urls = ['http://example.com']

    def parse(self, response):
        # 获取数值数据
        data = response.xpath('//div[@class="data"]/text()').extract()

        # 将数据转换为浮点数数组
        data_arr = np.array(data, dtype=np.float)

        yield {
            'sum': np.sum(data_arr),
            'mean': np.mean(data_arr),
            'max': np.max(data_arr),
            'min': np.min(data_arr)
        }

在上述代码中，通过XPath提取了网页中的数值数据，并使用NumPy库将数据转换为浮点数数组，然后使用NumPy提供的函数计算了数据的总和、平均值、最大值和最小值。

### 4.2.3 数据合并

数据合并指将多个数据集合并为一个数据集的过程。常见的数据合并包括行合并、列合并、表合并等。

下面是一个示例，演示如何使用Scrapy进行数据合并：

import scrapy

class MySpider(scrapy.Spider):
    name = 'myspider'
    start_urls = ['http://example.com']

    def parse(self, response):
        # 获取数据集1
        data1 = response.xpath('//div[@class="data1"]/text()').extract()

        # 获取数据集2
        data2 = response.xpath('//div[@class="data2"]/text()').extract()

        yield {
            'merged_data': data1 + data2
        }

在上述代码中，通过XPath分别提取了两个数据集，并使用列表的加法操作符将它们合并为一个数据集。

## 4.3 数据存储

数据处理完毕后，往往需要将数据存储到数据库、文件或者其他存储介质中，以便后续的分析和应用。

常见的数据存储方式包括保存为CSV文件、保存到MySQL数据库、保存到MongoDB数据库等。

下面是一个示例，演示如何使用Scrapy将数据存储到CSV文件和MySQL数据库：

import scrapy
import csv
import pymysql

class MySpider(scrapy.Spider):
    name = 'myspider'
    start_urls = ['http://example.com']

    def parse(self, response):
        # 获取数据
        data = response.xpath('//div[@class="data"]/text()').extract()

        # 存储为CSV文件
        with open('data.csv', 'w', newline='', encoding='utf-8') as f:
            writer = csv.writer(f)
            writer.writerow(['data'])
            writer.writerows([[item] for item in data])

        # 存储到MySQL数据库
        connection = pymysql.connect(host='localhost', port=3306, user='root', password='password', db='mydatabase')
        cursor = connection.cursor()
        for item in data:
            cursor.execute("INSERT INTO mytable (data) VALUES (%s)", (item,))
        connection.commit()
        connection.close()

在上述代码中，通过XPath提取了网页中的数据，并使用CSV模块将数据存储为CSV文件，同时使用PyMySQL模块将数据存储到MySQL数据库中。

## 4.4 数据分析与可视化

数据处理完毕后，可以进行进一步的数据分析和可视化，以便从数据中发现规律和洞察问题。

常见的数据分析和可视化工具包括NumPy、Pandas、Matplotlib、Seaborn等。

下面是一个示例，演示如何使用NumPy和Matplotlib进行数据分析和可视化：

import scrapy
import numpy as np
import matplotlib.pyplot as plt

class MySpider(scrapy.Spider):
    name = 'myspider'
    start_urls = ['http://example.com']

    def parse(self, response):
        # 获取数值数据
        data = response.xpath('//div[@class="data"]/text()').extract()

        # 将数据转换为浮点数数组
        data_arr = np.array(data, dtype=np.float)

        # 计算数据的统计指标
        mean = np.mean(data_arr)
        std = np.std(data_arr)

        # 绘制数据的直方图
        plt.hist(data_arr, bins=20, edgecolor='black')

        # 添加标题和坐标轴标签
        plt.title('Distribution of Data')
        plt.xlabel('Data')
        plt.ylabel('Frequency')

        # 添加统计指标的注释
        plt.text(0.05, 0.95, f'Mean: {mean:.2f}\nStd: {std:.2f}', transform=plt.gca().transAxes, va='top')

        # 显示图形
        plt.show()

在上述代码中，通过XPath提取了网页中的数值数据，并使用NumPy将数据转换为浮点数数组，然后使用NumPy计算了数据的均值和标准差。最后，使用Matplotlib绘制了数据的直方图，并添加了统计指标的注释。

## 小结

本章介绍了如何使用Scrapy进行数据清洗和处理的方法和技巧，包括去除空值、去除重复值、处理缺失值、数据转换、数据运算、数据合并、数据存储、数据分析和可视化等。通过学习这些内容，读者可以更好地处理爬取回来的数据，以便后续的分析和应用。

# 5. 高级技巧

在使用Scrapy进行网页数据爬取的过程中，有一些高级技巧可以帮助我们更加高效地完成爬虫任务。本章节将介绍几个常用的高级技巧。

#### 5.1 动态网页爬取

有些网页采用了AJAX或者其他动态渲染技术，在浏览器中显示的内容和网页源代码中的内容不一致，这就给爬虫带来了困难。下面介绍两种解决动态网页爬取问题的方法。

##### 方法一：使用Selenium

Selenium是一个用于自动化浏览器操作的工具，可以模拟用户的操作过程，并获取网页的渲染结果。通过集成Selenium，可以很方便地爬取动态网页数据。

import scrapy
from selenium import webdriver

class MySpider(scrapy.Spider):
    name = 'my_spider'
    allowed_domains = ['example.com']
    start_urls = ['http://example.com']
    def parse(self, response):
        driver = webdriver.Chrome()
        driver.get(response.url)
        # 等待页面加载完毕
        driver.implicitly_wait(3)
        # 使用driver进行页面操作，如点击按钮、输入表单等
        # 获取渲染后的页面源码
        html = driver.page_source
        # 对渲染后的页面进行解析处理
        driver.quit()

##### 方法二：了解API接口

有些动态网页会提供API接口，通过分析接口的请求方式和参数，可以直接向接口发送HTTP请求来获取数据，而无需直接爬取页面。

#### 5.2 使用代理和User Agent

在进行大规模的数据爬取时，很容易被目标网站的反爬虫机制发现并封禁IP地址。为了绕过这个限制，可以使用代理服务器和随机的User Agent来隐藏爬虫的真实身份。

##### 配置代理

# settings.py

USER_AGENT_LIST = [
    'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.97 Safari/537.36',
    'Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.97 Safari/537.36',
    # 其他User Agent
]

DOWNLOADER_MIDDLEWARES = {
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
    'myproject.middlewares.RandomUserAgentMiddleware': 400,
    'scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware': 543,
    'myproject.middlewares.RandomProxyMiddleware': 750,
}

##### 配置User Agent

# middlewares.py

import random
from myproject.settings import USER_AGENT_LIST

class RandomUserAgentMiddleware(object):

    def process_request(self, request, spider):
        user_agent = random.choice(USER_AGENT_LIST)
        request.headers['User-Agent'] = user_agent

##### 配置代理服务器

# middlewares.py

import random
from myproject.settings import PROXY_LIST

class RandomProxyMiddleware(object):

    def process_request(self, request, spider):
        proxy = random.choice(PROXY_LIST)
        request.meta['proxy'] = proxy

#### 5.3 配置限速和并发

当我们爬取网站时，为了避免给目标服务器造成过大的压力，需要进行限速和并发控制。

##### 配置下载延迟

# settings.py

DOWNLOAD_DELAY = 3

##### 配置并发请求数

# settings.py

CONCURRENT_REQUESTS = 16
CONCURRENT_REQUESTS_PER_DOMAIN = 8

#### 5.4 验证码处理

有些网站为了防止爬虫，会设置验证码。在爬取这类网站数据时，需要实现验证码的自动识别和处理。

##### 使用打码平台

可以通过调用第三方打码平台的API来进行验证码识别。将验证码图片上传至打码平台，获得识别结果后，再将结果填入表单提交。

##### 使用机器学习

通过训练模型，可以实现对常见验证码的自动识别。可以使用机器学习库如OpenCV和TensorFlow进行验证码识别的训练和实现。

#### 5.5 使用中间件优化爬取过程

Scrapy提供了中间件的机制，可以在请求和响应的整个过程中添加自定义的处理逻辑。通过编写中间件，可以增加一些有用的功能，如自动重试、请求头处理、IP地址切换等。

# middlewares.py

from scrapy import signals

class MyMiddleware(object):

    @classmethod
    def from_crawler(cls, crawler):
        middleware = cls()
        crawler.signals.connect(middleware.open_spider, signal=signals.spider_opened)
        crawler.signals.connect(middleware.close_spider, signal=signals.spider_closed)
        return middleware

    def open_spider(self, spider):
        # 打开爬虫时的处理逻辑
        pass

    def close_spider(self, spider):
        # 关闭爬虫时的处理逻辑
        pass

    def process_request(self, request, spider):
        # 对请求进行处理的逻辑
        pass

    def process_response(self, request, response, spider):
        # 对响应进行处理的逻辑
        pass

    def process_exception(self, request, exception, spider):
        # 处理异常的逻辑
        pass

通过编写自定义中间件，可以优化爬取过程，增加一些自定义的功能和处理逻辑。

以上便是一些常用的高级技巧，可以帮助我们更加高效地完成网页数据的爬取任务。在实际应用中，根据具体的需求可以选择适用的技巧来优化爬虫程序。

# 6. 实战案例

本章将通过几个实战案例，展示如何使用Scrapy进行数据爬取和处理。

#### 6.1 爬取新闻网站数据

在这个实例中，我们将使用Scrapy爬取新闻网站的数据。首先，我们需要分析目标网站的页面结构和数据提取规则。然后，创建一个Scrapy项目并定义Item，用于存储爬取到的数据。接下来，编写Spider，定义爬取的起始链接和数据提取规则。最后，启动爬虫，Scrapy将自动执行爬取任务并将数据存储到指定的位置。

import scrapy

class NewsSpider(scrapy.Spider):
    name = 'news'
    start_urls = ['http://www.example.com/news']

    def parse(self, response):
        # 解析响应，提取数据
        news_list = response.xpath('//div[@class="news-list"]/ul/li')
        for news in news_list:
            item = {
                'title': news.xpath('a/text()').extract_first(),
                'url': news.xpath('a/@href').extract_first()
            }
            yield item

        # 提取下一页链接，继续爬取
        next_page = response.xpath('//a[@class="next-page"]/@href').extract()
        if next_page:
            yield response.follow(next_page, self.parse)

#### 6.2 爬取电商网站商品信息

这个实例展示了如何使用Scrapy爬取电商网站的商品信息。首先，我们需要分析网站的页面结构和数据提取规则。然后，创建一个Scrapy项目并定义Item，用于存储爬取到的商品信息。接下来，编写Spider，定义爬取的起始链接和数据提取规则。最后，启动爬虫，Scrapy将自动执行爬取任务并将数据存储到指定的位置。

import scrapy

class ProductSpider(scrapy.Spider):
    name = 'product'
    start_urls = ['http://www.example.com/products']

    def parse(self, response):
        # 解析响应，提取商品信息
        product_list = response.xpath('//div[@class="product-list"]/ul/li')
        for product in product_list:
            item = {
                'name': product.xpath('div[@class="name"]/text()').extract_first(),
                'price': product.xpath('div[@class="price"]/text()').extract_first()
            }
            yield item

        # 提取下一页链接，继续爬取
        next_page = response.css('a.next-page::attr(href)').extract_first()
        if next_page:
            yield response.follow(next_page, self.parse)

#### 6.3 爬取社交媒体数据

这个实例演示了如何使用Scrapy爬取社交媒体的数据。我们以Twitter为例进行说明。首先，我们需要获取Twitter的API授权，并设置相关参数。然后，创建一个Scrapy项目并定义Item，用于存储爬取到的社交媒体数据。接下来，编写Spider，定义爬取的起始链接和数据提取规则。最后，启动爬虫，Scrapy将通过Twitter的API获取数据并存储到指定的位置。

import scrapy
from scrapy_twisted.plugins import OAuth

class TwitterSpider(scrapy.Spider):
    name = 'twitter'
    @property
    def start_urls(self):
        return ['https://api.twitter.com/1.1/statuses/user_timeline.json?screen_name=example']

    @OAuth('twitter')
    def parse(self, response):
        # 解析响应，提取社交媒体数据
        data = response.json()
        for item in data:
            tweet = {
                'text': item['text'],
                'user': item['user']['screen_name'],
                'created_at': item['created_at']
            }
            yield tweet

#### 6.4 爬取股票数据

这个实例介绍了如何使用Scrapy爬取股票数据。我们以雅虎财经为例进行说明。首先，我们需要分析目标网站的页面结构和数据提取规则。然后，创建一个Scrapy项目并定义Item，用于存储爬取到的股票数据。接下来，编写Spider，定义爬取的起始链接和数据提取规则。最后，启动爬虫，Scrapy将自动执行爬取任务并将数据存储到指定的位置。

import scrapy

class StockSpider(scrapy.Spider):
    name = 'stock'
    start_urls = ['http://finance.yahoo.com/quote/example']

    def parse(self, response):
        # 解析响应，提取股票数据
        stock = {
            'symbol': response.css('h1::text').extract_first(),
            'price': response.css('.price::text').extract_first()
        }
        yield stock

#### 6.5 爬取图片和视频数据

这个实例展示了如何使用Scrapy爬取图片和视频数据。我们以Unsplash为例进行说明。首先，我们需要分析目标网站的页面结构和数据提取规则。然后，创建一个Scrapy项目并定义Item，用于存储爬取到的媒体数据。接下来，编写Spider，定义爬取的起始链接和数据提取规则。最后，启动爬虫，Scrapy将自动执行爬取任务并将媒体数据存储到指定的位置。

import scrapy

class MediaSpider(scrapy.Spider):
    name = 'media'
    start_urls = ['https://unsplash.com']

    def parse(self, response):
        # 解析响应，提取图片和视频链接
        media_list = response.css('figure')
        for media in media_list:
            item = {
                'image_url': media.css('img::attr(src)').extract_first(),
                'video_url': media.css('video source::attr(src)').extract_first()
            }
            yield item

通过以上几个实战案例，我们能够更加深入地理解Scrapy的用法，并且根据实际需求进行灵活的数据爬取和处理。当然，在实际应用过程中，我们还需注意网站的反爬虫机制和合法性问题，遵守网站的使用规则，避免对目标网站造成压力。