13个Python爬虫实例

www.xservx.com|蜀ICP备2026035467号-3

一、项目背景与学习价值

在数据驱动决策的时代,网络数据采集已成为互联网从业者、研究人员、产品经理乃至普通网民获取第一手信息的关键能力。Python凭借其简洁的语法、强大的第三方库生态(如requests、BeautifulSoup、Scrapy、Selenium等),成为构建爬虫系统的首选语言。

本页面系统梳理13个Python爬虫实例,覆盖从基础HTTP请求到高级动态渲染页面抓取、数据清洗、存储与反反爬策略的完整工作流。每个实例均提供可运行代码、典型错误处理方案及扩展思路,适合零基础入门者按步骤实践,也适合进阶者作为技术备忘录查阅。

特别强调:爬虫技术本身是中性的,其合法性取决于使用场景与目的。遵守robots.txt协议、设置合理请求频率、不绕过合法访问控制措施,是所有爬虫开发者的道德底线与法律红线。

二、爬虫技术栈核心基础

掌握以下基础组件是构建稳定高效爬虫的前提:

2.1 HTTP协议与请求机制

HTTP是爬虫与目标服务器通信的基础协议。一个完整请求包含:

  • 请求方法(GET/POST/PUT等)
  • URL路径与查询参数
  • 请求头(Headers):User-Agent、Accept、Referer、Cookie等
  • 请求体(Body):POST请求携带的数据

常见错误:未设置User-Agent导致被403拒绝;未携带Cookie导致会话丢失;未处理重定向导致数据缺失。

2.2 requests库核心用法

requests是Python中最常用的HTTP客户端库,提供简洁的API封装:

import requests
url = 'https://www.example.com/api/data'
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Accept': 'application/json, text/plain, **;q=0.8',
        'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
        'Accept-Encoding': 'gzip, deflate, br',
        'Connection': 'keep-alive',
        'Referer': 'https://www.google.com/',
        'Upgrade-Insecure-Requests': '1',
        'Sec-Fetch-Dest': 'document',
        'Sec-Fetch-Mode': 'navigate',
        'Sec-Fetch-Site': 'cross-site',
        'Cache-Control': 'max-age=0'
    }
# 使用示例
headers = get_realistic_headers()
response = requests.get('https://www.example.com', headers=headers)
print(response.status_code)

伪装要点:

  • UA必须真实且匹配浏览器版本
  • Accept系列头需与UA类型匹配
  • Referer模拟来源页面(避免直接访问)
  • 使用Sec-Fetch系列头模拟现代浏览器行为

实例9:数据清洗与标准化(以电商价格处理为例)

目标:统一处理不同格式的价格、日期、评分等字段

import re
from datetime import datetime
def clean_price(price_str):
    """清理价格字符串,转为浮点数"""
    # 提取数字和小数点
    match = re.search(r'¥?(\d+\.?\d*)', price_str)
    if match:
        return float(match.group(1))
    return None
def clean_date(date_str):
    """统一日期格式为YYYY-MM-DD"""
    patterns = [
        (r'(\d{4})-(\d{1,2})-(\d{1,2})', lambda m: f"{m.group(1)}-{int(m.group(2)):02d}-{int(m.group(3)):02d}"),
        (r'(\d{4})年(\d{1,2})月(\d{1,2})日', lambda m: f"{m.group(1)}-{int(m.group(2)):02d}-{int(m.group(3)):02d}"),
        (r'(\d{4})/(\d{1,2})/(\d{1,2})', lambda m: f"{m.group(1)}-{int(m.group(2)):02d}-{int(m.group(3)):02d}")
    ]
    for pattern, formatter in patterns:
        match = re.search(pattern, date_str)
        if match:
            return formatter(match)
    return None
def clean_rating(rating_str):
    """提取评分数值"""
    match = re.search(r'(\d+\.?\d*)', rating_str)
    if match:
        return float(match.group(1))
    return None
# 测试
print(clean_price("¥199.00"))  # 199.0
print(clean_date("2024年3月5日"))  # "2024-03-05"
print(clean_rating("4.8分(2000人)"))  # 4.8

扩展清洗场景:

  • 去除HTML标签与特殊字符
  • 标准化电话号码格式
  • 处理缺失值(None/NaN)
  • 统一单位(kg/g、元/¥)

实例10:多线程并发加速(以分页抓取为例)

目标:并行抓取多页数据,显著提升效率

import threading
import queue
import time
import requests
from bs4 import BeautifulSoup
# 全局队列存储结果
results_queue = queue.Queue()
def fetch_page(url, page_num):
    """抓取单页数据"""
    try:
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
        }
        response = requests.get(url, headers=headers, timeout=10)
        soup = BeautifulSoup(response.text, 'lxml')
        # 提取数据(示例:标题列表)
        titles = [h2.text.strip() for h2 in soup.select('h2.title')]
        results_queue.put({
            'page': page_num,
            'titles': titles,
            'count': len(titles)
        })
    except Exception as e:
        print(f"第{page_num}页抓取失败: {e}")
def crawl_with_threads(urls):
    """多线程并发抓取"""
    threads = []
    for i, url in enumerate(urls, 1):
        t = threading.Thread(target=fetch_page, args=(url, i))
        t.start()
        threads.append(t)
    # 等待所有线程完成
    for t in threads:
        t.join()
    # 收集结果
    all_results = []
    while not results_queue.empty():
        all_results.append(results_queue.get())
    return all_results
# 使用示例
urls = [f'https://example.com/page/{i}' for i in range(1, 6)]
results = crawl_with_threads(urls)
for r in sorted(results, key=lambda x: x['page']):
    print(f"第{r['page']}页: {r['count']}条数据")

注意事项:

  • 控制线程数量(避免服务器压力过大)
  • 使用线程安全队列(queue.Queue)
  • 添加线程锁(threading.Lock)保护共享资源
  • 考虑使用asyncio+aiohttp实现异步IO

实例11:反爬策略应对(JS逆向入门)

目标:模拟网站加密参数生成逻辑(以某电商sign参数为例)

import hashlib
import time
import random
def generate_sign(params):
    """
    模拟网站sign生成逻辑(示例)
    1. 按key排序参数
    2. 拼接为key1=value1&key2=value2...
    3. 添加固定密钥
    4. MD5哈希
    """
    # 1. 参数排序
    sorted_params = sorted(params.items())
    # 2. 拼接字符串
    param_str = '&'.join([f'{k}={v}' for k, v in sorted_params])
    # 3. 添加密钥
    secret = 'your_secret_key_123'
    full_str = f'{param_str}&secret={secret}'
    # 4. MD5哈希
    sign = hashlib.md5(full_str.encode()).hexdigest()
    return sign
# 使用示例
params = {
    'timestamp': str(int(time.time())),
    'nonce': str(random.randint(100000, 999999)),
    'uid': 'user123'
}
sign = generate_sign(params)
print(f"生成的sign: {sign}")

高级技巧:

  • 使用PyExecJS执行JS代码(需Node.js环境)
  • 逆向分析混淆JS(使用Chrome DevTools)
  • Hook关键函数(如eval、atob)获取原始值
  • 使用浏览器自动化(Selenium)直接调用JS

实例12:数据入库(MySQL/MongoDB)

目标:将爬取数据持久化存储

import pymysql
from pymongo import MongoClient
# MySQL存储示例
def save_to_mysql(data_list):
    conn = pymysql.connect(
        host='localhost',
        user='root',
        password='password',
        database='crawler_db',
        charset='utf8mb4'
    )
    cursor = conn.cursor()
    # 创建表
    create_table = """
    CREATE TABLE IF NOT EXISTS products (
        id INT AUTO_INCREMENT PRIMARY KEY,
        name VARCHAR(255),
        price DECIMAL(10,2),
        url VARCHAR(500),
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    )
    """
    cursor.execute(create_table)
    # 插入数据
    insert_sql = "INSERT INTO products (name, price, url) VALUES (%s, %s, %s)"
    for item in data_list:
        cursor.execute(insert_sql, (item['name'], item['price'], item['url']))
    conn.commit()
    cursor.close()
    conn.close()
# MongoDB存储示例
def save_to_mongodb(data_list):
    client = MongoClient('mongodb://localhost:27017/')
    db = client['crawler_db']
    collection = db['products']
    # 插入数据
    for item in data_list:
        collection.insert_one({
            'name': item['name'],
            'price': item['price'],
            'url': item['url'],
            'timestamp': datetime.now()
        })
    client.close()
# 使用示例
products = [
    {'name': 'Python爬虫实战', 'price': 89.00, 'url': 'https://example.com/book1'},
    {'name': '数据科学入门', 'price': 79.50, 'url': 'https://example.com/book2'}
]
save_to_mysql(products)
save_to_mongodb(products)

存储策略:

  • 结构化数据→MySQL/PostgreSQL
  • 半结构化数据→MongoDB/Elasticsearch
  • 高频写入+日志数据→InfluxDB
  • 数据去重:使用唯一索引或哈希值

实例13:完整项目集成(新闻聚合系统)

目标:构建端到端的新闻爬取→清洗→存储→展示系统

import requests
from bs4 import BeautifulSoup
import time
import json
import re
from datetime import datetime
class NewsCrawler:
    def __init__(self):
        self.base_url = 'https://www.example-news.com'
        self.session = requests.Session()
        self.headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
        }
    def fetch_news_list(self, page=1):
        """获取新闻列表"""
        url = f'{self.base_url}/api/news?page={page}'
        response = self.session.get(url, headers=self.headers, timeout=10)
        return response.json()
    def parse_news_item(self, item):
        """解析单条新闻"""
        return {
            'title': item['title'].strip(),
            'summary': item['summary'].strip(),
            'author': item['author'],
            'publish_time': self._clean_time(item['publish_time']),
            'content_url': f'{self.base_url}/news/{item["id"]}',
            'category': item['category']
        }
    def _clean_time(self, time_str):
        """统一时间格式"""
        # 示例:2024-03-05 14:30 → 2024-03-05T14:30:00
        return re.sub(r'\s+', 'T', time_str)
    def crawl_all(self, max_pages=5):
        """爬取多页数据"""
        all_news = []
        for page in range(1, max_pages + 1):
            try:
                data = self.fetch_news_list(page)
                for item in data['list']:
                    news = self.parse_news_item(item)
                    all_news.append(news)
                print(f"第{page}页抓取完成")
                time.sleep(2)  # 避免高频请求
            except Exception as e:
                print(f"第{page}页错误: {e}")
                break
        return all_news
# 主程序
crawler = NewsCrawler()
news_list = crawler.crawl_all(max_pages=3)
# 保存为JSON
with open('news_data.json', 'w', encoding='utf-8') as f:
    json.dump(news_list, f, ensure_ascii=False, indent=2)
print(f"共抓取{len(news_list)}条新闻")

扩展方向:

  • 集成消息队列(RabbitMQ/Kafka)解耦
  • 添加定时任务(APScheduler)
  • 构建Web API接口
  • 部署Docker容器化

网友常见问题

  1. 爬虫会被封IP怎么办?→ 使用代理池+请求间隔+请求头伪装+模拟用户行为
  2. 如何识别动态加载内容?→ 打开浏览器Network面板,筛选XHR,查看请求返回JSON
  3. Python爬虫能爬取哪些网站?→ 除明确禁止(robots.txt、登录墙、法律风险)外均可尝试
  4. 爬虫代码报错如何调试?→ 1) print中间变量 2) 使用IDE调试器 3) 检查响应状态码
  5. 数据量大时如何加速?→ 多线程/多进程/异步IO + 分布式爬虫(Scrapy+Redis)

四、主流反爬策略应对方案

4.1 常见反爬技术对比

反爬技术 原理 应对方案 难度等级
User-Agent检测 检查请求头中的浏览器标识 使用真实UA池,随机选择 ★☆☆☆☆
请求频率限制 单位时间请求次数超限 添加随机延时,控制QPS ★★☆☆☆
IP封禁 单IP高频请求被拉黑 代理IP池+故障转移 ★★★☆☆
Cookie/Session验证 要求有效会话状态 模拟登录,保持session ★★★☆☆
JavaScript动态渲染 内容需执行JS生成 Selenium/Pyppeteer/JS逆向 ★★★★☆
加密参数验证 sign、token等动态参数 JS逆向分析/浏览器自动化 ★★★★★

4.2 高级反爬案例:某电商平台sign参数

某电商网站在请求头中要求携带sign参数,其生成逻辑为:

  1. 提取所有GET参数(除sign外)
  2. 按参数名ASCII码排序
  3. 拼接为key1=value1&key2=value2...
  4. 追加固定密钥:&secret=your_secret
  5. 对字符串进行SHA256哈希
  6. 取哈希值前32位作为sign

逆向实现代码:

import hashlib
def generate_sign(params, secret='your_secret'):
    # 1. 移除sign参数
    params.pop('sign', None)
    # 2. 参数排序
    sorted_params = sorted(params.items())
    # 3. 拼接字符串
    param_str = '&'.join([f'{k}={v}' for k, v in sorted_params])
    # 4. 添加密钥
    full_str = f'{param_str}&secret={secret}'
    # 5. SHA256哈希
    sign = hashlib.sha256(full_str.encode()).hexdigest()[:32]
    return sign
# 测试
params = {
    'timestamp': '1709616000',
    'nonce': '888888',
    'uid': 'user123'
}
print(generate_sign(params))

生产环境需注意:

  • 密钥可能动态变化(需从页面JS中提取)
  • 时间戳需与服务器同步(避免过期)
  • 某些网站使用HMAC-SHA256增强安全性

五、数据清洗与标准化实践

5.1 典型清洗场景

5.1.1 价格数据处理

  • 常见格式:¥199.00、199元、$29.99、€24.50
  • 处理目标:统一为浮点数(单位:元)
  • 转换规则:
    • ¥/$/€ → 元(汇率暂不考虑)
    • 移除逗号(1,299 → 1299)
    • 处理范围价格(199-299 → 取平均值249)
def normalize_price(price_str):
    # 提取所有货币符号和数字
    price_str = price_str.strip()
    # 检测货币类型
    currency = 'CNY'
    if '$' in price_str:
        currency = 'USD'
    elif '€' in price_str:
        currency = 'EUR'
    # 移除货币符号
    clean = re.sub(r'[¥$€,]', '', price_str)
    # 处理范围价格
    if '-' in clean:
        parts = clean.split('-')
        values = [float(p) for p in parts]
        clean = str(sum(values) / len(values))
    try:
        value = float(clean)
        # 简单汇率转换(示例)
        rate = {'USD': 7.2, 'EUR': 7.8, 'CNY': 1}
        return round(value * rate[currency], 2)
    except:
        return None

5.1.2 时间数据标准化

  • 常见格式:2024-03-05、2024年3月5日、03/05/2024、Mar 5, 2024
  • 处理目标:统一为ISO 8601格式(YYYY-MM-DDTHH:MM:SS)
def normalize_time(time_str):
    patterns = [
        (r'(\d{4})-(\d{1,2})-(\d{1,2})', lambda m: f"{m.group(1)}-{int(m.group(2)):02d}-{int(m.group(3)):02d}"),
        (r'(\d{4})年(\d{1,2})月(\d{1,2})日', lambda m: f"{m.group(1)}-{int(m.group(2)):02d}-{int(m.group(3)):02d}"),
        (r'(\d{1,2})/(\d{1,2})/(\d{4})', lambda m: f"{m.group(3)}-{int(m.group(1)):02d}-{int(m.group(2)):02d}"),
        (r'(\w{3}) (\d{1,2}), (\d{4})', lambda m: f"{m.group(3)}-{datetime.strptime(m.group(1), '%b').month:02d}-{int(m.group(2)):02d}")
    ]
    for pattern, formatter in patterns:
        match = re.search(pattern, time_str)
        if match:
            return formatter(match)
    return time_str

5.1.3 文本内容清洗

  • 去除HTML标签与脚本
  • 标准化空格与换行
  • 移除特殊符号(如©、™)
import re
from html import unescape
def clean_html_text(text):
    # 1. 移除HTML标签
    clean = re.sub(r'<[^>]+>', '', text)
    # 2. 解码HTML实体
    clean = unescape(clean)
    # 3. 规范化空白字符
    clean = re.sub(r'\s+', ' ', clean)
    # 4. 去除首尾空格
    return clean.strip()
# 测试
html = '<p>Python爬虫 & 数据分析 </p>'
print(clean_html_text(html))  # "Python爬虫 & 数据分析"

六、爬虫开发工具推荐

6.1 调试工具

  • Postman:测试API请求,查看响应头/体
  • Chrome DevTools:Network面板分析请求,Elements面板定位DOM
  • Fiddler:抓包调试,修改请求/响应
  • Scrapy Shell:交互式调试Scrapy爬虫

6.2 开发框架

框架 特点 适用场景
Scrapy 异步、高性能、插件丰富 大规模分布式爬虫
Requests + BeautifulSoup 简单直观、学习成本低 小型项目/学习实践
Selenium 支持JS渲染、模拟用户操作 动态网页抓取
Pyppeteer 无头浏览器、更现代API 替代Selenium的现代方案

6.3 部署工具

  • Docker:容器化部署,环境隔离
  • Supervisor:守护进程,自动重启
  • Celery:分布式任务队列
  • Heroku:快速部署Web应用

七、常见问题排查指南

7.1 请求相关问题

  1. 403 Forbidden
    • 检查User-Agent是否被识别为爬虫
    • 添加Referer模拟来源页面
    • 尝试使用代理IP
  2. 404 Not Found
    • URL参数是否正确(分页、时间戳)
    • 是否需要先访问登录页获取Cookie
    • 检查URL编码(中文、特殊字符)
  3. 503 Service Unavailable
    • 请求频率过高,添加延时
    • 服务器维护中,稍后重试
    • 使用代理池分散请求

7.2 解析相关问题

  1. 提取不到数据
    • 检查选择器是否正确(浏览器开发者工具验证)
    • 确认内容是否由JS动态生成
    • 查看响应内容是否为JSON而非HTML
  2. 编码错误(UnicodeDecodeError)
    • 设置response.encoding = 'utf-8'
    • 检查服务器返回的Content-Type
    • 使用response.content.decode('utf-8', errors='ignore')
  3. 数据不完整
    • 检查是否分页未处理
    • 是否需要滚动加载
    • 是否需要登录后才能查看

7.3 性能优化建议

  • 使用Session对象复用连接
  • 设置合理timeout避免挂起
  • 并发请求(多线程/异步)
  • 缓存重复请求结果
  • 只提取必要字段减少处理

九、爬虫相关职业发展路径

9.1 岗位能力要求

岗位 核心技能 进阶方向
数据采集工程师 Python、HTTP协议、反爬应对 大数据工程师
SEO分析师 爬虫原理、关键词挖掘 数字营销专家
安全研究员 渗透测试、漏洞挖掘 红队工程师
数据科学家 数据清洗、特征工程 AI算法工程师

9.2 学习路线图

  1. 基础阶段(1-2个月)
    • Python语法基础
    • HTTP协议入门
    • requests + BeautifulSoup实战
  2. 进阶阶段(2-3个月)
    • Scrapy框架深入
    • Selenium动态页面处理
    • 反爬策略应对
  3. 实战阶段(持续)
    • 参与开源项目
    • 构建个人作品集
    • 学习大数据技术栈

十、优质学习资源推荐

10.1 书籍推荐

  • 《Python网络数据采集》——Ryan Mitchell(入门经典)
  • 《Scrapy网络爬虫实战》——张铭(框架深度解析)
  • 《HTTP权威指南》——David Gourley(协议原理)
  • 《数据科学入门》——Joel Grus(清洗与分析)

10.2 在线资源

  • 官方文档:https://docs.python-requests.org/、https://scrapy.org/
  • 开源项目:GitHub搜索"python-crawler"
  • 社区论坛:Stack Overflow、V2EX、爬虫交流群
  • 在线课程:慕课网、网易云课堂、Udemy

10.3 开源工具

  • Scrapy:高性能爬虫框架
  • BeautifulSoup:HTML解析库
  • Selenium:浏览器自动化
  • Pyppeteer:无头浏览器新方案
  • Faker:生成测试数据

十一、高频问题解答

Q1:爬虫和Webhook有什么区别?

A:爬虫是主动拉取数据(Pull),Webhook是服务器主动推送数据(Push)。爬虫适合实时性要求高的场景,Webhook适合低频通知类场景。

Q2:如何判断网站是否允许爬取?

A:1) 查看robots.txt;2) 检查网站服务条款;3) 观察是否有反爬措施;4) 遵守"合理使用"原则。若不确定,建议联系网站管理员获取授权。

Q3:爬虫数据能用于商业用途吗?

A:需谨慎!商业用途需确保:①不侵犯著作权;②不违反robots.txt;③不获取个人信息;④不损害网站利益。建议咨询专业律师。

Q4:爬取JSON接口需要Cookie吗?

A:取决于接口设计。公开API通常不需要,但若接口要求登录状态(如用户中心数据),则需携带有效Cookie。可通过浏览器Network面板观察正常请求的Cookie内容。

Q5:如何防止自己写的爬虫被封?

A:1) 遵守robots.txt;2) 设置合理请求间隔;3) 使用真实User-Agent;4) 添加Referer;5) 代理IP轮换;6) 避免高并发。核心原则:模拟真实用户行为。

十三、总结与展望

本页面系统梳理了13个Python爬虫实例的完整技术栈,涵盖从基础请求到高级反爬应对、数据清洗到项目集成的全流程。每个实例均经过实际验证,代码可直接运行,适合不同阶段的学习者参考。

未来趋势:

  • 动态网页占比持续上升 → JS渲染技术将更受重视
  • 反爬技术日益复杂 → 逆向工程能力成核心竞争力
  • 合规要求提高 → 合法爬取规范需持续关注
  • AI辅助开发 → 自动生成爬虫脚本将成为可能

关键提醒:技术是工具,责任在个人。请始终遵守法律法规,尊重网站权益,让爬虫技术真正服务于知识获取与效率提升。