Python 爬虫实战指南：从基础请求到分布式框架

sudo apt update && sudo apt install python3 python3-pip python3-venv -y

安装完成后，执行以下命令确认：

python3 --version
pip3 --version

创建虚拟环境

为了避免全局依赖冲突，强烈建议为每个爬虫项目创建独立的虚拟环境：

# 进入项目根目录
mkdir my_spider && cd my_spider
# 在项目目录下创建虚拟环境
python3 -m venv venv
# 激活虚拟环境
# Windows：venv\Scripts\activate
# macOS/Linux：source venv/bin/activate

激活后，终端左侧会显示 (venv)，此时安装的所有包都只作用于该环境。

常用开发工具推荐

• IDE/编辑器：PyCharm Community / Professional、VS Code、Sublime Text。
• 调试工具：VS Code/PyCharm 自带的调试器，或者命令行脚本使用 pdb。
• 版本管理：Git + VS Code / PyCharm Git 插件。
• 其他辅助：Postman / Insomnia 用于模拟 HTTP 请求；Charles / Fiddler 抓包调试 AJAX 请求。

基础篇：用 Requests + BeautifulSoup 做简单爬虫

安装必要库

在虚拟环境中，执行：

pip install requests beautifulsoup4 lxml

• requests：Python 最常用的 HTTP 库，用于发送 GET/POST 请求。
• beautifulsoup4：常见的 HTML/XML 解析库，入门简单。
• lxml：速度快、功能强大的解析器，供 BeautifulSoup 使用。

认识 HTTP 请求与响应

• HTTP 请求：由方法（GET、POST、PUT 等）、URL、请求头（Headers）、请求体（Body）等组成。
• HTTP 响应：包含状态码（200、404、500 等）、响应头、响应体（通常为 HTML、JSON、图片、文件等）。
• Requests 常用参数：
  • url：请求地址。
  • params：URL 参数（字典/字符串）。
  • headers：自定义请求头（例如 User-Agent、Referer、Cookie）。
  • data / json：POST 请求时发送的表单或 JSON 数据。
  • timeout：超时时间（秒），防止请求一直卡住。
  • proxies：配置代理。

示例：

import requests
url = 'https://httpbin.org/get'
params = {'q': 'python 爬虫', 'page': 1}
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) ...'}
response = requests.get(url, params=params, headers=headers, timeout=10)
print(response.status_code)  # 打印状态码，例如 200
print(response.encoding)     # 编码，例如 'utf-8'
print(response.text[:200])   # 前 200 字符

编写第一个爬虫：抓取网页标题

下面以爬取「https://www.example.com」网页标题为例，演示最简单的流程：

# file: simple_spider.py
import requests
from bs4 import BeautifulSoup

def fetch_title(url):
    try:
        # 1. 发送 GET 请求
        headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) ...'}
        response = requests.get(url, headers=headers, timeout=10)
        response.raise_for_status()  # 如果状态码不是 200，引发 HTTPError
        
        # 2. 设置正确的编码
        response.encoding = response.apparent_encoding
        
        # 3. 解析 HTML
        soup = BeautifulSoup(response.text, 'lxml')
        
        # 4. 提取 <title> 标签内容
        title_tag = soup.find('title')
        if title_tag:
            return title_tag.get_text().strip()
        else:
            return '未找到 title 标签'
    except Exception as e:
        return f'抓取失败：{e}'

if __name__ == '__main__':
    url = 'https://www.example.com'
    title = fetch_title(url)
    print(f'网页标题：{title}')

运行结果示例：

(venv) $ python simple_spider.py
网页标题：Example Domain

解析 HTML：BeautifulSoup 用法详解

BeautifulSoup 库使用简单，常用方法如下：

1. 查找单个节点：soup.find(tag_name, attrs={}, recursive=True, text=None, **kwargs)。示例：soup.find('div', class_='content')。可以使用 attrs={'class': 'foo', 'id': 'bar'} 精确定位。
2. 查找所有节点：soup.find_all(tag_name, attrs={}, limit=None, **kwargs)。示例：soup.find_all('a', href=True) 返回所有带 href 的链接。
3. CSS 选择器：soup.select('div.content > ul li a')，返回列表。支持 id（#id）、class（.class）、属性（[attr=value]）等。
4. 获取属性或文本：node.get('href') 拿属性值；node['href'] 同上，但如果属性不存在会抛异常；node.get_text(strip=True) 获取节点文本，并去除前后空白。
5. 常用属性：soup.title / soup.title.string / soup.title.text，soup.body / soup.head / soup.a / soup.div 等快捷属性。

示例：提取列表页所有文章链接

html = response.text
soup = BeautifulSoup(html, 'lxml')
# 假设每篇文章链接都在 <h2><a href="...">...</a></h2>
for h2 in soup.find_all('h2', class_='post-title'):
    a_tag = h2.find('a')
    title = a_tag.get_text(strip=True)
    link = a_tag['href']
    print(title, link)

文件存储：将抓到的数据保存为 CSV/JSON

• encoding='utf-8-sig' 能兼容 Excel 打开时不出现乱码。

SQLite 存储（适合小规模项目）

import sqlite3
conn = sqlite3.connect('spider.db')
cursor = conn.cursor()
# 创建表（如果不存在）
cursor.execute('''
CREATE TABLE IF NOT EXISTS articles (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    title TEXT,
    url TEXT UNIQUE
);
''')
# 插入数据
items = [('第一篇', 'https://...'), ('第二篇', 'https://...'),]
for title, url in items:
    try:
        cursor.execute('INSERT INTO articles (title, url) VALUES (?, ?)', (title, url))
    except sqlite3.IntegrityError:
        pass  # URL 已存在就跳过
conn.commit()
conn.close()

JSON 格式

import json
data = [{'title': '第一篇', 'url': 'https://...'}, {'title': '第二篇', 'url': 'https://...'}]
with open('result.json', 'w', encoding='utf-8') as f:
    json.dump(data, f, ensure_ascii=False, indent=4)

CSV 格式

import csv
data = [{'title': '第一篇', 'url': 'https://...'}, {'title': '第二篇', 'url': 'https://...'}]
with open('result.csv', mode='w', newline='', encoding='utf-8-sig') as f:
    fieldnames = ['title', 'url']
    writer = csv.DictWriter(f, fieldnames=fieldnames)
    writer.writeheader()
    for item in data:
        writer.writerow(item)

常见反爬措施及应对策略

• User-Agent 检测：默认 requests 的 User-Agent 大多被识别为'爬虫'，容易被屏蔽。应用：在请求头中随机选用常见浏览器 User-Agent。
• IP 限制：如果同一 IP 在短时间内发起大量请求，服务器可能会封禁或返回 403。应对：使用代理池，定期更换 IP。
• Cookie 验证：某些网站登录后才能访问完整内容，需要先模拟登录获取 Cookie，再在后续请求中带上。用 requests.Session() 管理会话，同一 Session 自动保存并发送 Cookie。
• 验证码：简易验证码有时可通过 OCR 自动识别，但复杂图片验证码需要专门打码平台或人工识别。在入门阶段，尽量选择不需要验证码或抢先获取 API。
• AJAX / 动态渲染：如果页面数据是通过 JavaScript 动态加载，直接用 requests 只能获取静态 HTML。可分析 AJAX 请求接口（Network 面板），直接请求接口返回的 JSON；或使用浏览器自动化工具（Selenium/Playwright）模拟浏览器渲染。

Cookie 验证示例

import requests
session = requests.Session()
login_data = {'username': 'xxx', 'password': 'xxx'}
session.post('https://example.com/login', data=login_data)
# 登录成功后，session 自动保存了 Cookie
response = session.get('https://example.com/protected-page')

User-Agent 检测示例

import random
USER_AGENTS = [
    'Mozilla/5.0 ... Chrome/100.0.4896.127 ...',
    'Mozilla/5.0 ... Firefox/110.0 ...',
    'Mozilla/5.0 ... Safari/605.1.15 ...',
]
headers = {'User-Agent': random.choice(USER_AGENTS)}
response = requests.get(url, headers=headers)

进阶篇：更强大的解析工具

虽然 BeautifulSoup 足以应付大部分新手场景，但当你遇到结构复杂、嵌套多、或需要批量高效提取时，下面这些工具会更适合。

lxml (XPath)

• 特点：基于 C 语言实现，解析速度快，支持标准的 XPath 查询。
• 常见 XPath 语法：//tag[@attr="value"] 查找所有符合条件的 tag；text() 获取文本节点；@href 获取属性值。

示例：

from lxml import etree
html = '''<html><body>
<div><h2><a href="/p1">文章 A</a></h2></div>
<div><h2><a href="/p2">文章 B</a></h2></div>
</body></html>'''
# 1. 将文本转换为 Element 对象
tree = etree.HTML(html)
# 2. 使用 XPath 语法提取所有链接文本和 href
titles = tree.xpath('//div[@class="post"]/h2/a/text()')
links = tree.xpath('//div[@class="post"]/h2/a/@href')
for t, l in zip(titles, links):
    print(t, l)

parsel（Scrapy 内置的解析器）

• 特点：Scrapy 自带的一套基于 Css/XPath 的快速解析工具，接口与 lxml 类似，但更贴合 Scrapy 的数据提取习惯。

示例：

from parsel import Selector
html = '''<ul>
<li><a href="/a1">Item1</a></li>
<li><a href="/a2">Item2</a></li>
</ul>'''
sel = Selector(text=html)
# 使用 CSS 选择器
for item in sel.css('li.item'):
    title = item.css('a::text').get()
    link = item.css('a::attr(href)').get()
    print(title, link)

PyQuery（类似 jQuery 的解析方式）

• 特点：接口风格类似 jQuery，习惯了前端的同学会很快上手。内部使用 lxml 作为解析器，速度不逊于直接调用 lxml。

示例：

from pyquery import PyQuery as pq
html = '''<div>
<h2><a href="/x1">新闻 X1</a></h2>
<h2><a href="/x2">新闻 X2</a></h2>
</div>'''
doc = pq(html)
for item in doc('#posts h2'):
    a = pq(item).find('a')
    title = a.text()
    url = a.attr('href')
    print(title, url)

正则表达式在爬虫中的应用

正则并不是万能的 HTML 解析方案，但在提取简单规则（如邮箱、电话号码、特定模式字符串）时非常方便。在爬虫中，可先用 BeautifulSoup/lxml 找到相应的大块内容，再对内容字符串用正则提取。

示例：

import re
from bs4 import BeautifulSoup
html = '<div>联系邮箱：[email protected] 联系电话：123-4567-890</div>'
soup = BeautifulSoup(html, 'lxml')
info = soup.find('div', class_='info').get_text()
# 匹配邮箱
email_pattern = r'[\w\.-]+@[\w\.-]+'
emails = re.findall(email_pattern, info)
print('邮箱：', emails)

框架篇：Scrapy 全面入门

如果你想快速搭建一个可维护、可扩展的爬虫项目，Scrapy 是 Python 爬虫生态中最成熟、最流行的爬虫框架之一。

Scrapy 简介

• Scrapy：一个专门为大规模网络爬取与信息提取设计的开源框架，具有高性能、多并发、支持分布式、内置各种中间件与管道。
• 适用场景：大规模爬取同类型大量网页；对页面进行复杂数据清洗、去重、存储；需要高度定制化中间件或扩展时。

安装与项目结构

创建 Scrapy 项目：

scrapy startproject myproject

安装 Scrapy：

pip install scrapy

项目目录结构（示例）：

myproject/
  scrapy.cfg
  myproject/
    __init__.py
    items.py       # 定义数据模型（Item）
    middlewares.py # 自定义中间件
    pipelines.py   # 数据处理与存储 Pipeline
    settings.py    # Scrapy 全局配置
    spiders/       # 各种爬虫文件放在这里
      __init__.py
      example_spider.py

编写第一个 Scrapy 爬虫 Spider

假设我们要爬去 quotes.toscrape.com 网站上所有名言及作者：

定义 Item 模型 (myproject/items.py)：

import scrapy
class MyprojectItem(scrapy.Item):
    text = scrapy.Field()
    author = scrapy.Field()
    tags = scrapy.Field()

在 myproject/spiders/ 下新建 quotes_spider.py：

import scrapy
from myproject.items import MyprojectItem

class QuotesSpider(scrapy.Spider):
    name = 'quotes'  # 爬虫名，运行时指定
    allowed_domains = ['quotes.toscrape.com']
    start_urls = ['https://quotes.toscrape.com/']

    def parse(self, response):
        # 提取每个名言块
        for quote in response.css('div.quote'):
            item = MyprojectItem()
            item['text'] = quote.css('span.text::text').get()
            item['author'] = quote.css('small.author::text').get()
            item['tags'] = quote.css('div.tags a.tag::text').getall()
            yield item
            
            # 翻页：获取下一页链接并递归
            next_page = response.css('li.next a::attr(href)').get()
            if next_page:
                yield response.follow(next_page, callback=self.parse)

运行爬虫：

scrapy crawl quotes

Item、Pipeline、Settings 详解

• Items (items.py)：定义要提取的数据结构与字段，相当于'数据模型'。
• Spiders (spiders/xxx.py)：每个 spider 文件对应一个任务，可接收 start_urls、allowed_domains、parse() 回调等。
• Pipelines (pipelines.py)：处理从 Spider 返回的 Item，常见操作包括数据清洗（去重、格式化）、存储（写入 JSON/CSV、入库）、下载附件等。
• Settings (settings.py)：全局配置文件，包含并发数（CONCURRENT_REQUESTS）、下载延时（DOWNLOAD_DELAY）、中间件配置、管道配置、User-Agent 等。

常见 Settings 配置示例：

# settings.py（只列部分）
BOT_NAME = 'myproject'
SPIDER_MODULES = ['myproject.spiders']
NEWSPIDER_MODULE = 'myproject.spiders'
ROBOTSTXT_OBEY = True
CONCURRENT_REQUESTS = 8
DOWNLOAD_DELAY = 1
DEFAULT_REQUEST_HEADERS = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) ...',
}
ITEM_PIPELINES = {'myproject.pipelines.JsonWriterPipeline': 300,}
LOG_LEVEL = 'INFO'

Scrapy Shell 在线调试

Shell 模式下，你可以快速试错、验证提取逻辑，比写完整 Spider 再跑要高效很多。

scrapy shell 'https://quotes.toscrape.com/'

进入 shell 后，你可以执行：

>>> response.status
200
>>> response.css('div.quote span.text::text').getall()
['"The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking."', ...]

分布式与多线程：Scrapy 爬虫并发配置

• 并发请求数：在 settings.py 中设置 CONCURRENT_REQUESTS（默认 16）。
• 单域名并发：CONCURRENT_REQUESTS_PER_DOMAIN（默认 8）。
• 下载延时：DOWNLOAD_DELAY（默认 0）。
• 自动限速：AUTOTHROTTLE_ENABLED = True，配合 AUTOTHROTTLE_START_DELAY、AUTOTHROTTLE_MAX_DELAY 等。
• 并行请求：Scrapy 内部使用 Twisted 异步网络库实现高并发，单机即可轻松处理成千上万请求。

Scrapy 中间件与扩展

• Downloader Middleware：位于 Scrapy 引擎与下载器之间，可控制请求/响应，常用于动态设置 User-Agent、Proxy；拦截并修改请求/响应头；处理重试、重定向等。

示例：随机 User-Agent Middleware

# myproject/middlewares.py
import random
from scrapy import signals

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

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

    def process_request(self, request, spider):
        ua = random.choice(self.user_agents)
        request.headers.setdefault('User-Agent', ua)

并在 settings.py 中配置：

USER_AGENTS_LIST = ['Mozilla/5.0 ... Chrome/100.0 ...', 'Mozilla/5.0 ... Firefox/110.0 ...']
DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.RandomUserAgentMiddleware': 400,
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
}

动态内容爬取：Selenium 与 Playwright

当目标网页内容依赖 JavaScript 动态渲染时，单纯用 requests 或 Scrapy 获取到的 HTML 往往不包含最终可视化的数据。此时可以使用'浏览器自动化'工具，让其像真实浏览器一样加载页面，再提取渲染后的内容。

为什么需要浏览器自动化？

许多现代网站（尤其是单页应用 SPA）使用 React、Vue、Angular 等框架，通过 AJAX 或 API 获取数据并在前端渲染，直接请求 URL 只能拿到空白或框架代码。浏览器自动化可以启动一个真实或无头浏览器实例，访问页面，等待 JavaScript 执行完成，拿到渲染完毕的 DOM，然后再用解析库提取。

Selenium 基础用法

1. 下载 WebDriver（以 Chrome 为例）：前往 ChromeDriver 下载页面，下载与本地 Chrome 版本相匹配的 chromedriver。将 chromedriver 放置在系统 PATH 下，或在代码中指定路径。
2. 显式等待与隐式等待：driver.implicitly_wait(10)，在寻找元素时最长等待 10 秒；使用 WebDriverWait 与 ExpectedConditions。

示例：抓取动态网页内容

from selenium import webdriver
from selenium.webdriver.chrome.service import Service as ChromeService
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options
import time

# 1. 配置 Chrome 选项
chrome_options = Options()
chrome_options.add_argument('--headless')  # 无界面模式
chrome_options.add_argument('--no-sandbox')
chrome_options.add_argument('--disable-gpu')

# 2. 指定 chromedriver 路径或直接放到 PATH 中
service = ChromeService(executable_path='path/to/chromedriver')

# 3. 创建 WebDriver
driver = webdriver.Chrome(service=service, options=chrome_options)
try:
    # 4. 打开页面
    driver.get('https://quotes.toscrape.com/js/')
    # 这是一个 JavaScript 渲染的示例
    # 5. 等待 JS 渲染，最简单的方式：time.sleep（建议改用显式/隐式等待）
    time.sleep(2)
    # 6. 提取渲染后的 HTML
    html = driver.page_source
    # 7. 交给 BeautifulSoup 或 lxml 解析
    from bs4 import BeautifulSoup
    soup = BeautifulSoup(html, 'lxml')
    for quote in soup.css('div.quote'):
        text = quote.find('span', class_='text').get_text()
        author = quote.find('small', class_='author').get_text()
        print(text, author)
finally:
    driver.quit()

Playwright for Python（更快更轻量）

• Playwright：由微软维护、继承自 Puppeteer 的跨浏览器自动化库，支持 Chromium、Firefox、WebKit，无需单独下载 WebDriver。
• 优点：启动速度快、API 简洁、并发控制更灵活。

同步版 Playwright

from playwright.sync_api import sync_playwright
from bs4 import BeautifulSoup

def main():
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()
        page.goto('https://quotes.toscrape.com/js/')
        page.wait_for_selector('div.quote')
        html = page.content()
        browser.close()
        soup = BeautifulSoup(html, 'lxml')
        for quote in soup.select('div.quote'):
            text = quote.select_one('span.text').get_text()
            author = quote.select_one('small.author').get_text()
            print(text, author)

if __name__ == '__main__':
    main()

安装：

pip install playwright
playwright install

无头浏览器 (headless) 模式及性能优化

• 无头模式：在 Linux 服务器等环境下，没有图形界面，需要 --headless 参数；在 macOS/Windows 上也可加速启动。
• 资源限制：可以通过设置启动参数降低资源占用，如：Chrome：chrome_options.add_argument('--disable-gpu')、--no-sandbox、--disable-dev-shm-usage。
• 避免过度渲染：如果只想拿纯数据，尽量通过分析接口（XHR 请求）直接调用后台 API，不必启动完整浏览器。

结合 Selenium/Playwright 与 BeautifulSoup 解析

一般流程：

1. 用 Selenium/Playwright 拿到渲染后的 page_source 或 content()；
2. 用 BeautifulSoup/lxml 对 HTML 进行二次解析与提取。

示例综合：

from selenium import webdriver
from selenium.webdriver.chrome.service import Service as ChromeService
from selenium.webdriver.chrome.options import Options
from bs4 import BeautifulSoup

chrome_options = Options()
chrome_options.add_argument('--headless')
service = ChromeService('path/to/chromedriver')
driver = webdriver.Chrome(service=service, options=chrome_options)
try:
    driver.get('https://example.com/dynamic-page')
    driver.implicitly_wait(5)
    html = driver.page_source
    soup = BeautifulSoup(html, 'lxml')
    # 根据解析需求提取数据
    for item in soup.select('div.article'):
        title = item.select_one('h1').get_text()
        content = item.select_one('div.content').get_text(strip=True)
        print(title, content)
finally:
    driver.quit()

异步爬虫：aiohttp + asyncio 与 HTTPX

当面对上千个、甚至上万个链接需要同时抓取时，同步阻塞式的 requests 就显得效率低下。Python 原生的 asyncio 协程、aiohttp 库或 httpx 异步模式可以极大提升并发性能。

同步 vs 异步：性能原理简述

• 同步（Blocking）：一次请求完毕后才开始下一次请求。
• 异步（Non-Blocking）：发出请求后可立即切换到其他任务，网络 I/O 等待期间不阻塞线程。
• 对于 I/O 密集型爬虫，异步能显著提高吞吐量。

aiohttp 入门示例

1. 说明：aiohttp.TCPConnector(limit=50) 将并发连接限制在 50，避免短时间打开过多连接被服务器封。asyncio.create_task 创建并发 Task，交由事件循环调度。await asyncio.gather(*) 等待所有任务完成。

使用 asyncio + aiohttp 并发抓取

import asyncio
import aiohttp
from bs4 import BeautifulSoup

async def fetch(session, url):
    try:
        async with session.get(url, timeout=10) as response:
            text = await response.text()
            return text
    except Exception as e:
        print(f'抓取 {url} 失败：{e}')
        return None

async def parse(html, url):
    if not html:
        return
    soup = BeautifulSoup(html, 'lxml')
    title = soup.find('title').get_text(strip=True) if soup.find('title') else 'N/A'
    print(f'URL: {url}，Title: {title}')

async def main(urls):
    # connector 限制最大并发数，防止打开过多 TCP 连接
    conn = aiohttp.TCPConnector(limit=50)
    async with aiohttp.ClientSession(connector=conn) as session:
        tasks = []
        for url in urls:
            task = asyncio.create_task(fetch(session, url))
            tasks.append(task)
        # gather 等待所有 fetch 完成
        htmls = await asyncio.gather(*tasks)
        # 逐一解析
        for html, url in zip(htmls, urls):
            await parse(html, url)

if __name__ == '__main__':
    urls = [f'https://example.com/page/{i}' for i in range(1, 101)]
    asyncio.run(main(urls))

HTTPX：Requests 的异步升级版

• HTTPX：由 Encode 团队开发，与 requests API 十分相似，同时支持同步与异步模式。与 requests 兼容的 API（如 .get()、.post()、.json()、.text 等），极大降低了上手门槛。

示例：

import asyncio
import httpx
from bs4 import BeautifulSoup

async def fetch(client, url):
    try:
        resp = await client.get(url, timeout=10.0)
        resp.raise_for_status()
        return resp.text
    except Exception as e:
        print(f'Error {url}: {e}')
        return None

async def main(urls):
    async with httpx.AsyncClient(limits=httpx.Limits(max_connections=50)) as client:
        tasks = [asyncio.create_task(fetch(client, url)) for url in urls]
        for coro in asyncio.as_completed(tasks):
            html = await coro
            if html:
                title = BeautifulSoup(html, 'lxml').find('title').get_text(strip=True)
                print('Title:', title)

if __name__ == '__main__':
    urls = [f'https://example.com/page/{i}' for i in range(1, 101)]
    asyncio.run(main(urls))

数据存储与去重

爬虫的最终目的是获取并存储有价值的数据，因此选择合适的存储方式与去重机制至关重要。

本地文件：CSV、JSON、SQLite

1. CSV/JSON：适合一次性、容量较小、对数据结构要求不高的场景。直接用 Python 标准库即可读写。
2. SQLite：轻量级嵌入式数据库，无需额外部署数据库服务器。适合中小规模项目，比如几万条数据。

示例：

import sqlite3
conn = sqlite3.connect('data.db')
cursor = conn.cursor()
cursor.execute('CREATE TABLE IF NOT EXISTS items (id INTEGER PRIMARY KEY, title TEXT, url TEXT UNIQUE)')
data = [('标题 1', 'https://a.com/1'), ('标题 2', 'https://a.com/2')]
for title, url in data:
    try:
        cursor.execute('INSERT INTO items (title, url) VALUES (?, ?)', (title, url))
    except sqlite3.IntegrityError:
        pass  # 去重
conn.commit()
conn.close()

MySQL/PostgreSQL 等关系型数据库

• 优点：适合大规模数据存储，支持 SQL 强大的查询功能，能更好地做数据分析、统计。

示例（MySQL）：

import pymysql
conn = pymysql.connect(host='localhost', user='root', password='root', db='spider_db', charset='utf8mb4')
cursor = conn.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS articles (
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(255),
    url VARCHAR(255) UNIQUE
) CHARACTER SET utf8mb4;
''')
data = [('标题 1', 'https://a.com/1'), ('标题 2', 'https://a.com/2')]
for title, url in data:
    try:
        cursor.execute('INSERT INTO articles (title, url) VALUES (%s, %s)', (title, url))
    except pymysql.err.IntegrityError:
        pass
conn.commit()
conn.close()

MongoDB 等 NoSQL 存储

• 优点：文档型数据库，对半结构化 JSON 数据支持友好，可灵活存储字段不同的条目。
• 安装与驱动：本地安装 MongoDB 或使用云服务；Python 驱动：pip install pymongo。

示例：

from pymongo import MongoClient
client = MongoClient('mongodb://localhost:27017/')
db = client['spider_db']
collection = db['articles']
# 插入或更新（去重依据：url）
data = {'title': '标题 1', 'url': 'https://a.com/1', 'tags': ['新闻', '推荐']}
collection.update_one({'url': data['url']}, {'$set': data}, upsert=True)

Redis 用作去重与短期缓存

• Redis：键值存储，支持超高并发访问，非常适合做指纹去重、短期缓存、队列等。
  1. 布隆过滤器 (Bloom Filter)：当 URL 数量达到数百万级别时，普通 Python 集合会占用大量内存，布隆过滤器用空间换时间，以极少内存判断某个 URL 是否已爬取（有一定误判率）。可以使用 pybloom-live 或直接在 Redis 中搭建 Bloom Filter（如 RedisBloom 模块）。
  2. Redis Set：小规模去重可直接用 Redis set 存储已爬 URL。

常见策略：

import redis
r = redis.Redis(host='localhost', port=6379, db=0)
url = 'https://example.com/page/1'
# 尝试添加到 set，返回 1 表示新添加，返回 0 表示已存在
if r.sadd('visited_urls', url):
    print('新 URL，可爬取')
else:
    print('URL 已存在，跳过')

去重策略：指纹、哈希、Bloom Filter

• 指纹：通常对 URL 做标准化（去掉排序不同但内容相同的参数、多余的斜杠），然后对标准化后 URL 做哈希（如 MD5、SHA1），存到 Set 中对比。
• Bloom Filter：一种以极少内存做到高效去重的概率算法，对大规模 URL 判断去重十分划算，但有极小误判率（可能会把未访问的 URL 误判为已访问）。
• 库推荐：pybloom-live；redis-py-bloom 或 Redis 官方 RedisBloom 模块；Scrapy 内置 scrapy.dupefilters.RFPDupeFilter。

分布式爬虫：Scrapy-Redis 与分布式调度

当单机爬虫难以满足高并发、大规模抓取时，就需要分布式爬虫，将任务分布到多台机器协同完成。Scrapy-Redis 是 Scrapy 官方推荐的分布式方案之一。

Scrapy-Redis 简介与安装

• Scrapy-Redis：基于 Redis 存储队列与去重指纹，实现分布式调度、分布式去重、数据共享的 Scrapy 扩展。

安装：

pip install scrapy-redis

分布式去重队列与调度

1. 在 Scrapy 项目中集成 Scrapy-Redis：继承 scrapy_redis.spiders.RedisSpider 或 RedisCrawlSpider，将原本的 start_urls 替换为从 Redis 队列中获取种子 URL。
2. 将种子 URL 推入 Redis：在本地或远程机器上，用 redis-cli 将种子 URL 推入列表。
3. 启动分布式爬虫：所有实例会从同一个 Redis 队列中获取 URL，去重也基于 Redis，互不重复。

修改 Spider

# myproject/spiders/redis_quotes.py
from scrapy_redis.spiders import RedisSpider
from myproject.items import MyprojectItem

class RedisQuotesSpider(RedisSpider):
    name = 'redis_quotes'
    redis_key = 'redis_quotes:start_urls'

    def parse(self, response):
        for quote in response.css('div.quote'):
            item = MyprojectItem()
            item['text'] = quote.css('span.text::text').get()
            item['author'] = quote.css('small.author::text').get()
            item['tags'] = quote.css('div.tags a.tag::text').getall()
            yield item
            next_page = response.css('li.next a::attr(href)').get()
            if next_page:
                yield response.follow(next_page, callback=self.parse)

修改 settings.py：

# settings.py
SCHEDULER = "scrapy_redis.scheduler.Scheduler"
SCHEDULER_PERSIST = True
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
REDIS_URL = 'redis://:[email protected]:6379/0'
ITEM_PIPELINES = {'scrapy_redis.pipelines.RedisPipeline': 300}
REDIS_ITEMS_KEY = '%(spider)s:items'
REDIS_START_URLS_KEY = '%(name)s:start_urls'

多机协作示例

1. 部署多台服务器（A、B、C），都能访问同一个 Redis 实例。
2. 在 A、B、C 机上，各自拉取完整的 Scrapy 项目代码，并配置好 settings.py 中的 REDIS_URL。
3. 三台机器会自动协调，每台都从 Redis 队列中取 URL，去重也由 Redis 统一维护。
4. 在 A 机或任意一处，将种子 URL 塞入 Redis：

redis-cli -h A_ip -p6379 lpush redis_quotes:start_urls "https://quotes.toscrape.com/"

常见反爬与反制策略

频率限制与请求头伪装

1. 访问频率控制（限速）：Scrapy 中使用 DOWNLOAD_DELAY、AUTOTHROTTLE_ENABLED 等。
2. User-Agent 伪装：通过随机 User-Agent 模拟不同浏览器。
3. Referer、Accept-Language、Accept-Encoding 等 Headers：模拟真实浏览器请求时携带的完整 Header。

模拟真实浏览器请求：

headers = {
    'User-Agent': 'Mozilla/5.0 ...',
    'Referer': 'https://example.com/',
    'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
    'Accept-Encoding': 'gzip, deflate, br',
    'Cookie': 'sessionid=xxx; other=yyy',
}
response = requests.get(url, headers=headers)

登录验证与 Cookie 管理

• Session 对象：在 requests 中，使用 requests.Session() 方便统一管理 Cookie。
• 模拟登录流程：获取登录页 GET 请求，拿到隐藏的 token（如 CSRF）；结合用户名/密码、token，POST 到登录接口；成功后，session 内部有了 Cookie，后续使用同一 session 发起请求即可保持登录状态。

带 Cookie 抓取：

session = requests.Session()
# 第一次请求，拿到 CSRF Token
login_page = session.get('https://example.com/login')
from bs4 import BeautifulSoup
soup = BeautifulSoup(login_page.text, 'lxml')
token = soup.find('input', {'name': 'csrf_token'})['value']
# 构造登录表单
data = {'username': 'yourname', 'password': 'yourpwd', 'csrf_token': token}
# 登录
session.post('https://example.com/login', data=data, headers={'User-Agent': '...'})
# 登录成功后用 session 继续抓取需要登录才能访问的页面
profile = session.get('https://example.com/profile')
print(profile.text)

验证码识别（简单介绍）

• 常见验证码类型：验证码图片（扭曲字母/数字）；滑动验证码（拼图/拖动）；点选验证码（选特定图像）；行为生物特征（人机验证）。
• 常用方案：打码平台/人工打码；绕过/获取接口；简单 OCR 识别。

简单 OCR 识别：

from PIL import Image
import pytesseract
img = Image.open('captcha.png')
text = pytesseract.image_to_string(img).strip()
print('识别结果：', text)

代理 IP 池的搭建与旋转

1. 为什么要用代理：同一 IP 短时间内请求次数过多容易被封禁；使用代理 IP 池可以不断切换 IP，降低单 IP 请求频率。
2. 获取代理：免费代理（不稳定）；付费代理（稳定、安全）。
3. 在 Scrapy 中配置代理：自定义 RandomProxyMiddleware。

自定义 RandomProxyMiddleware：

# myproject/middlewares.py
import random

class RandomProxyMiddleware:
    def __init__(self, proxies):
        self.proxies = proxies

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

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

搭建本地简单代理池示例：

import requests
from lxml import etree
import random
import time

def fetch_free_proxies():
    url = 'https://www.kuaidaili.com/free/inha/1/'
    headers = {'User-Agent': 'Mozilla/5.0 ...'}
    resp = requests.get(url, headers=headers)
    tree = etree.HTML(resp.text)
    proxies = []
    for row in tree.xpath('//table//tr')[1:]:
        ip = row.xpath('./td[1]/text()')[0]
        port = row.xpath('./td[2]/text()')[0]
        proxy = f'http://{ip}:{port}'
        try:
            r = requests.get('https://httpbin.org/ip', proxies={'http': proxy, 'https': proxy}, timeout=3)
            if r.status_code == 200:
                proxies.append(proxy)
        except:
            continue
    return proxies

def get_random_proxy(proxies):
    return random.choice(proxies) if proxies else None

if __name__ == '__main__':
    proxy_list = fetch_free_proxies()
    print('可用代理：', proxy_list)

完整案例：爬取某新闻网站并存入数据库

本节以'爬取某模拟新闻网站（示例：https://news.example.com）的头条新闻，并将标题、摘要、链接存入 MySQL 数据库'为例，完整演示 Scrapy + MySQL 的使用。

需求分析

1. 目标数据：新闻标题、摘要（简介）、文章链接、发布时间。
2. 爬取范围：首页头条新闻（假设分页结构或动态加载，可视情况调整）。
3. 存储方式：MySQL 数据库，表名 headline_news，字段：id, title, summary, url, pub_date。
4. 反爬策略：设置随机 User-Agent、下载延时、简单 IP 伪装。

使用 Scrapy + MySQL 完整实现

编写 Spider (news_spider/spiders/news.py)

import scrapy
from news_spider.items import NewsSpiderItem

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

    def parse(self, response):
        # 假设首页头条新闻在 <div> 下，每个新闻项 <div>
        for news in response.css('div.headline-list div.item'):
            item = NewsSpiderItem()
            item['title'] = news.css('h2.title::text').get().strip()
            item['summary'] = news.css('p.summary::text').get().strip()
            item['url'] = response.urljoin(news.css('a::attr(href)').get())
            item['pub_date'] = news.css('span.pub-date::text').get().strip()
            # 需后续转换为标准时间
            yield scrapy.Request(
                url=item['url'],
                callback=self.parse_detail,
                meta={'item': item}
            )
            # 假设分页结构：下一页链接在 <a href="...">
            next_page = response.css('a.next-page::attr(href)').get()
            if next_page:
                yield response.follow(next_page, callback=self.parse)

    def parse_detail(self, response):
        item = response.meta['item']
        # 在详情页可提取更精确的发布时间
        pub_date = response.css('div.meta span.date::text').get().strip()
        item['pub_date'] = self.parse_date(pub_date)
        yield item

    def parse_date(self, date_str):
        from datetime import datetime
        try:
            dt = datetime.strptime(date_str, '%Y-%m-%d %H:%M:%S')
            return dt
        except:
            return None

MySQL Pipeline (news_spider/pipelines.py)

import pymysql
from pymysql.err import IntegrityError

class MySQLPipeline:
    def open_spider(self, spider):
        self.conn = pymysql.connect(
            host=spider.settings.get('MYSQL_HOST'),
            port=spider.settings.get('MYSQL_PORT'),
            user=spider.settings.get('MYSQL_USER'),
            password=spider.settings.get('MYSQL_PASSWORD'),
            db=spider.settings.get('MYSQL_DB'),
            charset=spider.settings.get('MYSQL_CHARSET'),
            cursorclass=pymysql.cursors.DictCursor
        )
        self.cursor = self.conn.cursor()
        create_table_sql = """
        CREATE TABLE IF NOT EXISTS headline_news (
            id INT AUTO_INCREMENT PRIMARY KEY,
            title VARCHAR(255),
            summary TEXT,
            url VARCHAR(512) UNIQUE,
            pub_date DATETIME
        ) CHARACTER SET utf8mb4;
        """
        self.cursor.execute(create_table_sql)
        self.conn.commit()

    def close_spider(self, spider):
        self.cursor.close()
        self.conn.close()

    def process_item(self, item, spider):
        insert_sql = """
        INSERT INTO headline_news (title, summary, url, pub_date)
        VALUES (%s, %s, %s, %s)
        """
        try:
            self.cursor.execute(insert_sql, (
                item.get('title'),
                item.get('summary'),
                item.get('url'),
                item.get('pub_date')
            ))
            self.conn.commit()
        except IntegrityError:
            pass  # URL 已存在则跳过
        return item

设置 MySQL 配置 (news_spider/settings.py)

# Database settings
MYSQL_HOST = 'localhost'
MYSQL_PORT = 3306
MYSQL_USER = 'root'
MYSQL_PASSWORD = 'root'
MYSQL_DB = 'news_db'
MYSQL_CHARSET = 'utf8mb4'

# Item Pipeline
ITEM_PIPELINES = {'news_spider.pipelines.MySQLPipeline': 300,}

# Download settings
ROBOTSTXT_OBEY = True
DOWNLOAD_DELAY = 1
CONCURRENT_REQUESTS = 8
USER_AGENTS_LIST = ['Mozilla/5.0 ... Chrome/100.0 ...', 'Mozilla/5.0 ... Firefox/110.0 ...']
DOWNLOADER_MIDDLEWARES = {
    'news_spider.middlewares.RandomUserAgentMiddleware': 400,
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
}

定义 Item (news_spider/items.py)

import scrapy
class NewsSpiderItem(scrapy.Item):
    title = scrapy.Field()
    summary = scrapy.Field()
    url = scrapy.Field()
    pub_date = scrapy.Field()

安装依赖

pip install scrapy pymysql

创建 Scrapy 项目

scrapy startproject news_spider
cd news_spider

代码详解与常见 Q&A

• Q：为什么要在 parse 方法中发起新的 Request 到详情页？
  • 因为首页展示的数据有限，有些字段（如精确发布时间、作者、正文）要到详情页才能拿到。meta 参数可将部分已抓取的字段传递到下一个回调。
• Q：如何将字符串 '2025-05-30 14:30:00' 转为 datetime？
  • 使用 Python 标准库 datetime.strptime，传入对应格式；若格式不一致，可先 strip() 或正则提取。
• Q：如果目标网站有登录或验证码怎么办？
  • 可在 start_requests 方法里模拟登录（使用 requests + cookies 或 Selenium），登录后获取 Cookie，再将 Cookie 带入 Scrapy 调用。
• Q：如何处理分页数量巨大（上千页）？
  • 可分析 URL 规律（如 page=1,2,3...），使用 for page in range(1, 1001): yield scrapy.Request(...)。注意限速与 IP 轮换，防止被封。

Python 爬虫相关的常用第三方库一览（截至 2024 年底）

以下对各类常用库进行分类归纳，并附简要说明与典型使用场景。

基础请求与解析

浏览器自动化

异步爬取

登录模拟与验证码处理

反爬与代理

分布式调度

其它有用工具

说明：因篇幅所限，上表仅列出截至 2024 年底常用或较为稳定的 Python 爬虫库，后续可能有新库或旧库迭代，请根据实际需求及时查阅官方文档或社区资源。

附录

常见报错及解决方案

1. ModuleNotFoundError: No module named 'xxx'
   • 原因：未安装该包或安装在全局而非虚拟环境中。
   • 解决：确认当前虚拟环境是否已激活，并执行 pip install xxx。
2. requests.exceptions.SSLError: [SSL: CERTIFICATE_VERIFY_FAILED]
   • 原因：本机 CA 证书有问题，无法验证 HTTPS。
   • 解决：升级 certifi：pip install --upgrade certifi；临时忽略：requests.get(url, verify=False)（不推荐用于生产）。
3. ValueError: too many values to unpack (expected 2) 在 XPath 返回多值时
   • 原因：使用 for x, y in tree.xpath(...)，但 XPath 返回值数量与预期不符。
   • 解决：检查 XPath 语法，或者使用 zip() 将两个列表匹配。
4. selenium.common.exceptions.WebDriverException: Message: 'chromedriver' executable needs to be in PATH
   • 原因：chromedriver 未放在系统 PATH，或路径不正确。
   • 解决：下载与 Chrome 版本一致的 chromedriver，并将其路径添加到环境变量，或者在代码中指定 executable_path。
5. pymysql.err.OperationalError: (1045, "Access denied for user 'root'@'localhost' (using password: YES)")
   • 原因：MySQL 用户名/密码、权限或 MySQL 服务未启动。
   • 解决：检查用户名、密码是否正确，MySQL 服务是否运行，数据库名称是否存在。
6. TimeoutError 或 asyncio.exceptions.TimeoutError
   • 原因：网络慢或被目标站点限制。
   • 解决：加大 timeout 参数，降低并发数，适当设置代理。
7. UnicodeEncodeError/UnicodeDecodeError
   • 原因：处理的文本编码与 Python 默认编码不一致。
   • 解决：明确指定 response.encoding = 'utf-8'，或者在读写文件时加 encoding='utf-8'。

常用 HTTP 状态码速查

学习资源与进阶指南

1. 官方文档
   • Requests：https://docs.python-requests.org/
   • BeautifulSoup：http://beautifulsoup.readthedocs.io/
   • Scrapy：https://docs.scrapy.org/
   • Selenium：https://www.selenium.dev/documentation/
   • Playwright：https://playwright.dev/python/
   • aiohttp：https://docs.aiohttp.org/
   • httpx：https://www.python-httpx.org/
2. 推荐书籍
   • 《Python 网络数据采集（第二版）》—— Ryan Mitchell
   • 《深入 Python 爬虫框架 Scrapy》—— 黄今
   • 《Python3 网络爬虫开发实战》—— 石刚
3. 课程与视频
   • B 站、YouTube 上均有优质 Python 爬虫视频教程（可搜索'Python 爬虫 零基础'、'Scrapy 教程'等）。
   • Coursera/慕课网上的 Python 爬虫进阶课程。
4. 社区资源
   • Stack Overflow：https://stackoverflow.com/（遇到报错可搜索）
   • SegmentFault：https://segmentfault.com/（国内开发者社区）
   • GitHub Trending：搜索开源爬虫项目，学习最佳实践。

总结

本教程从最基础的 requests + BeautifulSoup，到 Scrapy 框架、浏览器自动化、异步爬虫、分布式爬虫，系统梳理了 Python 爬虫的常见技术与实践要点，并盘点了截至 2024 年底的主流库与工具。对于初学者而言，掌握以下几个关键点即可快速上手：

1. 理解 HTTP 基础：会构造 GET/POST 请求、分析响应；
2. 掌握 HTML 解析：熟悉 BeautifulSoup、lxml（XPath/CSS Selector）；
3. 尝试 Scrapy：学会搭建 Scrapy 项目、编写 Spider、Pipeline、Settings，并用 Scrapy Shell 调试；
4. 应对动态页面：熟练使用 Selenium 或 Playwright 抓取 JS 渲染内容，并结合常规解析方法提取数据；
5. 探索异步爬虫：理解协程原理，用 aiohttp、httpx 提升并发性能；
6. 数据存储与去重：掌握 CSV/JSON/SQLite/MySQL/MongoDB 的使用，并做好 URL 去重（集合、Redis、Bloom Filter）；
7. 反爬与反制：设置 User-Agent、Referer、下载延时、代理 IP 池等，了解验证码处理思路；
8. 分布式爬虫：学习 Scrapy-Redis，将任务分配到多台机器，提高抓取效率。

最后，爬虫技术更新迅速，截止到本教程编写时（2024 年底）的主流库可能会随着技术迭代、站点反爬升级而发生变化。建议你在入门后，积极关注各大 Python 社区、GitHub Trending 以及官方文档，及时跟进新特性、新库、新思路，不断优化自己的爬虫方案。祝你能在数据抓取的道路上越走越远，愉快地玩转 Python 爬虫世界！