从零开始：爬虫入门与实践全攻略

44次阅读

共计 11832 个字符，预计需要花费 30 分钟才能阅读完成。

在这个信息爆炸的时代，数据已成为驱动创新和决策的核心引擎。从市场分析到学术研究，从舆情监控到个性化推荐，海量的数据是这一切的基础。然而，这些数据往往散落在互联网的各个角落，以非结构化的形式存在于网页之中。如何高效、自动化地获取这些宝贵的“数字石油”？答案就是——网络爬虫。

网络爬虫，简单来说，就是一段能够模拟人类浏览器行为，自动从互联网上抓取信息的程序。它能够访问网页、解析内容、提取所需数据，并将其存储起来。对于初学者而言，爬虫听起来可能有些神秘和复杂，但实际上，只要掌握了正确的方法和工具，你也能成为一名优秀的数据“情报员”。

本文将为你提供一份从零开始的爬虫入门与实践全攻略。无论你是一名数据爱好者、开发者，还是仅仅对数据采集充满好奇，本文都将带你一步步揭开爬虫的神秘面纱，从基础理论到实战演练，让你掌握构建和运用爬虫的核心技能。我们将深入探讨爬虫的工作原理、合法性边界、常用工具，并通过实际案例带你亲手构建不同类型的爬虫。准备好了吗？让我们一起踏上这场充满探索乐趣的数据采集之旅吧！

在正式动手之前，了解爬虫的基本原理和相关概念至关重要。这不仅能帮助你更好地理解代码逻辑，还能让你在面对复杂情况时，能够从容应对。

网络爬虫的核心工作流程，可以概括为以下几个步骤：

发起请求（Request）： 爬虫首先模拟浏览器向目标网站发送 HTTP 或 HTTPS 请求（如 GET、POST）。这个请求包含了请求头（User-Agent、Cookie 等）和请求体（POST 请求的数据）。
获取响应（Response）： 网站服务器接收到请求后，会返回一个 HTTP 响应。这个响应通常包含状态码（如 200 表示成功）、响应头和响应体。响应体通常就是 HTML、JSON、XML 等格式的网页内容。
解析内容（Parsing）： 爬虫接收到响应后，需要对响应体进行解析。如果响应是 HTML 页面，爬虫会利用解析库（如 BeautifulSoup、lxml）将其转换成可操作的数据结构，以便查找和提取所需信息。
数据提取（Extraction）： 根据预设的规则（如 CSS 选择器、XPath），从解析后的内容中提取目标数据，如标题、链接、图片 URL、文本等。
存储数据（Storage）： 将提取到的数据保存到本地文件（如 CSV、JSON）、数据库（如 MySQL、MongoDB）或其他存储介质中。
循环与遍历（Loop & Traversal）： 许多网站包含多个页面或链接。爬虫会根据提取到的链接，重复上述步骤，对更多页面进行抓取，直到达到预设的抓取深度或范围。

这个过程就像是一个高效的“信息搬运工”，不知疲倦地在网络世界中穿梭，寻找并收集你想要的信息。

掌握爬虫技术固然强大，但更重要的是了解并遵守相关的法律法规和道德规范。不当的爬取行为可能导致法律风险或被目标网站封禁。

Robots 协议（robots.txt）： 大多数网站会在其根目录下放置一个名为 robots.txt 的文件。这个文件是网站向爬虫发出的“君子协定”，规定了哪些内容允许爬取，哪些内容禁止爬取。在进行爬取前，务必查阅并遵守目标网站的 robots.txt 协议。
爬取频率与服务器压力： 频繁、高速的爬取行为可能会对目标网站的服务器造成巨大压力，甚至导致其崩溃。进行爬取时应设置合理的请求间隔（Sleep），避免对服务器造成不必要的负担。
数据隐私与版权： 爬取的数据可能包含用户隐私信息或受版权保护的内容。在处理和使用这些数据时，必须遵守相关的隐私保护法律和版权法，切勿滥用或非法传播。
反爬机制： 许多网站为了保护自身数据或防止恶意行为，会设置各种反爬机制，如 IP 限制、User-Agent 检测、验证码、JS 加密、登录验证等。爬虫工程师需要了解并合理应对这些机制，但要避免使用非法手段。

记住：合理、合法、合规是爬虫工作的基石。

要开始爬虫实践，你需要搭建一个 Python 开发环境。

安装 Python： 访问 Python 官网下载并安装最新版本的 Python（推荐 Python 3.x）。安装时记得勾选“Add Python to PATH”。
安装 pip： pip 是 Python 的包管理工具，随 Python 一同安装。你可以通过 pip list 命令检查是否安装成功。
安装常用库： 打开命令行工具（CMD 或 Terminal），使用 pip 安装以下核心库：
- requests：用于发送 HTTP 请求，简单易用。
- beautifulsoup4：用于 HTML/XML 解析，功能强大。
- lxml：高性能的 HTML/XML 解析库，常与 BeautifulSoup 配合使用或单独使用 XPath。
- selenium：用于模拟浏览器行为，处理动态网页（JavaScript 渲染）。
- Scrapy：一个功能强大的爬虫框架，适用于大型、复杂的爬虫项目。
```
pip install requests beautifulsoup4 lxml selenium scrapy
```

至此，你的爬虫实验室已准备就绪，可以开始动手实践了！

大多数初学者都会从抓取静态网页开始。静态网页是指内容在服务器端已经生成，并直接返回给浏览器显示的网页，其内容不会因用户操作而改变（除非刷新）。requests和 BeautifulSoup 是处理这类网页的黄金搭档。

requests库是 Python 中一个非常流行的 HTTP 客户端库，它让发送 HTTP 请求变得异常简单和人性化。

import requests

# 目标 URL
url = "https://www.example.com" # 请替换为你想要抓取的静态网页 URL

try:
    # 发送 GET 请求
    response = requests.get(url)

    # 检查响应状态码，200 表示成功
    if response.status_code == 200:
        print("请求成功！")
        # 获取网页内容（以文本形式）html_content = response.text
        # print(html_content[:500]) # 打印前 500 个字符查看
    else:
        print(f"请求失败，状态码：{response.status_code}")
except requests.exceptions.RequestException as e:
    print(f"请求发生错误：{e}")

在实际应用中，你可能需要添加请求头（如 User-Agent 来伪装浏览器），或者处理 POST 请求、带参数的 GET 请求等。

headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
}
response = requests.get(url, headers=headers)

获取到 HTML 内容后，就需要 BeautifulSoup 登场了。它能将复杂的 HTML 文档转换成一个易于操作的 Python 对象，你可以通过标签名、CSS 选择器、属性等多种方式来查找和提取数据。

from bs4 import BeautifulSoup

# 假设 html_content 已经通过 requests 获取
# html_content = """
# <html>
# <head><title> 示例网页 </title></head>
# <body>
#     <h1 class="title"> 欢迎来到我的博客 </h1>
#     <p class="intro"> 这里有一些新闻链接：</p>
#     <ul>
#         <li><a href="/news/1"> 新闻标题 1 </a></li>
#         <li><a href="/news/2"> 新闻标题 2 </a></li>
#         <li><a href="/news/3"> 新闻标题 3 </a></li>
#     </ul>
# </body>
# </html>
# """

# 创建 BeautifulSoup 对象，指定解析器为 lxml（更高效）soup = BeautifulSoup(html_content, 'lxml')

# 提取标题标签 <title> 的内容
title = soup.title.string
print(f"网页标题：{title}")

# 提取 class 为 "title" 的 h1 标签内容
main_title = soup.find('h1', class_='title').text
print(f"主要标题：{main_title}")

# 查找所有的新闻链接
news_links = soup.find_all('a') # 找到所有 <a> 标签
print("n 所有新闻链接：")
for link in news_links:
    # 获取链接文本
    link_text = link.text
    # 获取 href 属性值
    link_url = link.get('href')
    print(f"文本: {link_text}, 链接: {link_url}")

# 使用 CSS 选择器提取数据（更接近前端开发者的习惯）print("n 使用 CSS 选择器提取新闻：")
# 选择器：ul 下的所有 li 标签，再选择 li 下的 a 标签
news_items = soup.select('ul li a')
for item in news_items:
    print(f"文本: {item.text}, 链接: {item.get('href')}")

让我们来一个完整的案例：抓取一个模拟新闻页面的标题和链接。

import requests
from bs4 import BeautifulSoup
import time # 用于设置请求间隔

def scrape_news(url):
    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
    }
    news_list = []

    print(f"正在请求：{url}")
    try:
        response = requests.get(url, headers=headers, timeout=10) # 设置超时
        response.raise_for_status() # 如果状态码不是 200，抛出 HTTPError 异常

        soup = BeautifulSoup(response.text, 'lxml')

        # 假设新闻标题都在 class 为 'news-item' 的 div 中，且标题是 h2 标签，链接在 h2 下的 a 标签中
        # 根据实际网页结构调整选择器
        news_items = soup.select('div.news-item h2 a')

        if not news_items:
            print("未找到新闻内容，请检查选择器或网页结构。")

        for item in news_items:
            title = item.text.strip()
            # 获取绝对链接
            relative_url = item.get('href')
            full_url = requests.compat.urljoin(url, relative_url) # 拼接为完整的 URL
            news_list.append({'title': title, 'url': full_url})
            print(f"- 标题: {title}, 链接: {full_url}")

    except requests.exceptions.RequestException as e:
        print(f"请求 {url} 时发生错误：{e}")
    except Exception as e:
        print(f"解析 {url} 时发生错误：{e}")

    return news_list

if __name__ == "__main__":
    # 模拟一个静态新闻列表页的 URL，请自行替换为实际可访问的 URL
    # 比如你可以找一个简单的博客列表页或者新闻归档页
    target_url = "http://www.python.org/blogs/" # 仅为示例，实际情况可能需要更复杂的解析
    # 如果该网站反爬，可能无法成功。请替换为一个更简单的、允许爬取的网站。# 例如：https://en.wikipedia.org/wiki/Web_scraping
    # 目标 url 也可以是本地 html 文件，方便测试
    # target_url = "file:///path/to/your/local/news.html"

    print("开始抓取新闻...")
    # 模拟一个本地 HTML 内容进行测试
    mock_html_content = """
    <html>
    <head><title> 模拟新闻列表 </title></head>
    <body>
        <h1> 最新新闻 </h1>
        <div class="news-list">
            <div class="news-item"><h2><a href="/news/tech-innovation"> 科技创新：AI 如何改变世界 </a></h2></div>
            <div class="news-item"><h2><a href="/news/economy-outlook"> 经济展望：全球市场的新挑战 </a></h2></div>
            <div class="news-item"><h2><a href="/news/environment-protection"> 环境保护：应对气候变化的行动 </a></h2></div>
        </div>
        <a href="/next_page"> 下一页 </a>
    </body>
    </html>
    """
    # 实际运行时，请将上面 scrape_news 函数中的 requests.get(url, ...) 注释掉，# 并使用下面两行代码来模拟响应：# soup = BeautifulSoup(mock_html_content, 'lxml')
    # response = type('obj', (object,), {'text': mock_html_content, 'status_code': 200, 'raise_for_status': lambda: None})()

    # 如果用实际 URL，请取消注释下一行
    # news = scrape_news(target_url)

    # 演示如何处理 mock_html_content
    # 为了演示目的，我们手动创建 BeautifulSoup 对象
    # 在实际爬虫中，这些数据应来自 requests.get(url).text
    soup_mock = BeautifulSoup(mock_html_content, 'lxml')
    mock_news_list = []
    news_items_mock = soup_mock.select('div.news-item h2 a')
    for item in news_items_mock:
        title = item.text.strip()
        relative_url = item.get('href')
        # 对于模拟数据，拼接 URL 可能需要特定逻辑
        full_url = f"http://mockwebsite.com{relative_url}"
        mock_news_list.append({'title': title, 'url': full_url})
        print(f"- 标题: {title}, 链接: {full_url}")

    print("n 抓取完成！")
    # print("抓取到的新闻：", news)
    print("模拟抓取到的新闻：", mock_news_list)

提示： 在运行真实 URL 的爬虫时，请务必设置 time.sleep() 来控制请求频率，避免对目标网站造成负担。

并非所有网页内容都能直接通过 Requests 获取。随着前端技术的发展，许多网站使用 JavaScript 动态加载内容（如 Ajax 请求），或者通过各种反爬机制来阻止爬虫。

当网页内容由 JavaScript 动态渲染时，Requests 和 BeautifulSoup 可能只能获取到不完整的 HTML 骨架。这时，Selenium就能派上用场了。Selenium 是一个自动化测试工具，但它能够驱动真实的浏览器（如 Chrome、Firefox）加载网页，执行 JavaScript，并获取渲染后的内容。

工作原理： Selenium 通过 WebDriver 与浏览器进行通信。你可以编写 Python 代码来控制浏览器执行点击、填写表单、滚动页面等操作，等待 JS 加载完成，然后获取完全渲染的 HTML 内容。
安装： 除了pip install selenium，你还需要下载对应浏览器版本的 WebDriver（例如 Chrome 的 ChromeDriver），并将其放置在系统 PATH 中或指定其路径。

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# 需要先下载 ChromeDriver 并配置到 PATH
# 或者指定 chromedriver 的路径：# driver = webdriver.Chrome(executable_path='/path/to/chromedriver')

driver = webdriver.Chrome() # 启动 Chrome 浏览器
driver.maximize_window() # 最大化窗口

try:
    url = "https://www.example.com" # 替换为含有动态内容的 URL，例如一个需要滚动加载更多内容的网站
    driver.get(url)

    # 等待某个元素加载完成，例如等待 ID 为 "content-loaded" 的 div 出现
    # 这确保了 JavaScript 内容已经渲染
    WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "content-loaded"))
    )

    # 获取渲染后的页面 HTML
    rendered_html = driver.page_source
    print("获取到动态加载的页面内容（部分）：")
    # print(rendered_html[:1000])

    # 接着你可以使用 BeautifulSoup 解析 rendered_html
    soup = BeautifulSoup(rendered_html, 'lxml')
    # 例如，查找所有新闻标题
    # news_titles = soup.select('div.dynamic-news-item h2')
    # for title_elem in news_titles:
    #     print(title_elem.text.strip())

    print("页面加载并等待完成，可以进行数据提取了。")

finally:
    driver.quit() # 关闭浏览器

Selenium 虽然强大，但它会启动真实的浏览器，资源消耗较大，抓取速度相对较慢。对于大规模爬取，通常会优先考虑直接分析 Ajax 请求、模拟请求参数等方式，只在必要时才使用 Selenium。

网站的反爬手段层出不穷，但万变不离其宗。了解它们能帮助你设计更健壮的爬虫：

基于 User-Agent 检测： 网站通过检测请求头中的 User-Agent 来判断是否是浏览器访问。
- 应对： 设置 requests 的headers，伪装成常见的浏览器 User-Agent，或者维护一个 User-Agent 池随机使用。
基于 IP 访问频率限制： 同一 IP 短时间内大量请求会被封禁。
- 应对： 设置请求间隔（time.sleep()），使用代理 IP 池（付费或免费代理）。
登录验证与 Cookie： 许多内容需要登录后才能访问。
- 应对： 模拟登录（提交表单），或者在登录成功后，将会话中的 Cookie 保存下来，后续请求带上 Cookie。
验证码： 图形验证码、滑动验证码、点选验证码等。
- 应对： 简单的可使用 OCR 识别，复杂的可能需要打码平台（人工或 AI 识别服务）。
JavaScript 加密 / 混淆： 关键数据通过 JS 加密后传输或渲染。
- 应对： 分析 JS 代码逻辑，逆向解密；或者使用 Selenium 直接获取渲染结果。
Honeypot（蜜罐）： 网站设置不可见的链接或表单，一旦爬虫访问或填写，即被识别并封禁。
- 应对： 仔细分析 HTML 结构，避免点击或提交隐藏元素。

应对反爬是一个长期博弈的过程，需要耐心和技巧。

对于需要抓取大量数据、结构复杂、需要分布式部署的爬虫项目，使用 requests 和BeautifulSoup从头搭建会非常繁琐且难以维护。这时，Scrapy框架的优势就体现出来了。

Scrapy 是一个为爬取网站和提取结构化数据而设计的快速、高级的 Python 爬虫框架。它具有以下显著优势：

异步 IO： Scrapy 内置异步网络请求，可以在等待一个网页响应的同时处理另一个网页，大大提高爬取效率。
架构清晰： 模块化设计，职责分离，易于扩展和维护。
功能全面： 内置下载器、调度器、管道、中间件等组件，提供了从请求到存储的全流程支持。
可扩展性强： 丰富的中间件和管道接口，方便自定义功能，如处理 Cookie、代理、User-Agent、数据清洗等。
社区活跃： 拥有庞大的用户群体和活跃的社区支持。

理解 Scrapy 的架构是使用它的关键：

Scrapy Engine（引擎）： 负责控制所有组件的数据流，调度事件。
Scheduler（调度器）： 接收引擎发来的请求，并将其放入队列，等待下载器处理。
Downloader（下载器）： 负责发送 HTTP 请求到网站，并返回响应。
Spiders（爬虫）： 定义了如何爬取某个网站，包括初始请求、如何从响应中提取数据以及如何生成新的请求。
Item Pipelines（项目管道）： 负责处理爬虫提取到的 Item（数据项），如清洗数据、验证数据、持久化存储（存入数据库或文件）。
Downloader Middlewares（下载器中间件）： 介于引擎和下载器之间，可以处理请求和响应，如设置 User-Agent、代理、Cookie。
Spider Middlewares（爬虫中间件）： 介于引擎和爬虫之间，可以处理爬虫的输入（响应）和输出（Item、Request）。

创建一个 Scrapy 项目通常遵循以下步骤：

创建项目：

scrapy startproject myproject
cd myproject

定义 Item： 在 items.py 中定义你想要抓取的数据结构。

# myproject/items.py
import scrapy

class MyprojectItem(scrapy.Item):
    # define the fields for your item here like:
    title = scrapy.Field() # 标题
    url = scrapy.Field()   # 链接
    content = scrapy.Field() # 内容

编写 Spider： 在 spiders 目录下创建一个新的 Spider 文件（如myspider.py），定义爬取逻辑。

# myproject/spiders/myspider.py
import scrapy
from myproject.items import MyprojectItem

class MySpider(scrapy.Spider):
    name = 'myspider' # 爬虫的唯一名称
    start_urls = ['http://quotes.toscrape.com/'] # 初始爬取 URL 列表

    def parse(self, response):
        # 这个方法负责解析初始请求返回的响应
        # 这里的 response 就是下载器下载下来的网页内容
        # 从响应中提取数据
        for quote in response.css('div.quote'):
            item = MyprojectItem()
            item['title'] = quote.css('span.text::text').get()
            item['url'] = response.url # 示例中没有特定 URL，用当前页 URL
            item['content'] = quote.css('small.author::text').get() # 作者作为内容示例
            yield item # 将提取到的数据交给 Item Pipeline 处理

        # 查找下一页链接，并生成新的请求
        next_page = response.css('li.next a::attr(href)').get()
        if next_page is not None:
            yield response.follow(next_page, callback=self.parse) # 递归调用 parse 方法

配置 Item Pipeline（可选）： 在 pipelines.py 中定义数据处理和存储逻辑。

# myproject/pipelines.py
class MyprojectPipeline:
    def process_item(self, item, spider):
        # 可以在这里对数据进行清洗、验证
        # 例如，将 title 转换为大写
        item['title'] = item['title'].upper()
        return item

同时需要在 settings.py 中激活 Pipeline：

# myproject/settings.py
ITEM_PIPELINES = {'myproject.pipelines.MyprojectPipeline': 300, # 300 是优先级，数字越小优先级越高}

运行爬虫：

scrapy crawl myspider -o quotes.json # 运行名为 myspider 的爬虫，并将结果输出到 quotes.json 文件

Scrapy 的强大远不止于此，它还支持请求重试、深度限制、并发控制、分布式部署等高级功能，是专业爬虫开发的首选框架。

抓取到的数据仅仅是原材料，真正发挥其价值还需要进行后续的存储、清洗和分析。

文件存储：
- CSV（Comma Separated Values）： 结构简单，适用于存储表格数据，可用 Excel 等软件直接打开。
- JSON（JavaScript Object Notation）： 轻量级的数据交换格式，易于人阅读和编写，也易于机器解析和生成，非常适合存储结构化的半结构化数据。
- TXT： 适用于存储纯文本或日志。
数据库存储：
- 关系型数据库（如 MySQL, PostgreSQL）： 适合存储结构化、关系明确的数据，方便进行复杂的查询和管理。
- 非关系型数据库（如 MongoDB, Redis）： 适合存储非结构化、半结构化数据，具有高扩展性和灵活的数据模型。MongoDB 常用于存储 JSON 格式的文档数据。