当前位置：首页 > 文章列表 > 文章 > python教程 > Python爬虫教程与实战技巧分享

Python爬虫教程与实战技巧分享

2026-01-15 09:44:52 0浏览收藏

最近发现不少小伙伴都对文章很感兴趣，所以今天继续给大家介绍文章相关的知识，本文《Python爬虫编写教程及实战技巧》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

答案是使用Python编写爬虫需经历目标分析、发送请求、解析内容、提取数据和存储结果五个核心步骤。首先明确要抓取的网站及所需数据，如博客文章标题和链接；接着用requests库发送HTTP请求获取网页HTML内容，并通过response.raise_for_status()检查请求是否成功；然后利用BeautifulSoup解析HTML，通过find_all和find等方法定位元素，提取文本和属性值，同时处理相对链接；获取数据后，可选择将结果保存为JSON或CSV文件，或存入SQLite、MongoDB等数据库以实现高效管理；面对动态网页中JavaScript渲染的内容，需采用Selenium或Playwright等无头浏览器工具模拟真实浏览行为，确保能获取完整数据；此外，还需应对反爬机制，如设置随机User-Agent、使用代理IP池、处理验证码，并遵守robots.txt协议和相关法律法规，确保爬取行为合法合规；最后，对数据进行清洗去重，并建立日志记录、定时调度与监控机制，保障爬虫长期稳定运行。

如何用Python编写一个爬虫？

用Python写爬虫，说白了，就是模拟浏览器去访问网页，然后把页面里的信息“抓”下来。这事儿核心就是两步：发请求获取网页内容，然后解析内容提取数据。最常用、最基础的工具组合就是requests库负责发请求，BeautifulSoup库负责解析HTML。

解决方案

要用Python写一个基本的爬虫，我们通常会从以下几个核心步骤开始。这不仅仅是代码的堆砌，更是一个思考和实践的过程。

首先，你需要明确目标。你要爬取哪个网站？想要什么数据？比如，我们想从一个简单的博客网站上抓取文章标题和链接。

1. 发送HTTP请求 Python的requests库是处理HTTP请求的利器。它让网络请求变得异常简单。

import requests

url = 'https://www.example.com/blog' # 假设这是你的目标博客URL
try:
    response = requests.get(url)
    response.raise_for_status() # 检查请求是否成功，如果不是200，会抛出HTTPError
    html_content = response.text
    print("网页内容获取成功！")
except requests.exceptions.RequestException as e:
    print(f"请求失败: {e}")
    html_content = None

这里有个小细节，response.raise_for_status()是个好习惯，能帮你快速发现网络或服务器问题，而不是让程序带着一个无效的响应继续跑。

2. 解析HTML内容 拿到HTML内容后，我们需要从中提取有用的信息。BeautifulSoup库（通常与lxml或html.parser解析器配合使用）在这方面表现出色。

from bs4 import BeautifulSoup

if html_content:
    soup = BeautifulSoup(html_content, 'html.parser') # 使用html.parser解析器
    # 假设文章标题都在h2标签里，并且链接在h2下的a标签里
    articles = soup.find_all('h2') # 找到所有h2标签

    data = []
    for article in articles:
        link_tag = article.find('a')
        if link_tag:
            title = link_tag.get_text(strip=True) # 获取标题文本，去除空白
            href = link_tag.get('href') # 获取链接
            if href and not href.startswith('http'): # 处理相对路径
                href = requests.utils.urljoin(url, href)
            data.append({'title': title, 'url': href})

    for item in data:
        print(f"标题: {item['title']}, 链接: {item['url']}")
else:
    print("无法解析，因为没有获取到有效的网页内容。")

BeautifulSoup的find_all()和find()方法让你能像CSS选择器一样定位元素。get_text()和get()则用来提取文本和属性值。处理相对路径是个常见坑，requests.utils.urljoin能优雅地解决。

3. 数据存储（可选但常用） 抓取到的数据通常需要保存下来。最简单的可以是CSV或JSON文件。

import json

if data:
    with open('articles.json', 'w', encoding='utf-8') as f:
        json.dump(data, f, ensure_ascii=False, indent=4)
    print("数据已保存到 articles.json")

这只是一个最基础的骨架。实际的爬虫项目会复杂得多，涉及到错误处理、反爬机制、数据清洗、多线程/异步、分布式等等。但核心思路，就是请求-解析-提取-存储。

Python爬虫开发中常见的挑战与应对策略

说起爬虫，它可不是一帆风顺的。我自己的经验告诉我，很多时候，代码写起来容易，但要让它稳定、高效地运行，遇到的挑战远比想象中多。这就像是在玩猫鼠游戏，网站总想阻止你，而你得想办法绕过去。

1. 反爬机制 这是最常见也最让人头疼的问题。网站为了保护自身资源，会采取各种手段阻止自动化访问：

IP封禁： 你的IP地址在短时间内访问频率过高，网站可能会直接封禁你的IP。
- 应对： 使用代理IP池。你可以购买高质量的代理服务，或者自己搭建代理池。每次请求随机更换IP，或者在被封后切换IP。这玩意儿就像是给你的爬虫“换脸”，让它看起来像是不同的访客。
User-Agent检测： 网站会检查你的请求头中的User-Agent字段，如果发现是爬虫常用的UA，就可能拒绝服务。
- 应对： 伪装User-Agent。维护一个User-Agent池，每次请求随机选择一个真实的浏览器UA。
验证码： 访问频率异常时，弹出图形验证码或滑块验证码。
- 应对： 简单的图形验证码可以用OCR库（如pytesseract）识别，但准确率不高。复杂的验证码（如滑动、点选）可能需要接入第三方打码平台，或者使用机器学习模型进行识别。当然，最省事的是尽量避免触发验证码。
Cookie/Session管理： 网站可能通过Cookie跟踪用户会话，没有正确携带Cookie的请求会被视为异常。
- 应对： requests库默认会管理会话，但如果需要模拟登录或维持特定会话，你需要手动处理Cookie，或者使用requests.Session()对象。
Referer检测： 检查请求的来源页面。
- 应对： 在请求头中设置一个合理的Referer字段。

2. 动态内容（JavaScript渲染） 很多现代网站的内容不是直接写在HTML里的，而是通过JavaScript在浏览器加载后动态生成的。requests库只能获取到原始HTML，拿不到JS渲染后的内容。

应对： 使用无头浏览器（Headless Browser）。Selenium、Playwright是这类工具的代表。它们能启动一个真实的浏览器（只是你看不到界面），执行JavaScript，然后获取JS渲染后的页面内容。这虽然能解决问题，但性能开销会大很多，速度也慢。

3. 数据存储与管理 爬取到的数据量可能非常大，如何高效、有组织地存储和管理它们是个问题。

应对：
- 小规模数据： CSV、JSON文件足够。
- 结构化数据： SQLite（本地文件数据库）、MySQL、PostgreSQL等关系型数据库是好选择。它们能确保数据完整性，方便查询。
- 非结构化/半结构化数据： MongoDB等NoSQL数据库更灵活，适合存储结构多变的数据。
- 数据清洗： 爬取到的数据往往不干净，有噪音、格式不统一。使用Pandas等库进行数据清洗和预处理是必不可少的步骤。

4. 爬虫的伦理与法律 这可能是最容易被忽视，但却最重要的挑战。

应对：
- robots.txt： 检查网站的robots.txt文件，它会告诉你哪些页面允许爬取，哪些不允许。尊重这些规则是基本原则。
- 访问频率： 不要对网站造成过大负担，设置合理的请求间隔（time.sleep()）。
- 数据用途： 明确你爬取数据的用途，不要用于非法目的，避免侵犯隐私和版权。
- 法律法规： 了解并遵守当地关于数据爬取和使用的法律法规。有些数据，即使能爬到，也可能不能公开使用。

面对这些挑战，没有一劳永逸的解决方案，更多的是根据具体情况灵活调整策略，不断尝试和优化。这正是爬虫开发的魅力所在，也是它的复杂之处。

如何处理动态网页内容和JavaScript渲染？

当你用requests库获取一个网页，却发现返回的HTML里压根没有你想要的数据，或者数据是空的，那八成就是碰上JavaScript渲染的动态网页了。我第一次遇到这情况时也挺懵的，心想：“这不科学啊，浏览器里明明看得到！”后来才明白，requests看到的只是服务器最初吐出的HTML，而浏览器在接收到HTML后，还会执行其中的JavaScript代码，这些代码可能会从其他地方加载数据，或者动态生成页面元素。

要解决这个问题，我们需要一个能够模拟浏览器行为的工具，让它不仅能加载HTML，还能执行JavaScript。目前主流的解决方案是使用无头浏览器（Headless Browser）。

什么是无头浏览器？ 你可以把它想象成一个没有图形界面的浏览器。它能像Chrome、Firefox一样加载网页、执行JavaScript、处理CSS、管理Cookie，但你却看不到它的窗口。这让它非常适合自动化测试和网页抓取。

主流的无头浏览器工具：

Selenium：

特点： 老牌的自动化测试框架，支持多种浏览器（Chrome, Firefox, Edge等）。它通过驱动程序（如ChromeDriver）与真实浏览器进行交互。
优点： 功能强大，生态成熟，可以模拟用户几乎所有的交互行为（点击、输入、滚动等）。
缺点： 性能开销较大，启动一个浏览器实例需要时间，内存占用也高，不适合大规模、高并发的爬取。
何时使用： 当你遇到复杂的JS渲染、需要模拟用户登录、点击等操作时，Selenium是首选。

Selenium基本示例： 首先，你需要安装selenium库和对应的浏览器驱动（比如ChromeDriver）。

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

# 配置Chrome选项，使其无头运行
chrome_options = Options()
chrome_options.add_argument("--headless") # 启用无头模式
chrome_options.add_argument("--disable-gpu") # 禁用GPU加速，有些系统可能需要
chrome_options.add_argument("--no-sandbox") # 某些Linux环境需要

# 指定ChromeDriver的路径（根据你的实际安装位置修改）
# service = Service('/path/to/chromedriver') # 如果驱动不在PATH中，需要指定路径

# 启动Chrome浏览器
driver = webdriver.Chrome(options=chrome_options) # 如果service没有指定，它会尝试在PATH中找

url = 'https://www.example.com/dynamic-content-page' # 假设这是一个动态加载内容的页面

try:
    driver.get(url)
    print(f"页面加载完成: {url}")
    time.sleep(3) # 等待JavaScript执行和内容加载，时间根据页面复杂程度调整

    # 现在可以获取渲染后的页面内容
    rendered_html = driver.page_source
    # print(rendered_html) # 打印查看渲染后的HTML

    # 使用BeautifulSoup解析渲染后的HTML
    from bs4 import BeautifulSoup
    soup = BeautifulSoup(rendered_html, 'html.parser')

    # 假设我们想找一个动态加载出来的元素
    dynamic_element = soup.find('div', class_='dynamic-data')
    if dynamic_element:
        print(f"找到动态数据: {dynamic_element.get_text(strip=True)}")
    else:
        print("未找到动态数据。")

except Exception as e:
    print(f"发生错误: {e}")
finally:
    driver.quit() # 关闭浏览器

这段代码会启动一个看不见的Chrome浏览器，访问页面，等待JS加载，然后把最终的HTML拿出来用BeautifulSoup解析。time.sleep(3)是关键，它给了页面足够的时间去执行JavaScript。

Playwright：
- 特点： 微软推出的新一代自动化测试和爬虫库，支持Chrome、Firefox、WebKit（Safari的引擎）。
- 优点： 相比Selenium，API更现代、更简洁，性能更好，内置了自动等待机制，处理异步操作更方便。
- 缺点： 相对较新，社区和资源不如Selenium丰富。
- 何时使用： 如果你追求更好的性能和更现代的API，或者需要跨浏览器测试，Playwright是优秀的选择。
requests-html：
- 特点： requests库的作者Kenneth Reitz开发的，试图在requests的简洁性和无头浏览器的能力之间找到平衡。它内部使用了pyppeteer（Chrome/Chromium的无头浏览器驱动）。
- 优点： API非常像requests，用起来直观，适合快速处理一些需要JS渲染的页面，但又不想引入完整Selenium的场景。
- 缺点： 功能不如Selenium/Playwright强大和灵活，对某些复杂的JS交互可能力不从心。
- 何时使用： 当你只需要简单的JS渲染，且不想引入重量级工具时，可以尝试。

选择哪种工具，取决于你的具体需求和页面的复杂程度。如果只是简单JS渲染，requests-html可能够用；如果需要模拟复杂交互，Selenium或Playwright会是更好的选择。但无论哪种，都要记住，无头浏览器会消耗更多的系统资源，所以在使用时要权衡好性能和功能。

高效数据存储与管理：爬取数据后该怎么做？

爬虫最核心的任务是获取数据，但数据拿到手，仅仅是万里长征的第一步。如何有效地存储、管理这些数据，让它们变得有价值，这同样是个大学问。我见过太多人，爬了一堆数据，结果就扔在几个零散的CSV文件里，想用的时候找半天，或者干脆就烂在那里了。这可不行，数据是资产，得好好打理。

1. 结构化与非结构化数据

首先要明确你爬取的数据是结构化的（比如表格数据、用户信息）还是非结构化的（比如文章正文、图片、视频链接）。这会直接影响你的存储选择。

2. 存储选项

文件存储 (CSV, JSON, TXT)

优点： 简单、直接，不需要额外配置数据库。对于小规模数据或一次性任务非常方便。JSON格式尤其适合存储半结构化数据，比如嵌套的字典和列表。
缺点： 随着数据量增大，文件读写效率会降低；数据查询、更新、删除操作不便；数据完整性难以保证；不适合多进程/多线程并发写入。
适用场景： 爬取数据量不大，或者作为临时存储、中间结果输出。

import csv
import json

# 存储到CSV
def save_to_csv(data_list, filename='output.csv', headers=None):
    if not data_list:
        return
    if not headers:
        headers = data_list[0].keys() # 假设数据是字典列表

    with open(filename, 'w', newline='', encoding='utf-8') as f:
        writer = csv.DictWriter(f, fieldnames=headers)
        writer.writeheader()
        writer.writerows(data_list)
    print(f"数据已保存到 {filename}")

# 存储到JSON
def save_to_json(data_list, filename='output.json'):
    with open(filename, 'w', encoding='utf-8') as f:
        json.dump(data_list, f, ensure_ascii=False, indent=4)
    print(f"数据已保存到 {filename}")

# 示例数据
sample_data = [
    {'title': 'Python爬虫入门', 'url': 'http://example.com/p1'},
    {'title': '数据存储策略', 'url': 'http://example.com/p2'}
]
save_to_csv(sample_data)
save_to_json(sample_data)

关系型数据库 (SQLite, MySQL, PostgreSQL)

优点： 强大的数据管理能力，支持SQL查询，数据完整性高，适合存储结构化数据。SQLite是轻量级的，一个文件就是一个数据库，无需独立服务器，非常适合本地开发和小型项目。MySQL和PostgreSQL则适合大型、并发量高的项目。
缺点： 需要预定义表结构（Schema），对非结构化数据支持不好；需要一定的数据库知识。
适用场景： 爬取的数据结构固定，需要频繁查询、分析、关联，或者数据量较大。

SQLite示例：

import sqlite3

def save_to_sqlite(data_list, db_name='crawler_data.db', table_name='articles'):
    conn = sqlite3.connect(db_name)
    cursor = conn.cursor()

    # 创建表，如果不存在
    cursor.execute(f'''
        CREATE TABLE IF NOT EXISTS {table_name} (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            title TEXT NOT NULL,
            url TEXT UNIQUE
        )
    ''')

    for item in data_list:
        try:
            cursor.execute(f'''
                INSERT INTO {table_name} (title, url) VALUES (?, ?)
            ''', (item['title'], item['url']))
        except sqlite3.IntegrityError:
            print(f"URL '{item['url']}' 已存在，跳过插入。")

    conn.commit()
    conn.close()
    print(f"数据已保存到 SQLite 数据库 {db_name} 的 {table_name} 表中。")

save_to_sqlite(sample_data)

这里我加了一个UNIQUE约束在url字段上，这样可以避免重复插入相同的URL，这在爬虫中是个非常实用的去重策略。

NoSQL数据库 (MongoDB, Redis)

优点： 灵活的Schema，适合存储非结构化和半结构化数据，可扩展性强，高并发读写性能好。MongoDB是文档型数据库，非常适合存储JSON-like的数据。Redis是内存数据库，读写速度极快，常用于缓存、消息队列或存储临时、高频访问的数据。
缺点： 缺乏SQL的强大查询能力，数据一致性模型可能与关系型数据库不同。
适用场景： 爬取的数据结构多变，需要快速存储和检索，或者数据量巨大。

MongoDB示例：

# 需要安装 pymongo 库
from pymongo import MongoClient

def save_to_mongodb(data_list, db_name='crawler_db', collection_name='articles'):
    client = MongoClient('mongodb://localhost:27017/') # 连接MongoDB服务
    db = client[db_name]
    collection = db[collection_name]

    # 批量插入，避免重复插入可以使用 update_one with upsert=True 或检查是否存在
    for item in data_list:
        # 检查是否已存在，以URL作为唯一标识
        if not collection.find_one({'url': item['url']}):
            collection.insert_one(item)
        else:
            print(f"URL '{item['url']}' 已存在，跳过插入。")

    client.close()
    print(f"数据已保存到 MongoDB 数据库 {db_name} 的 {collection_name} 集合中。")

# save_to_mongodb(sample_data) # 需要本地运行MongoDB服务

在MongoDB中，我同样通过find_one来检查URL是否已存在，避免重复插入。

3. 数据清洗与预处理

无论选择哪种存储方式，爬取到的“原始”数据往往是脏乱差的，比如：