Python 爬虫开发实战：从 Requests 到分布式部署

• 请求前务必查看目标站点的 robots.txt（通常在 https://example.com/robots.txt），遵从抓取规则；
• 有些站点禁止大量抓取、禁止商业用途，在爬取前请阅读并遵守版权与隐私政策；
• 不要对目标站点造成过大压力，建议设置合适的延时 (time.sleep)、并发数限制；
• 遵守爬虫与爬取数据后续处理相关法律法规，切勿用于违法用途。

开发环境准备

安装 Python（建议 3.8 及以上）

1. Windows：
   • 前往 https://www.python.org/downloads 下载对应 3.8+ 的安装包，默认选中'Add Python 3.x to PATH'，点击'Install Now'。
2. macOS： 建议使用 Homebrew 安装：

   brew install [email protected] 
   

3. Linux (Ubuntu/Debian 系)：

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

   执行以下命令确认：

   python3 --version
   pip3 --version
   

提示：如果你机器上同时安装了 Python 2.x 和 Python 3.x，可能需要使用 python3、pip3 来替代 python、pip。

创建虚拟环境并激活

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

# 进入项目根目录
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 插件，实现代码托管与协作。
  • 将项目托管到 GitHub/Gitee 等。
• 其他辅助：
  • Postman / Insomnia：用于模拟 HTTP 请求、查看响应头；
  • Charles / Fiddler：抓包工具，可调试 AJAX 请求、Cookie、headers 等。

基础篇：用 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)：获取节点文本，并去除前后空白；
   • node.text：获取节点及子节点合并文本。
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)

常见反爬措施及应对策略

• 默认 requests 的 User-Agent 大多被识别为'爬虫'，容易被屏蔽。
• 应用：在请求头中随机选用常见浏览器 User-Agent。

2. IP 限制
   • 如果同一 IP 在短时间内发起大量请求，服务器可能会封禁或返回 403。
   • 应对：使用代理池（详见第 11 节），定期更换 IP。
   • 某些网站登录后才能访问完整内容，需要先模拟登录获取 Cookie，再在后续请求中带上。
   • 用 requests.Session() 管理会话，同一 Session 自动保存并发送 Cookie。
3. 验证码
   • 简易验证码有时可通过 OCR 自动识别，但复杂图片验证码需要专门打码平台或人工识别。
   • 在入门阶段，尽量选择不需要验证码或抢先获取 API。
4. 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：获取属性值；
  • //div//a：查找 div 下所有后代中的 a；
  • //ul/li[1]：查找第一个 li；
  • contains(@class, "foo")：class 中包含 foo 的元素。

示例：

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)
# 输出：
# 文章 A /p1
# 文章 B /p2

安装：

pip install lxml

parsel（Scrapy 内置的解析器）

• 特点：Scrapy 自带的一套基于 Css/XPath 的快速解析工具，接口与 lxml 类似，但更贴合 Scrapy 的数据提取习惯。
• parsel.Selector 对象在 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)
# 使用 XPath
for item in sel.xpath('//li[@class="item"]'):
    title = item.xpath('./a/text()').get()
    link = item.xpath('./a/@href').get()
    print(title, link)

安装：

pip install parsel

PyQuery（类似 jQuery 的解析方式）

• 特点：接口风格类似 jQuery，习惯了前端的同学会很快上手。
• PyQuery 内部使用 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)
# 通过标签/ID/css 选择器定位
for item in doc('#posts h2'): # item 是 lxml 的 Element，需要再次包装
    a = pq(item).find('a')
    title = a.text()
    url = a.attr('href')
    print(title, url)

安装：

pip install pyquery

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

• 正则并不是万能的 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)
# 匹配电话号码
phone_pattern = r'\d{3}-\d{4}-\d{3,4}'
phones = re.findall(phone_pattern, info)
print('电话：', phones)

框架篇：Scrapy 全面入门

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

Scrapy 简介

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

安装与项目结构

项目目录结构（示例）：

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

创建 Scrapy 项目：

scrapy startproject myproject

安装 Scrapy：

pip install scrapy

编写第一个 Scrapy 爬虫 Spider

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

运行爬虫：

scrapy crawl quotes

运行后，会在项目根目录生成 quotes.json，其中包含抓取到的所有名言数据。

配置数据存储 Pipeline（可选存储到 JSON/CSV/数据库），如在 myproject/pipelines.py：

import json

class JsonWriterPipeline:
    def open_spider(self, spider):
        self.file = open('quotes.json', 'w', encoding='utf-8')
        self.file.write('[\n')

    def close_spider(self, spider):
        self.file.write('\n]')
        self.file.close()

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

并在 settings.py 中启用：

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

定义 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)

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'

# 遵循 robots 协议
ROBOTSTXT_OBEY = True

# 并发请求数（默认 16）
CONCURRENT_REQUESTS = 8

# 下载延时（秒），防止对目标站造成过大压力
DOWNLOAD_DELAY = 1

# 配置 User-Agent
DEFAULT_REQUEST_HEADERS = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) ...',
}

# 启用 Pipeline
ITEM_PIPELINES = {
    'myproject.pipelines.JsonWriterPipeline': 300,
}

# 启用或禁用中间件、扩展、管道等
DOWNLOADER_MIDDLEWARES = {
    # 'myproject.middlewares.SomeDownloaderMiddleware': 543,
}

# 日志等级
LOG_LEVEL = 'INFO'

Scrapy Shell 在线调试

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

进入 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."', ...]
>>> response.xpath('//div[@class="quote"]/span[@class="text"]/text()').getall()

Scrapy 提供了 scrapy shell <URL> 命令，可以快速测试 XPath、CSS 选择器。

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

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

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

Scrapy 中间件与扩展（Downloader Middleware、Downloader Handler）

• Downloader Middleware：位于 Scrapy 引擎与下载器之间，可控制请求/响应，常用于：
  • 动态设置 User-Agent、Proxy；
  • 拦截并修改请求/响应头；
  • 处理重试（Retry）、重定向（Redirect）等。
• Downloader Handler：更底层的接口，一般不常用，Scrapy 已提供 HttpDownloadHandler、S3DownloadHandler 等。

示例：随机 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 ...',
    # 更多 User-Agent
]
DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.RandomUserAgentMiddleware': 400,
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
}

动态内容爬取：Selenium 与 Playwright

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

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

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

Selenium 基础用法

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

显式等待：使用 WebDriverWait 与 ExpectedConditions，例如：

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

element = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.CSS_SELECTOR, 'div.quote'))
)

示例：抓取动态网页内容

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()

安装：

pip install selenium

Playwright for Python（更快更轻量）

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

同步版 Playwright
如果你不想使用异步，也可以借助 sync_api：

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()

示例：抓取动态内容

import asyncio
from playwright.async_api import async_playwright
from bs4 import BeautifulSoup

async def main():
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page()
        await page.goto('https://quotes.toscrape.com/js/')
        # 可选：等待某个元素加载完成
        await page.wait_for_selector('div.quote')
        content = await page.content() # 获取渲染后的 HTML
        await browser.close()
        # 交给 BeautifulSoup 解析
        soup = BeautifulSoup(content, '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__':
    asyncio.run(main())

安装：

pip install playwright # 安装浏览器内核（只需第一次执行）
playwright install

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

• 无头模式：在 Linux 服务器等环境下，没有图形界面，需要 --headless 参数；在 macOS/Windows 上也可加速启动。
• 资源限制：可以通过设置启动参数降低资源占用，如：
  • Chrome：chrome_options.add_argument('--disable-gpu')、--no-sandbox、--disable-dev-shm-usage；
  • Playwright：browser = await p.chromium.launch(headless=True, args=['--disable-gpu', '--no-sandbox'])。
• 避免过度渲染：如果只想拿纯数据，尽量通过分析接口（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))

安装：

pip install aiohttp

使用 asyncio 协程池提高并发

如果需要对抓取和解析做更精细的并行控制，可使用 asyncio.Semaphore 或第三方协程池库（如 aiomultiprocess、aiojobs）来控制并发数。

import asyncio
import aiohttp
from bs4 import BeautifulSoup

semaphore = asyncio.Semaphore(20) # 最多同时跑 20 个协程

async def fetch_with_sem(session, url):
    async with semaphore:
        try:
            async with session.get(url, timeout=10) as resp:
                return await resp.text()
        except Exception as e:
            print(f'Error fetching {url}: {e}')
            return None

async def main(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [asyncio.create_task(fetch_with_sem(session, url)) for url in urls]
        results = await asyncio.gather(*tasks)
        for html, url in zip(results, urls):
            if html:
                title = BeautifulSoup(html, 'lxml').find('title').get_text(strip=True)
                print(url, title)

if __name__ == '__main__':
    sample_urls = [f'https://example.com/page/{i}' for i in range(1, 51)]
    asyncio.run(main(sample_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))

安装：

pip install httpx

异步下使用解析库示例（aiohttp + lxml）

import asyncio
import aiohttp
from lxml import etree

async def fetch_and_parse(session, url):
    try:
        async with session.get(url, timeout=10) as resp:
            text = await resp.text()
            tree = etree.HTML(text)
            # 提取第一条消息
            msg = tree.xpath('//div[@class="msg"]/text()')
            print(url, msg)
    except Exception as e:
        print(f'Error fetching {url}: {e}')

async def main(urls):
    conn = aiohttp.TCPConnector(limit=30)
    async with aiohttp.ClientSession(connector=conn) as session:
        tasks = [fetch_and_parse(session, url) for url in urls]
        await asyncio.gather(*tasks)

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

数据存储与去重

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

本地文件：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()

安装：先安装对应数据库服务器（MySQL、MariaDB、PostgreSQL），然后在 Python 中安装驱动：

pip install pymysql # MySQL
pip install psycopg2 # PostgreSQL

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：纯 Python 布隆过滤器库；
  • redis-py-bloom 或 Redis 官方 RedisBloom 模块（需 Redis 安装相应扩展）；
  • Scrapy 内置 scrapy.dupefilters.RFPDupeFilter，默认用的是文件或 Redis 存储的指纹去重。

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

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

为什么要做分布式？

• 海量链接：需要抓取数百万、上亿条 URL 时，单机进程/线程或协程都难以在可接受时间内完成。
• 速度要求：需要更短时间内获取全量数据，提高爬取速度。
• 容错与扩展：分布式部署可实现节点增减、机器故障自愈等。

Scrapy-Redis 简介与安装

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

安装：

pip install scrapy-redis

分布式去重队列与调度

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

在多台服务器或多终端分别启动爬虫：

scrapy crawl redis_quotes

在本地或远程机器上，用 redis-cli 将种子 URL 推入列表：

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

修改 Spider

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

class RedisQuotesSpider(RedisSpider):
    name = 'redis_quotes' # Redis 中存放 start_urls 的 key
    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
# 使用 redis 作为调度器
SCHEDULER = "scrapy_redis.scheduler.Scheduler"
# 每次爬虫重启时是否继续未爬取完的爬取队列
SCHEDULER_PERSIST = True
# 使用 redis 去重（替换默认的 RFPDupeFilter）
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
# 指定 redis 链接地址
REDIS_URL = 'redis://:[email protected]:6379/0'
# 将 item 存入 redis 由其他进程或管道处理
ITEM_PIPELINES = {'scrapy_redis.pipelines.RedisPipeline': 300}
# 指定用来存储队列的 redis key 前缀
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。
   • 三台机器会自动协调，每台都从 Redis 队列中取 URL，去重也由 Redis 统一维护。
3. 数据收集：
   • 爬取的 Item 通过 RedisPipeline 自动存入 Redis 列表（key: quotes:items）；
   • 之后可通过独立脚本或 pipeline 再将数据持久化到数据库/文件。

在 A、B、C 分别运行：

scrapy crawl redis_quotes

在 A 机或任意一处，将种子 URL 塞入 Redis：

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

在 A 机上运行：

redis-server # 启动 Redis（可独立部署）

常见反爬与反制策略

频率限制与请求头伪装

1. 访问频率控制（限速）
   • Scrapy 中使用 DOWNLOAD_DELAY、AUTOTHROTTLE_ENABLED 等。
2. User-Agent 伪装
   • 通过随机 User-Agent 模拟不同浏览器。
   • 代码示例见第 4.6 节。
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
    'Cookie': 'sessionid=xxx; other=yyy',
}
response = requests.get(url, headers=headers)

对目标站设置随机或固定延时：

import time, random
time.sleep(random.uniform(1, 3)) # 随机等待 1~3 秒

登录验证与 Cookie 管理

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

带 Cookie 抓取：

session = requests.Session()
# 第一次请求，拿到 CSRF Token
login_page = session.get('https://example.com/login')
# 用 BeautifulSoup 解析隐藏 token
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)

验证码识别（简单介绍）

• 常见验证码类型：
  • 验证码图片（扭曲字母/数字）；
  • 滑动验证码（拼图/拖动）
  • 点选验证码（选特定图像）
  • 行为生物特征（人机验证）
• 常用方案：
  1. 打码平台/人工打码：当验证码过于复杂时，可调用第三方打码平台 API（如超级鹰、打码兔等），将图片发送给平台，由平台返回识别结果；或者简单地由人工识别。
  2. 绕过/获取接口：很多网站的登录并不真用验证码进行提交，而是在前端校验。可以抓包找到真实的登录接口，模拟接口请求，绕过验证码。

简单 OCR 识别：用 pytesseract 对简单数字/字母验证码进行识别，但对扭曲度高或干扰线多的验证码成功率不高。

pip install pytesseract pillow

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. 获取代理
   • 免费代理：网上公开的免费代理 IP，但一般不稳定、易失效。可用爬虫定期从免费代理网站（如 xicidaili、kuaidaili）抓取可用代理，并验证可用性。
   • 付费代理：阿布云、快代理等付费代理服务，更稳定、更安全。
3. 在 Scrapy 中配置代理
   • 这样 Scrapy 在每次请求时会随机从 PROXY_LIST 中取一个代理。

自定义 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

简单在 settings.py 中设置：

# settings.py
# 下载中间件（若自定义 proxy pool、user-agent，则参照上文中间件示例）
DOWNLOADER_MIDDLEWARES = {
    'scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware': 110,
    'myproject.middlewares.RandomProxyMiddleware': 100,
}
# 代理列表
PROXY_LIST = [
    'http://ip1:port1',
    'http://ip2:port2',
    # ...
]

搭建本地简单代理池示例（以免费代理为例，仅供学习）

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)
    # 实际爬虫中使用示例：
    proxy = get_random_proxy(proxy_list)
    if proxy:
        resp = requests.get('https://example.com', proxies={'http': proxy, 'https': proxy}, timeout=10)
        print(resp.status_code)

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

本节以'爬取某模拟新闻网站（示例：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 完整实现

1. 运行爬虫
   • 确保 MySQL 已创建数据库 news_db，用户名、密码正确；

运行期间，日志会显示抓取进度，成功后可在 headline_news 表中查看抓取结果：

SELECT * FROM headline_news LIMIT 10;

在项目根目录执行：

scrapy crawl news

编写 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):
        # 假设 date_str 格式为 '2025-05-30 14:30:00'
        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:
            # URL 已存在则跳过
            pass
        return item

自定义中间件：随机 User-Agent (news_spider/middlewares.py)

import random

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)

设置 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 轮换，防止被封。
• Q：为什么要随机 User-Agent？
  • 防止被网站识别为爬虫。
• Q：如何在 Scrapy 中使用代理？
  • 参考第 11.4 节，在 DOWNLOADER_MIDDLEWARES 中配置自己的 RandomProxyMiddleware，或直接使用 Scrapy-Proxy-Pool 等库。

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 爬虫世界！