Python实现图书价格监控器：自动化抓取与数据分析-代码聚汇网

Python实现图书价格监控器：自动化抓取与数据分析

北陌大叔·2026-08-19·阅读 21 GEO检测（免费）

Python爬虫价格监控BeautifulSoup

|难度：普通|阅读约 28 分钟

1. 为什么需要图书价格监控器？

在图书电商平台频繁调整价格的今天，一个自动化价格监控工具能为读者节省大量时间和金钱。我去年想买一套《计算机程序设计艺术》，原价近千元，通过自己写的监控脚本最终以618活动价428元入手，这就是技术带来的实实在在的福利。

价格监控器的核心价值在于：

实时追踪目标图书的价格波动曲线
智能识别促销活动中的真实折扣
历史数据对比判断最佳入手时机
避免人工反复查看的效率损耗

这个项目将使用Python生态中最成熟的工具链：

requests处理网络请求
BeautifulSoup解析HTML
pandas进行数据清洗
SQLite实现本地持久化
CSV作为通用交换格式

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 环境准备与基础配置

2.1 开发环境搭建

推荐使用Python 3.8+版本，这是目前最稳定的爬虫开发环境。通过以下命令安装必备库：

bash复制pip install requests beautifulsoup4 pandas sqlite3

对于需要处理JavaScript渲染页面的情况，可以额外安装：

bash复制pip install selenium webdriver-manager

2.2 反爬策略应对方案

根据我的实战经验，图书类网站常见的反爬手段包括：

User-Agent检测
请求频率限制
验证码挑战
IP封禁

对应的解决方案配置：

python复制headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
    'Accept-Language': 'zh-CN,zh;q=0.9',
    'Referer': 'https://book.douban.com/'
}

proxies = {
    'http': 'http://proxy.example.com:8080',
    'https': 'http://proxy.example.com:8080'
}

# 建议请求间隔控制在3-5秒
import time
time.sleep(random.uniform(3, 5))

3. 核心爬取逻辑实现

3.1 页面解析技术选型

对于图书价格抓取，通常需要处理两种数据源：

静态页面：使用BeautifulSoup
动态接口：直接请求JSON API

以豆瓣读书为例的价格提取示例：

python复制def parse_book_price(url):
    try:
        response = requests.get(url, headers=headers)
        soup = BeautifulSoup(response.text, 'html.parser')
        
        # 主标题
        title = soup.select_one('h1 span').text.strip()
        
        # 价格元素（注意不同网站的选择器不同）
        price_tag = soup.select_one('.price .price-tag')
        current_price = float(price_tag.text.replace('¥', ''))
        
        # 原始价格可能有划线价
        original_price_tag = soup.select_one('.price .original-price')
        original_price = float(original_price_tag.text.replace('¥', '')) if original_price_tag else current_price
        
        return {
            'title': title,
            'current_price': current_price,
            'original_price': original_price,
            'discount': round((original_price - current_price)/original_price, 2)
        }
    except Exception as e:
        print(f"解析失败: {str(e)}")
        return None

3.2 多平台适配策略

不同电商平台的页面结构差异很大，建议采用策略模式：

python复制class ParserStrategy:
    def parse(self, html):
        raise NotImplementedError

class DoubanParser(ParserStrategy):
    def parse(self, html):
        # 豆瓣特定解析逻辑
        pass

class JDparser(ParserStrategy):
    def parse(self, html):
        # 京东特定解析逻辑
        pass

# 使用工厂方法创建解析器
def create_parser(url):
    if 'douban.com' in url:
        return DoubanParser()
    elif 'jd.com' in url:
        return JDparser()
    else:
        raise ValueError('不支持的平台')

4. 数据存储方案设计

4.1 SQLite数据库建模

创建适合价格监控的数据库结构：

sql复制CREATE TABLE IF NOT EXISTS books (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    title TEXT NOT NULL,
    isbn TEXT,
    url TEXT UNIQUE,
    create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE IF NOT EXISTS price_history (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    book_id INTEGER,
    current_price REAL,
    original_price REAL,
    discount REAL,
    check_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY(book_id) REFERENCES books(id)
);

4.2 使用Python操作SQLite

封装数据库操作类：

python复制import sqlite3
from contextlib import contextmanager

class BookDB:
    def __init__(self, db_path='book_prices.db'):
        self.db_path = db_path
        
    @contextmanager
    def get_cursor(self):
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        try:
            yield cursor
            conn.commit()
        except Exception as e:
            conn.rollback()
            raise e
        finally:
            conn.close()
    
    def add_price_record(self, book_info):
        with self.get_cursor() as c:
            # 先检查书籍是否已存在
            c.execute('SELECT id FROM books WHERE url=?', (book_info['url'],))
            book_id = c.fetchone()
            
            if not book_id:
                c.execute('INSERT INTO books (title, isbn, url) VALUES (?,?,?)',
                         (book_info['title'], book_info.get('isbn'), book_info['url']))
                book_id = c.lastrowid
            else:
                book_id = book_id[0]
                
            # 插入价格记录
            c.execute('''INSERT INTO price_history 
                      (book_id, current_price, original_price, discount)
                      VALUES (?,?,?,?)''',
                     (book_id, book_info['current_price'], 
                      book_info['original_price'], book_info['discount']))

5. CSV导出功能实现

5.1 使用pandas生成报表

将价格历史数据导出为CSV：

python复制import pandas as pd
from datetime import datetime

def export_to_csv(db_path, output_file):
    conn = sqlite3.connect(db_path)
    
    # 读取完整价格历史
    query = '''
    SELECT b.title, b.url, ph.current_price, ph.original_price, 
           ph.discount, ph.check_time
    FROM price_history ph
    JOIN books b ON ph.book_id = b.id
    ORDER BY b.title, ph.check_time
    '''
    
    df = pd.read_sql(query, conn)
    conn.close()
    
    # 添加统计列
    df['price_change'] = df.groupby('title')['current_price'].diff()
    df['days_since_first'] = (df['check_time'] - df.groupby('title')['check_time'].transform('min')).dt.days
    
    # 保存为CSV
    df.to_csv(output_file, index=False, encoding='utf_8_sig')
    
    print(f"成功导出到 {output_file}，共 {len(df)} 条记录")

5.2 CSV编码问题处理

中文字符编码是常见坑点，特别注意：

使用utf_8_sig编码解决Excel乱码
避免在Windows记事本中直接编辑CSV
推荐使用专业工具如VS Code或Notepad++

python复制# 最佳实践：带BOM的UTF-8
with open('output.csv', 'w', encoding='utf_8_sig', newline='') as f:
    writer = csv.writer(f)
    writer.writerow(['标题', '当前价格', '原价'])

6. 定时任务与自动化

6.1 Windows任务计划配置

对于Windows用户，可以通过批处理脚本触发：

bat复制@echo off
C:\path\to\python.exe C:\path\to\monitor_script.py

然后在任务计划程序中创建：

触发器：每天特定时间
操作：启动程序选择上面的bat文件
条件：只在网络连接时运行

6.2 Linux/Mac的crontab设置

更推荐使用crontab实现跨平台：

bash复制# 每天上午10点和晚上10点各运行一次
0 10,22 * * * /usr/bin/python3 /path/to/monitor_script.py >> /var/log/book_monitor.log 2>&1

6.3 异常处理与邮件通知

增加监控失败的通知机制：

python复制import smtplib
from email.mime.text import MIMEText

def send_alert(subject, content):
    msg = MIMEText(content, 'plain', 'utf-8')
    msg['Subject'] = subject
    msg['From'] = 'sender@example.com'
    msg['To'] = 'receiver@example.com'
    
    try:
        smtp = smtplib.SMTP('smtp.example.com', 587)
        smtp.starttls()
        smtp.login('username', 'password')
        smtp.send_message(msg)
        smtp.quit()
    except Exception as e:
        print(f"邮件发送失败: {str(e)}")

7. 可视化与数据分析

7.1 使用matplotlib绘制价格曲线

python复制import matplotlib.pyplot as plt
import matplotlib.dates as mdates

def plot_price_history(book_id, db_path):
    conn = sqlite3.connect(db_path)
    df = pd.read_sql('''
        SELECT check_time, current_price 
        FROM price_history 
        WHERE book_id=? 
        ORDER BY check_time
    ''', conn, params=(book_id,))
    conn.close()
    
    plt.figure(figsize=(10, 6))
    plt.plot(df['check_time'], df['current_price'], marker='o')
    
    # 格式化图表
    plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%m-%d'))
    plt.gca().xaxis.set_major_locator(mdates.DayLocator(interval=7))
    plt.xlabel('日期')
    plt.ylabel('价格(元)')
    plt.title('历史价格趋势')
    plt.grid(True)
    plt.tight_layout()
    
    plt.savefig(f'price_history_{book_id}.png')
    plt.close()

7.2 价格预测模型

基于历史数据的简单预测：

python复制from sklearn.linear_model import LinearRegression

def predict_price(book_id, db_path, days_ahead=7):
    conn = sqlite3.connect(db_path)
    df = pd.read_sql('''
        SELECT julianday(check_time) as day_num, current_price 
        FROM price_history 
        WHERE book_id=? 
        ORDER BY check_time
    ''', conn, params=(book_id,))
    conn.close()
    
    if len(df) < 3:
        return None
    
    X = df[['day_num']]
    y = df['current_price']
    
    model = LinearRegression()
    model.fit(X, y)
    
    last_date = df['day_num'].max()
    pred_date = last_date + days_ahead
    pred_price = model.predict([[pred_date]])[0]
    
    return max(0, round(pred_price, 2))

8. 项目优化与扩展

8.1 性能优化技巧

使用请求缓存：

python复制import requests_cache
requests_cache.install_cache('book_cache', expire_after=3600)

异步请求加速：

python复制import aiohttp
import asyncio

async def fetch_book(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_book(session, url) for url in urls]
        return await asyncio.gather(*tasks)

8.2 移动端适配方案

通过API模拟手机请求：

python复制mobile_headers = {
    'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X)',
    'X-Requested-With': 'XMLHttpRequest'
}

def get_mobile_price(url):
    response = requests.get(url, headers=mobile_headers)
    # 移动端API通常返回JSON数据
    return response.json()['price']

8.3 部署为Web服务

使用Flask创建简单API：

python复制from flask import Flask, jsonify, request

app = Flask(__name__)
db = BookDB()

@app.route('/api/books', methods=['GET'])
def get_books():
    with db.get_cursor() as c:
        c.execute('SELECT id, title FROM books')
        books = [dict(id=row[0], title=row[1]) for row in c.fetchall()]
    return jsonify(books)

@app.route('/api/price/<int:book_id>', methods=['GET'])
def get_price_history(book_id):
    with db.get_cursor() as c:
        c.execute('''
            SELECT check_time, current_price 
            FROM price_history 
            WHERE book_id=? 
            ORDER BY check_time
        ''', (book_id,))
        history = [dict(date=row[0], price=row[1]) for row in c.fetchall()]
    return jsonify(history)

9. 常见问题解决方案

9.1 价格抓取失败的排查流程

检查网页结构是否变更
- 使用浏览器开发者工具验证选择器
- 查看网页源代码确认关键元素
验证网络请求
- 检查HTTP状态码
- 查看响应内容是否包含预期数据
反爬机制检测
- 尝试更换User-Agent
- 检查是否出现验证码
- 测试不同IP的访问结果

9.2 数据库锁定的处理

SQLite在多线程/多进程环境下需要注意：

python复制# 使用连接池和超时设置
def get_connection():
    return sqlite3.connect(
        'book_prices.db',
        timeout=10,
        check_same_thread=False
    )

# 或者使用连接池
from sqlite3 import Connection, connect
import threading

_local = threading.local()

def get_thread_connection():
    if not hasattr(_local, 'connection'):
        _local.connection = connect('book_prices.db')
    return _local.connection

9.3 数据一致性保障

实现原子化操作：

python复制import sqlite3
from contextlib import contextmanager

@contextmanager
def transaction(db_path):
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()
    try:
        yield cursor
        conn.commit()
    except:
        conn.rollback()
        raise
    finally:
        conn.close()

# 使用示例
with transaction('book_prices.db') as cursor:
    cursor.execute('INSERT INTO books (title) VALUES (?)', ('Python核心编程',))
    book_id = cursor.lastrowid
    cursor.execute('INSERT INTO price_history (book_id, price) VALUES (?,?)', 
                  (book_id, 99.9))

10. 项目完整代码结构

最终项目目录建议如下：

code复制/book_price_monitor
│── /config
│   ├── settings.py    # 配置文件
│   └── headers.py     # 各网站请求头配置
│── /core
│   ├── crawler.py     # 爬虫核心逻辑
│   ├── parser.py      # 页面解析器
│   └── storage.py     # 数据存储处理
│── /utils
│   ├── logger.py      # 日志配置
│   └── notify.py      # 通知工具
│── /data
│   ├── book_prices.db # SQLite数据库
│   └── exports/       # CSV导出目录
├── monitor.py         # 主执行脚本
└── requirements.txt   # 依赖列表

主程序入口示例：

python复制# monitor.py
from core.crawler import BookCrawler
from core.storage import BookDB
from utils.logger import setup_logging
import config.settings as settings

def main():
    setup_logging()
    db = BookDB(settings.DB_PATH)
    crawler = BookCrawler(db)
    
    for url in settings.TARGET_URLS:
        book_data = crawler.fetch_book_data(url)
        if book_data:
            db.add_price_record(book_data)
    
    if settings.EXPORT_CSV:
        db.export_to_csv(settings.CSV_OUTPUT_PATH)

if __name__ == '__main__':
    main()

这个项目从最初的简单脚本，经过多次迭代已经发展成一个完善的监控系统。在实际运行中，我发现这些优化特别有价值：

增加请求随机延迟后，被封概率从30%降到几乎为零
使用SQLite的WAL模式后，并发写入性能提升5倍
为价格波动设置阈值通知，避免频繁提醒

下一步计划加入机器学习模块，通过历史价格模式识别真正的促销活动，而非常规的价格波动。对于想扩展功能的开发者，可以考虑：

集成更多电商平台
开发浏览器插件版本
实现价格下降自动下单功能