Python的`网络`爬虫：如何使用`Scrapy`和`BeautifulSoup`构建可扩展的网络爬虫。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

使用 Scrapy 和 BeautifulSoup 构建可扩展的网络爬虫

大家好，今天我们来聊聊如何使用 Python 中的 Scrapy 和 BeautifulSoup 构建可扩展的网络爬虫。Scrapy 是一个强大的 Python 爬虫框架，而 BeautifulSoup 则是一个灵活的 HTML/XML 解析库。结合两者，我们可以高效地抓取和解析网页数据。

1. 爬虫框架的选择：Scrapy 的优势

在开始构建爬虫之前，我们需要选择一个合适的框架。虽然可以使用 requests 库手动处理 HTTP 请求和 BeautifulSoup 解析 HTML，但对于复杂的爬虫项目，使用框架可以大大提高开发效率和可维护性。

Scrapy 相比其他爬虫框架，具有以下优势：

异步处理： Scrapy 基于 Twisted 异步网络库，能够并发处理多个请求，提高爬取速度。
中间件机制： 提供了强大的中间件机制，可以方便地实现请求重试、User-Agent 轮换、代理设置等功能。
数据管道： 允许自定义数据管道，对抓取的数据进行清洗、验证和存储。
可扩展性： Scrapy 的架构设计使其易于扩展，可以根据需求添加自定义组件。

因此，对于大型或复杂的爬虫项目，Scrapy 是一个理想的选择。

2. Scrapy 的基本架构

Scrapy 的架构可以概括为以下几个核心组件：

组件	功能	说明
Spider	定义如何抓取网页，包括起始 URL、解析规则等。	负责生成 Request 对象，并解析 Response 对象。
Scheduler	调度器，负责管理 Request 队列，并决定下一个要发送的 Request。	接收 Spider 生成的 Request 对象，并按照优先级进行排序。
Downloader	下载器，负责下载网页内容。	从 Scheduler 获取 Request 对象，发送 HTTP 请求，并返回 Response 对象。
Item Pipeline	数据管道，负责处理抓取到的数据。	接收 Spider 解析的 Item 对象，进行清洗、验证、存储等操作。
Middleware	中间件，用于处理 Request 和 Response，实现各种功能，如 User-Agent 轮换、代理设置等。	分为 Spider Middleware 和 Downloader Middleware，分别处理 Spider 和 Downloader 的 Request 和 Response。
Scrapy Engine	Scrapy 引擎，负责协调各个组件的工作。	负责控制数据流，将 Request 对象从 Spider 发送到 Downloader，将 Response 对象从 Downloader 发送到 Spider，并将 Item 对象发送到 Item Pipeline。

3. 创建 Scrapy 项目

首先，确保你已经安装了 Scrapy：

pip install scrapy

然后，创建一个新的 Scrapy 项目：

scrapy startproject myproject

这会在当前目录下创建一个名为 myproject 的文件夹，包含以下文件：

myproject/
    scrapy.cfg            # Scrapy 配置文件
    myproject/
        __init__.py
        items.py            # 定义数据结构
        middlewares.py      # 定义中间件
        pipelines.py        # 定义数据管道
        settings.py         # 项目设置
        spiders/            # 存放 Spider 的目录
            __init__.py

4. 定义 Item

Item 是 Scrapy 中用于存储抓取数据的容器。在 items.py 文件中定义 Item 的字段：

# myproject/items.py
import scrapy

class ProductItem(scrapy.Item):
    name = scrapy.Field()
    price = scrapy.Field()
    description = scrapy.Field()
    url = scrapy.Field()

5. 编写 Spider

Spider 是 Scrapy 的核心组件，负责定义如何抓取网页以及如何解析网页内容。在 spiders 目录下创建一个新的 Spider 文件，例如 myspider.py：

# myproject/spiders/myspider.py
import scrapy
from myproject.items import ProductItem
from bs4 import BeautifulSoup

class MySpider(scrapy.Spider):
    name = "myspider"
    allowed_domains = ["example.com"]  # 允许爬取的域名
    start_urls = ["http://www.example.com/products"]  # 起始 URL

    def parse(self, response):
        # 使用 BeautifulSoup 解析 HTML
        soup = BeautifulSoup(response.text, 'html.parser')

        # 提取产品信息
        products = soup.find_all('div', class_='product')

        for product in products:
            item = ProductItem()
            item['name'] = product.find('h2').text
            item['price'] = product.find('span', class_='price').text
            item['description'] = product.find('p', class_='description').text
            item['url'] = response.urljoin(product.find('a')['href'])  # 构建完整的 URL
            yield item  # 返回 Item 对象

在这个例子中，parse 方法是 Spider 的核心。它接收一个 response 对象，包含下载的网页内容。使用 BeautifulSoup 解析 HTML，提取产品信息，并将其存储到 ProductItem 对象中。 yield 关键字用于返回 Item 对象，Scrapy 会自动将这些 Item 对象传递给 Item Pipeline 进行处理。

6. 配置 Settings

settings.py 文件用于配置 Scrapy 项目的各种设置。例如，可以设置 User-Agent、开启 Item Pipeline、配置中间件等。

# myproject/settings.py

BOT_NAME = 'myproject'

SPIDER_MODULES = ['myproject.spiders']
NEWSPIDER_MODULE = 'myproject.spiders'

# Crawl responsibly by identifying yourself (and your website) on the user-agent
USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36'

# Obey robots.txt rules
ROBOTSTXT_OBEY = True

# Configure item pipelines
ITEM_PIPELINES = {
    'myproject.pipelines.MyPipeline': 300,
}

7. 实现 Item Pipeline

Item Pipeline 用于处理抓取到的数据。可以在 pipelines.py 文件中定义多个 Item Pipeline，每个 Pipeline 负责不同的处理任务。

# myproject/pipelines.py
import json

class MyPipeline:
    def __init__(self):
        self.file = open('products.json', 'w')

    def process_item(self, item, spider):
        # 将 Item 对象转换为 JSON 格式
        line = json.dumps(dict(item)) + "n"
        self.file.write(line)
        return item

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

在这个例子中，MyPipeline 将抓取到的产品信息存储到 products.json 文件中。 process_item 方法接收一个 Item 对象和一个 Spider 对象，并返回处理后的 Item 对象。 close_spider 方法在 Spider 关闭时被调用。

8. 运行 Spider

使用以下命令运行 Spider：

scrapy crawl myspider

Scrapy 会自动启动 Spider，下载网页内容，解析数据，并将数据传递给 Item Pipeline 进行处理。

9. 使用中间件

中间件用于处理 Request 和 Response，可以实现各种功能，如 User-Agent 轮换、代理设置、重试等。

9.1 User-Agent 轮换

为了避免被网站封禁，可以使用 User-Agent 轮换中间件。首先，在 middlewares.py 文件中定义一个 User-Agent 中间件：

# myproject/middlewares.py
import random

class RandomUserAgentMiddleware:
    def __init__(self, user_agent_list):
        self.user_agent_list = user_agent_list

    @classmethod
    def from_crawler(cls, crawler):
        return cls(
            user_agent_list=crawler.settings.get('USER_AGENT_LIST')
        )

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

然后，在 settings.py 文件中配置 User-Agent 列表和中间件：

# myproject/settings.py

USER_AGENT_LIST = [
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36',
    'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.106 Safari/537.36',
    # 添加更多 User-Agent
]

DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.RandomUserAgentMiddleware': 400,
}

9.2 代理设置

使用代理可以隐藏爬虫的真实 IP 地址，避免被网站封禁。首先，在 middlewares.py 文件中定义一个代理中间件：

# myproject/middlewares.py
import random

class ProxyMiddleware:
    def __init__(self, proxy_list):
        self.proxy_list = proxy_list

    @classmethod
    def from_crawler(cls, crawler):
        return cls(
            proxy_list=crawler.settings.get('PROXY_LIST')
        )

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

然后，在 settings.py 文件中配置代理列表和中间件：

# myproject/settings.py

PROXY_LIST = [
    'http://10.10.1.10:3128',
    'http://127.0.0.1:8888',
    # 添加更多代理
]

DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.ProxyMiddleware': 750,
}

9.3 重试

当请求失败时，可以自动重试。 Scrapy 已经内置了重试中间件，只需要在 settings.py 文件中开启即可：

# myproject/settings.py

RETRY_ENABLED = True
RETRY_TIMES = 3  # 重试次数

10. 扩展 Scrapy

Scrapy 的可扩展性非常强，可以根据需求添加自定义组件。例如，可以自定义 Scheduler、Downloader、Item Pipeline 等。

10.1 自定义 Scheduler

可以自定义 Scheduler 来控制 Request 队列的优先级和调度策略。例如，可以根据 URL 的深度来设置优先级，优先抓取深度较浅的 URL。

10.2 自定义 Downloader

可以自定义 Downloader 来处理特殊的 HTTP 请求。例如，可以使用 Selenium 来渲染 JavaScript 页面，或者使用 PhantomJS 来模拟浏览器行为。

10.3 自定义 Item Pipeline

可以自定义 Item Pipeline 来处理抓取到的数据。例如，可以将数据存储到数据库中，或者将数据发送到消息队列中。

11. 使用 BeautifulSoup 的注意事项

虽然 Scrapy 本身也支持使用 CSS 选择器和 XPath 表达式来提取数据，但在某些情况下，使用 BeautifulSoup 更加灵活和方便。

处理不规范的 HTML： BeautifulSoup 可以处理不规范的 HTML，例如缺少闭合标签、标签嵌套错误等。
复杂的文本提取： BeautifulSoup 提供了更加丰富的文本提取功能，例如可以提取指定标签内的所有文本，或者提取指定属性的值。

但是，使用 BeautifulSoup 也需要注意以下几点：

性能： BeautifulSoup 的性能相对较低，对于大型 HTML 文档，解析速度可能较慢。
依赖： 需要安装 BeautifulSoup 库。

因此，在选择解析工具时，需要根据实际情况进行权衡。对于简单的 HTML 结构，可以使用 CSS 选择器或 XPath 表达式。对于复杂的 HTML 结构，或者需要处理不规范的 HTML，可以使用 BeautifulSoup。

12. 可扩展性设计

构建可扩展的网络爬虫需要考虑以下几个方面：

模块化设计： 将爬虫拆分成多个模块，每个模块负责不同的功能。例如，可以将 Spider、Item Pipeline、Middleware 分别定义在不同的文件中。
配置化： 将爬虫的配置信息存储在配置文件中，方便修改和管理。例如，可以将起始 URL、User-Agent 列表、代理列表等存储在 settings.py 文件中。
异步处理： 使用异步网络库，并发处理多个请求，提高爬取速度。 Scrapy 本身就是基于 Twisted 异步网络库的。
分布式： 将爬虫部署到多个服务器上，并行抓取网页，提高爬取效率。可以使用 Scrapy-Redis 等框架来实现分布式爬虫。

13. 避免反爬虫

为了避免被网站封禁，需要采取一些反爬虫措施：

设置合理的爬取频率： 不要过于频繁地请求网站，以免给网站服务器造成过大的压力。
使用 User-Agent 轮换： 模拟不同的浏览器行为，避免被网站识别为爬虫。
使用代理： 隐藏爬虫的真实 IP 地址，避免被网站封禁。
处理验证码： 对于需要验证码的网站，可以使用 OCR 技术或者人工识别来处理验证码。
遵守 robots.txt 协议： 尊重网站的 robots.txt 协议，不要抓取禁止抓取的网页。

14. 代码示例：爬取电商网站商品信息

下面是一个更完整的例子，演示如何使用 Scrapy 和 BeautifulSoup 爬取电商网站的商品信息。假设我们要爬取某电商网站的商品名称、价格、描述和图片链接。

首先，定义 Item：

# myproject/items.py
import scrapy

class ECommerceItem(scrapy.Item):
    name = scrapy.Field()
    price = scrapy.Field()
    description = scrapy.Field()
    image_url = scrapy.Field()

然后，编写 Spider：

# myproject/spiders/ecommerce_spider.py
import scrapy
from myproject.items import ECommerceItem
from bs4 import BeautifulSoup

class ECommerceSpider(scrapy.Spider):
    name = "ecommerce_spider"
    allowed_domains = ["example.com"]
    start_urls = ["http://www.example.com/category/electronics"]

    def parse(self, response):
        soup = BeautifulSoup(response.text, 'html.parser')
        product_list = soup.find_all('div', class_='product-item')

        for product in product_list:
            item = ECommerceItem()
            item['name'] = product.find('h3', class_='product-name').text.strip()
            item['price'] = product.find('span', class_='product-price').text.strip()
            item['description'] = product.find('p', class_='product-description').text.strip()
            item['image_url'] = product.find('img', class_='product-image')['src']
            yield item

        # 翻页
        next_page = soup.find('a', class_='next-page')
        if next_page:
            next_page_url = response.urljoin(next_page['href'])
            yield scrapy.Request(next_page_url, callback=self.parse)

在这个例子中，Spider 首先解析当前页面的商品列表，提取商品信息，然后查找下一页的链接，并递归地抓取下一页的商品信息。

最后，配置 Item Pipeline：

# myproject/pipelines.py
import json

class JsonWriterPipeline:
    def __init__(self):
        self.file = open('electronics.json', 'w')

    def process_item(self, item, spider):
        line = json.dumps(dict(item), ensure_ascii=False) + "n"
        self.file.write(line)
        return item

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

确保在 settings.py 文件中启用 Item Pipeline：

# myproject/settings.py

ITEM_PIPELINES = {
    'myproject.pipelines.JsonWriterPipeline': 300,
}

通过以上步骤，我们就可以构建一个能够爬取电商网站商品信息的 Scrapy 爬虫。

爬虫架构和 BeautifulSoup 的强大结合

Scrapy 提供了强大的框架，处理请求调度和中间件管理；BeautifulSoup 则擅长解析HTML和提取数据。两者结合，能更高效地构建可扩展的网络爬虫。

可扩展性设计和反爬虫策略不可忽视

构建可扩展的爬虫需要模块化、配置化、异步处理和分布式策略。同时，反爬虫是绕不开的话题，合理的爬取频率、User-Agent 轮换、代理等等都需要考虑。