跳到主要内容
极客日志极客日志面向AI+效率的开发者社区
首页博客GitHub 精选镜像AI 生图工具UI配色美学隐私政策关于联系
搜索内容 / 工具 / 仓库 / 镜像...⌘K搜索
注册
博客列表
Python算法

Python 爬虫入门实战：从 Requests 到 Scrapy 分布式部署

Python 爬虫技术体系涵盖静态页面抓取、动态渲染处理及分布式架构设计。本文详解 Requests、BeautifulSoup 基础用法，深入 Scrapy 框架配置与中间件开发，介绍 Selenium 与 Playwright 应对 JS 渲染，以及 aiohttp 异步高并发方案。同时提供数据存储（MySQL/MongoDB）、反爬策略（代理/IP 池/验证码）及去重机制的完整实践指南，适合希望构建高效稳定数据采集系统的开发者参考。

Pythonist发布于 2026/3/24更新于 2026/7/2128 浏览
Python 爬虫入门实战：从 Requests 到 Scrapy 分布式部署

Python 爬虫入门实战：从 Requests 到 Scrapy 分布式部署

前言

在信息爆炸的时代，互联网已成为最丰富的数据来源。无论是电商价格、新闻动态还是招聘信息，通过爬虫都能高效获取。对于初学者而言，只要理解 HTTP、HTML 及基础 Python 编程，就能快速入门。

本教程面向零基础用户，讲解从最基本的抓取到进阶框架、异步、分布式再到反爬策略，逐步深入，手把手指导你搭建完整爬虫，并总结截至 2024 年底最常用的 Python 爬虫库。

核心亮点

  • 循序渐进：从 requests + BeautifulSoup 开始，到 Scrapy、Selenium、Playwright、异步爬虫，一步步掌握。
  • 实战示例：每个工具/框架都配有完整可运行的示例代码。
  • 最新库盘点：整理截至 2024 年常用的爬虫生态主流库。
  • 反爬与实战：从 User-Agent 伪装到代理 IP 池、验证码识别，多角度应对目标网站的各种反爬机制。

温馨提示：本教程示例均基于 Python 3.8+，强烈建议使用 Python 3.10 或更高版本。爬取网站数据时，请务必遵守目标网站的 robots.txt 以及相关法律法规，避免给他人服务器带来不必要的压力。

爬虫基础知识

什么是爬虫？

爬虫（Web Crawler）是一种通过程序自动访问网页，并将其中有用信息提取下来存储的数据采集工具。

原理简述：爬虫首先向指定 URL 发起 HTTP 请求，获取网页源代码（HTML、JSON、图片等），再通过解析技术（如 XPath、CSS 选择器、正则）从源码中提取所需数据，最后将数据保存到文件或数据库中。

应用场景

  1. 数据分析：电商价格监控、商品评论分析、竞品调研。
  2. 舆情监控：社交媒体热搜、论坛帖子、新闻资讯统计。
  3. 搜索引擎：Google、Bing 等搜索引擎通过爬虫定期抓取网页进行索引。
  4. 招聘信息采集：自动抓取招聘网站的岗位、薪资、公司信息。
  5. 学术研究：论文元数据爬取、知识图谱构建等。

基本流程

  1. 确定目标 URL：明确要爬取的网页地址。
  2. 发送 HTTP 请求：使用 requests、httpx、aiohttp 等库发送 GET、POST 请求。
  3. 解析响应内容：常用解析工具有 BeautifulSoup、lxml、parsel、PyQuery、正则表达式等。
  4. 提取数据：根据标签名、属性、XPath、CSS Selector 等定位到目标内容。
  5. 数据处理与存储：清洗、去重，然后保存到 CSV、JSON、SQLite、MySQL、MongoDB 等介质中。
  6. 翻页/递归：分析翻页逻辑，循环执行请求与解析。
  7. 异常处理与反爬对策：设置代理、随机 User-Agent、限速、IP 轮换。

法律与伦理问题

  • 请求前务必查看目标站点的 robots.txt，遵从抓取规则；
  • 遵守版权与隐私政策，不要对目标站点造成过大压力，建议设置合适的延时；
  • 遵守爬虫与爬取数据后续处理相关法律法规，切勿用于违法用途。

开发环境准备

安装 Python

建议安装 Python 3.8 及以上版本。

Windows：前往官网下载对应安装包，默认选中'Add Python 3.x to PATH'。 macOS：建议使用 Homebrew 安装：brew install [email protected] Linux (Ubuntu/Debian)：

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

安装完成后，执行 python3 --version 确认。

创建虚拟环境

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

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

常用开发工具推荐

  • IDE/编辑器：PyCharm、VS Code、Sublime Text。
  • 调试工具：VS Code/PyCharm 自带调试器，命令行脚本可使用 pdb。
  • 版本管理：Git + GitHub/Gitee。
  • 辅助工具：Postman / Insomnia（模拟 HTTP 请求）、Charles / Fiddler（抓包调试）。

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

安装必要库

pip install requests beautifulsoup4 lxml
  • requests：最常用的 HTTP 库。
  • beautifulsoup4：常见的 HTML/XML 解析库。
  • lxml：速度快、功能强大的解析器。

认识 HTTP 请求与响应

  • HTTP 请求：由方法（GET、POST 等）、URL、请求头（Headers）、请求体（Body）组成。
  • HTTP 响应：包含状态码、响应头、响应体。
  • Requests 常用参数：url、params、headers、data/json、timeout、proxies。

示例：

import requests

url = 'https://httpbin.org/get'
params = {'q': 'python 爬虫', 'page': 1}
headers = {'User-Agent': 'Mozilla/5.0 ...'}

response = requests.get(url, params=params, headers=headers, timeout=10)
print(response.status_code)  # 打印状态码
print(response.encoding)     # 编码
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 ...'}
        response = requests.get(url, headers=headers, timeout=10)
        response.raise_for_status()
        
        # 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}')

解析 HTML：BeautifulSoup 用法详解

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

  1. 查找单个节点：soup.find(tag_name, attrs={})
  2. 查找所有节点：soup.find_all(tag_name, attrs={})
  3. CSS 选择器：soup.select('div.content > ul li a')
  4. 获取属性或文本：node.get('href')、node.get_text(strip=True)

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

html = response.text
soup = BeautifulSoup(html, 'lxml')

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

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://...'}]
with open('result.json', 'w', encoding='utf-8') as f:
    json.dump(data, f, ensure_ascii=False, indent=4)

常见反爬措施及应对策略

  • User-Agent 检测：默认 requests 的 User-Agent 容易被识别。应用：在请求头中随机选用常见浏览器 User-Agent。
  • IP 限制：如果同一 IP 短时间内发起大量请求，服务器可能会封禁。应对：使用代理池，定期更换 IP。
  • Cookie 验证：某些网站登录后才能访问。用 requests.Session() 管理会话，同一 Session 自动保存并发送 Cookie。
  • AJAX / 动态渲染：如果页面数据是通过 JavaScript 动态加载，直接用 requests 只能获取静态 HTML。需分析 AJAX 接口或使用浏览器自动化工具。

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

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

lxml (XPath)

  • 特点：基于 C 语言实现，解析速度快，支持标准的 XPath 查询。
  • 常见语法：//tag[@attr="value"]、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>'''

tree = etree.HTML(html)
titles = tree.xpath('//div/h2/a/text()')
links = tree.xpath('//div/h2/a/@href')

for t, l in zip(titles, links):
    print(t, l)

parsel（Scrapy 内置的解析器）

  • 特点：Scrapy 自带的一套基于 Css/XPath 的快速解析工具。

示例：

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)
for item in sel.css('li'): 
    title = item.css('a::text').get()
    link = item.css('a::attr(href)').get()
    print(title, link)

PyQuery（类似 jQuery 的解析方式）

  • 特点：接口风格类似 jQuery，前端同学会很快上手。

示例：

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 解析方案，但在提取简单规则（如邮箱、电话号码）时非常方便。

示例：

import re
from bs4 import BeautifulSoup

html = '<div>联系邮箱：[email protected] 联系电话：123-4567-890</div>'
soup = BeautifulSoup(html, 'lxml')
info = soup.find('div').get_text()

email_pattern = r'[\w\.-]+@[\w\.-]+'
emails = re.findall(email_pattern, info)
print('邮箱：', emails)

框架篇：Scrapy 全面入门

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

Scrapy 简介

  • 适用场景：大规模爬取同类型大量网页、复杂数据清洗、高度定制化中间件。

安装与项目结构

scrapy startproject myproject

项目目录结构：

myproject/
  scrapy.cfg
  myproject/
    __init__.py
    items.py
    middlewares.py
    pipelines.py
    settings.py
    spiders/
      example_spider.py

编写第一个 Scrapy 爬虫 Spider

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

定义 Item (items.py)

import scrapy

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

编写 Spider (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 Shell 在线调试

Shell 模式下，你可以快速试错、验证提取逻辑。

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

并发配置

  • 并发请求数：在 settings.py 中设置 CONCURRENT_REQUESTS（默认 16）。
  • 下载延时：DOWNLOAD_DELAY（默认 0）。
  • 自动限速：AUTOTHROTTLE_ENABLED = True。

中间件与扩展

  • Downloader Middleware：位于引擎与下载器之间，常用于动态设置 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)

动态内容爬取：Selenium 与 Playwright

当目标网页内容依赖 JavaScript 动态渲染时，单纯用 requests 获取到的 HTML 往往不包含最终可视化的数据。此时可以使用'浏览器自动化'工具。

Selenium 基础用法

  1. 下载 WebDriver：下载与本地 Chrome 版本相匹配的 chromedriver。
  2. 显式等待与隐式等待：使用 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
from bs4 import BeautifulSoup

chrome_options = Options()
chrome_options.add_argument('--headless')
chrome_options.add_argument('--no-sandbox')

service = ChromeService(executable_path='path/to/chromedriver')
driver = webdriver.Chrome(service=service, options=chrome_options)

try:
    driver.get('https://quotes.toscrape.com/js/')
    html = driver.page_source
    soup = BeautifulSoup(html, 'lxml')
    for quote in soup.select('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

  • 优点：启动速度快、API 简洁、无需单独下载 WebDriver。

同步版示例：

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

异步爬虫：aiohttp + asyncio 与 HTTPX

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

aiohttp 入门示例

使用 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):
    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)
        
        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 的异步升级版

  • 特点：与 requests API 十分相似，同时支持同步与异步模式。

示例：

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

数据存储与去重

本地文件与数据库

  1. CSV/JSON：适合一次性、容量较小、对数据结构要求不高的场景。
  2. SQLite：轻量级嵌入式数据库，适合中小规模项目。
  3. MySQL/PostgreSQL：适合大规模数据存储，支持 SQL 强大的查询功能。
  4. MongoDB：文档型数据库，对半结构化 JSON 数据支持友好。

Redis 用作去重与短期缓存

  • Redis Set：小规模去重可直接用 Redis set 存储已爬 URL。
  • 布隆过滤器：当 URL 数量达到数百万级别时，普通 Python 集合会占用大量内存，布隆过滤器用空间换时间。

示例：

import redis

r = redis.Redis(host='localhost', port=6379, db=0)
url = 'https://example.com/page/1'

if r.sadd('visited_urls', url):
    print('新 URL，可爬取')
else:
    print('URL 已存在，跳过')

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

当单机爬虫难以满足高并发、大规模抓取时，就需要分布式爬虫。Scrapy-Redis 是 Scrapy 官方推荐的分布式方案之一。

集成 Scrapy-Redis

  1. 安装：pip install scrapy-redis
  2. 配置 Settings：
# 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}
  1. 修改 Spider：继承 scrapy_redis.spiders.RedisSpider。

多机协作示例

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

常见反爬与反制策略

频率限制与请求头伪装

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

登录验证与 Cookie 管理

  • Session 对象：在 requests 中，使用 requests.Session() 方便统一管理 Cookie。
  • 模拟登录流程：获取登录页 Token -> POST 登录接口 -> 保持 Session 状态。

验证码识别

  • 常见类型：图片验证码、滑动验证码、点选验证码。
  • 方案：打码平台/人工打码、绕过/获取接口、OCR 识别（如 pytesseract）。

代理 IP 池的搭建与旋转

  • 为什么要用代理：降低单 IP 请求频率，防止被封禁。
  • 获取代理：免费代理（不稳定）、付费代理（稳定）。可在 Scrapy 中配置 RandomProxyMiddleware。

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

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

需求分析

  1. 目标数据：新闻标题、摘要、文章链接、发布时间。
  2. 存储方式：MySQL 数据库。
  3. 反爬策略：设置随机 User-Agent、下载延时。

实现步骤

编写 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):
        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}
            )

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

    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

Python 爬虫相关的常用第三方库一览

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

基础请求与解析

库名功能简介典型场景
requests同步 HTTP 请求，API 简洁绝大多数简单爬虫
httpx支持同步 & 异步需要异步或更多高级功能
aiohttp原生 asyncio 协程模式高并发抓取
BeautifulSoupHTML/XML 解析初学者快速上手
lxml高性能解析器，支持 XPath需要高性能、大量数据解析
parselScrapy 自带解析器Scrapy 项目中快捷解析

浏览器自动化

库名功能简介典型场景
Selenium最成熟的浏览器自动化框架需模拟用户操作、抓取 JS 渲染内容
Playwright微软出品，API 简洁高性能 headless 模式
undetected-chromedriver对抗反爬，屏蔽 Selenium 特征需要更强的逃避检测能力

异步爬取

库名功能简介典型场景
asyncioPython 标准库，事件循环编写异步爬虫主框架
aiohttp基于 asyncio 的 HTTP 客户端高并发抓取
httpx支持同步 & 异步无缝切换异步模式

登录模拟与验证码处理

库名功能简介典型场景
requests + Session模拟登录，自动管理 Cookie大部分需要登录后抓取的场景
pytesseractOCR 识别图片文字简单验证码识别
captcha_solver第三方打码平台 SDK调用付费打码平台

反爬与代理

库名功能简介典型场景
fake-useragent随机生成 User-Agent防止被识别为爬虫
scrapy-rotating-proxiesScrapy 专用代理轮换中间件大规模抓取避免单 IP 封禁
proxylist2从多个免费代理网站抓取代理 IP自动化维护免费代理列表

分布式调度

库名功能简介典型场景
scrapy-redisScrapy 分布式爬虫扩展分布式 Scrapy 项目
scrapy-cluster基于 Kafka + Redis 的系统企业级分布式环境

附录

常见报错及解决方案

  1. ModuleNotFoundError：未安装该包或安装在全局而非虚拟环境中。解决：确认虚拟环境并执行 pip install xxx。
  2. SSLError：本机 CA 证书有问题。解决：升级 certifi 或临时忽略（不推荐）。
  3. ValueError：XPath 返回多值时解包错误。解决：检查 XPath 语法或使用 zip()。
  4. WebDriverException：chromedriver 路径问题。解决：下载匹配版本并添加到 PATH。
  5. OperationalError：MySQL 连接失败。解决：检查用户名、密码、服务是否运行。

常用 HTTP 状态码速查

状态码含义
200OK，请求成功
301永久重定向
403Forbidden，服务器拒绝访问
404Not Found，资源不存在
429Too Many Requests，请求频率过高
500Internal Server Error，服务器内部错误

学习资源

  • 官方文档：Requests、BeautifulSoup、Scrapy、Selenium、Playwright、aiohttp、httpx。
  • 推荐书籍：《Python 网络数据采集》、《深入 Python 爬虫框架 Scrapy》、《Python3 网络爬虫开发实战》。
  • 社区资源：Stack Overflow、SegmentFault、GitHub Trending。

总结

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

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

最后，爬虫技术更新迅速，建议在入门后，积极关注各大 Python 社区、GitHub Trending 以及官方文档，及时跟进新特性、新库、新思路，不断优化自己的爬虫方案。祝你能在数据抓取的道路上越走越远！

目录

  1. Python 爬虫入门实战：从 Requests 到 Scrapy 分布式部署
  2. 前言
  3. 爬虫基础知识
  4. 什么是爬虫？
  5. 应用场景
  6. 基本流程
  7. 法律与伦理问题
  8. 开发环境准备
  9. 安装 Python
  10. 创建虚拟环境
  11. 进入项目根目录
  12. 创建虚拟环境
  13. 激活虚拟环境
  14. Windows：venv\Scripts\activate
  15. macOS/Linux：source venv/bin/activate
  16. 常用开发工具推荐
  17. 基础篇：用 Requests + BeautifulSoup 做简单爬虫
  18. 安装必要库
  19. 认识 HTTP 请求与响应
  20. 编写第一个爬虫：抓取网页标题
  21. file: simple_spider.py
  22. 解析 HTML：BeautifulSoup 用法详解
  23. 文件存储：将抓到的数据保存为 CSV/JSON
  24. 常见反爬措施及应对策略
  25. 进阶篇：更强大的解析工具
  26. lxml (XPath)
  27. parsel（Scrapy 内置的解析器）
  28. PyQuery（类似 jQuery 的解析方式）
  29. 正则表达式在爬虫中的应用
  30. 框架篇：Scrapy 全面入门
  31. Scrapy 简介
  32. 安装与项目结构
  33. 编写第一个 Scrapy 爬虫 Spider
  34. Scrapy Shell 在线调试
  35. 并发配置
  36. 中间件与扩展
  37. myproject/middlewares.py
  38. 动态内容爬取：Selenium 与 Playwright
  39. Selenium 基础用法
  40. Playwright for Python
  41. 异步爬虫：aiohttp + asyncio 与 HTTPX
  42. aiohttp 入门示例
  43. HTTPX：Requests 的异步升级版
  44. 数据存储与去重
  45. 本地文件与数据库
  46. Redis 用作去重与短期缓存
  47. 分布式爬虫：Scrapy-Redis 与分布式调度
  48. 集成 Scrapy-Redis
  49. settings.py
  50. 多机协作示例
  51. 常见反爬与反制策略
  52. 频率限制与请求头伪装
  53. 登录验证与 Cookie 管理
  54. 验证码识别
  55. 代理 IP 池的搭建与旋转
  56. 完整案例：爬取某新闻网站并存入数据库
  57. 需求分析
  58. 实现步骤
  59. Python 爬虫相关的常用第三方库一览
  60. 基础请求与解析
  61. 浏览器自动化
  62. 异步爬取
  63. 登录模拟与验证码处理
  64. 反爬与代理
  65. 分布式调度
  66. 附录
  67. 常见报错及解决方案
  68. 常用 HTTP 状态码速查
  69. 学习资源
  70. 总结
  • 免费图片AI生成工具免费生成了解详情
  • Magick API 一键接入全球大模型注册送1000万token查看
  • 免费图片视频在线生成30秒，将你的创意变成现实开始设计
  • X/Twitter免费视频下载器免登陆无限额度免费视频解析下载了解详情
  • 100+免费在线小游戏爽一把
极客日志微信公众号二维码

微信扫一扫，关注极客日志

微信公众号「极客日志V2」，在微信中扫描左侧二维码关注。展示文案：极客日志V2 zeeklog

更多推荐文章

查看全部
  • 5 款主流 Python 爬虫框架对比：优缺点分析与选型指南
  • 制造业大语言模型私有化部署解决方案
  • 字符串模拟题精选：思维与实现解析
  • OpenClaw 权限配置完全指南
  • DALL·E 3 体验笔记：从生成到 API 调用的实践
  • UG NX 逆向工程设计流程：STL 导入与网格优化
  • 滑动窗口算法详解：LeetCode 经典例题实战
  • 前缀和算法实战：和为 K 的子数组
  • 基于 SpringBoot 的 SSM 小区失物招领系统设计
  • 二分查找实战：山峰数组的峰顶索引与寻找峰值
  • Whisper-medium.en 模型深度解析与 Python 实现
  • LeetCode 92 区间反转：递归与哨兵节点实战解析
  • Python 学习经典书籍推荐与选型指南
  • 基于 Spring Boot 的智驿 AI 系统毕业设计项目功能与技术栈
  • ERNIE-4.5-0.3B 轻量模型部署与性能实测指南
  • FreeRTOS 退避算法核心逻辑与实现
  • 豆包 AI 视频及图片本地保存方案
  • AMD 显卡本地部署 AI 大模型实战指南
  • 无需扩展插件 Copilot 接入第三方 OpenAI 接口配置
  • Web-Check 结合 cpolar 实现异地远程安全检测

相关免费在线工具

  • 加密/解密文本

    使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online

  • Gemini 图片去水印

    基于开源反向 Alpha 混合算法去除 Gemini/Nano Banana 图片水印，支持批量处理与下载。 在线工具，Gemini 图片去水印在线工具，online

  • curl 转代码

    解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online

  • Base64 字符串编码/解码

    将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online

  • Base64 文件转换器

    将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online

  • Markdown转HTML

    将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online