Selenium动态网页爬虫实战：从环境搭建到反反爬策略

1. 项目概述：为什么动态网页爬虫是新手必须迈过的坎？

如果你刚开始学Python爬虫，大概率是从 requests 和 BeautifulSoup 开始的。它们能轻松搞定静态网页，让你快速尝到数据抓取的甜头。但很快，你就会遇到一个“拦路虎”：页面数据明明在浏览器里清晰可见，用 requests 抓下来的HTML源码里却空空如也，只有一堆看不懂的JavaScript代码。恭喜你，你遇到了动态网页。这就像你拿到了一本魔法书，书页在你眼前会自动浮现文字，但当你试图复印它时，印出来的却是空白页。动态网页的内容，是由浏览器执行JavaScript代码后，实时从服务器获取数据并“画”在页面上的。传统的“请求-解析”模式在这里完全失效。

这就是 Selenium 登场的时刻。它不是一个单纯的HTTP请求库，而是一个 浏览器自动化工具 。它的核心思路是：“既然人可以用浏览器看到数据，那我就写个程序来模拟人操作浏览器的过程。” 通过 Selenium ，你可以用代码启动一个真实的浏览器（如Chrome、Firefox），让它加载网页、执行JavaScript、等待数据渲染完成，然后再去获取最终呈现在页面上的完整HTML。对于爬虫新手来说，掌握 Selenium 意味着你打开了网络数据获取的另一扇大门，从此静态、动态网页通吃，数据获取能力直接上了一个台阶。这个项目，就是带你从零开始，用 Selenium 这把“万能钥匙”，亲手揭开动态网页爬虫的神秘面纱。

2. 环境搭建与核心工具选型解析

工欲善其事，必先利其器。用 Selenium 爬虫，环境配置是第一步，也是最容易让新手卡住的地方。这里我会详细拆解每一步，并解释背后的原因。

2.1 Python与Selenium库安装：基础中的基础

首先确保你安装了Python。建议使用Python 3.7及以上版本，因为社区支持和库的兼容性更好。安装Python时，务必勾选“Add Python to PATH”，这是为了能在命令行中直接使用 python 和 pip 命令。

安装好Python后，打开你的命令行（Windows上是CMD或PowerShell，Mac/Linux上是Terminal），安装 Selenium 库非常简单：

pip install selenium

这条命令会从Python官方的软件仓库（PyPI）下载并安装 selenium 库及其依赖。 pip 是Python的包管理工具，相当于一个“软件商店”。

注意 ：国内网络环境有时访问PyPI速度较慢或会失败。你可以使用国内的镜像源来加速，例如清华源：

pip install selenium -i https://pypi.tuna.tsinghua.edu.cn/simple

2.2 浏览器驱动的选择与配置：Selenium的灵魂伴侣

这是 Selenium 配置的核心难点，也是很多新手放弃的地方。 Selenium 本身只是一个发出指令的“遥控器”，它需要一个具体的“机器人”（浏览器驱动）来接收指令并操作真实的浏览器。

1. 驱动与浏览器的版本匹配 你必须下载与你电脑上已安装的浏览器版本 严格匹配 的驱动程序。以最常用的Chrome浏览器为例：

• 打开Chrome，点击右上角三个点 -> 帮助 -> 关于Google Chrome，查看版本号（例如：128.0.6613.138）。
• 访问Chrome驱动的官方下载站（搜索“ChromeDriver”或访问其GitHub发布页）。
• 下载与你的Chrome主版本号（如128）完全一致的 chromedriver 。

为什么版本必须匹配？ 浏览器和驱动之间通过一种叫“WebDriver协议”的通信协议对话。不同版本的浏览器，其内部接口和协议细节可能有细微差别。版本不匹配就像你用新款手机的充电线去插旧款手机的接口，很可能充不上电甚至损坏设备，导致 Selenium 报错无法启动浏览器。

2. 驱动的放置与PATH环境变量 下载的驱动是一个可执行文件（Windows是 .exe ，Mac/Linux无后缀）。你有两种方式让Python找到它：

• 方法A（推荐给新手） ：将 chromedriver.exe 文件直接放在你的Python脚本所在的同一个文件夹下。这样， Selenium 会在当前目录自动寻找。
• 方法B（一劳永逸） ：将 chromedriver.exe 所在目录的路径添加到系统的 PATH 环境变量中。这样，无论你的脚本在哪个文件夹，系统都能找到它。具体添加方法因操作系统而异，网上教程很多。

3. 其他浏览器驱动

• Firefox ：驱动叫 geckodriver ，同样需要版本匹配。
• Edge ：驱动叫 msedgedriver 。
• 原则上， Selenium 支持任何实现了WebDriver协议的浏览器。

2.3 集成开发环境（IDE）的选择：写代码的战场

对于初学者，我不建议直接用记事本。一个好的IDE能帮你自动补全代码、高亮语法、调试错误，极大提升效率。

• PyCharm（社区版免费） ：功能最强大的Python IDE，对新手友好，项目管理、虚拟环境、调试器一应俱全。配置Python环境通常很直观。
• VS Code（免费） ：轻量级且高度可定制。你需要安装Python扩展插件，然后配置Python解释器路径。它更适合喜欢折腾和追求轻快的开发者。
• Jupyter Notebook ：适合做数据分析和阶段性实验，它以“单元格”为单位运行代码，即时看到结果，但对于构建一个完整的爬虫项目，结构化管理上不如前两者。

我的建议是： 新手从PyCharm社区版开始 ，减少在环境配置上的折腾，把精力集中在学习 Selenium 本身。

3. Selenium核心操作详解：从启动浏览器到获取数据

环境配好，我们开始真正的实战。我会把 Selenium 爬虫拆解成一个个连贯的动作，就像教你怎么操作一台复杂的机器。

3.1 初始化与浏览器启动：第一行代码

让我们写第一个脚本，目标很简单：用 Selenium 打开百度首页。

from selenium import webdriver
from selenium.webdriver.common.by import By
import time

# 1. 创建浏览器驱动对象
# 如果你把chromedriver放在了脚本同目录，这样写即可
driver = webdriver.Chrome()

# 2. 访问目标网址
driver.get("https://www.baidu.com")

# 3. 让程序等待3秒，以便我们看清浏览器打开的效果
time.sleep(3)

# 4. 关闭浏览器窗口
driver.quit()

运行这段代码，你会看到一个Chrome浏览器窗口自动弹出，加载百度首页，然后3秒后关闭。

关键点解析 ：

• webdriver.Chrome() ：这行代码启动了 ChromeDriver 进程，并打开一个新的Chrome浏览器窗口。这个窗口是完全受程序控制的。
• driver.get(url) ：命令浏览器导航到指定的URL。
• time.sleep(3) ：这是一个强制等待。在实际爬虫中，我们应尽量避免使用它，而用更智能的“显式等待”替代，后面会讲。
• driver.quit() ：关闭浏览器并释放 ChromeDriver 进程。务必在脚本最后调用，否则后台会残留进程。

3.2 元素定位：爬虫的“眼睛”

爬虫要获取数据，首先要告诉它数据在哪里。在网页上，数据存在于各种HTML元素（标签）里，比如输入框、按钮、链接、段落文本等。 Selenium 提供了多种“定位器”来找到这些元素。

八大定位方法（By类） ： 这是 Selenium 最核心的技能之一。 By 类提供了多种定位策略。

# 接续上面的driver
# 假设我们已经打开了百度页面

# 1. 通过ID定位 - ID通常是唯一的，最优先使用
search_box = driver.find_element(By.ID, "kw") # 找到百度搜索框

# 2. 通过NAME定位
search_box = driver.find_element(By.NAME, "wd")

# 3. 通过CLASS_NAME定位 - 注意class可能有多个，用空格分隔，这里匹配其中一个
# 例如 <input class="s_ipt s_ipt_wr">
search_box = driver.find_element(By.CLASS_NAME, "s_ipt")

# 4. 通过TAG_NAME定位 - 通过标签名，如`input`, `div`, `a`
input_tags = driver.find_elements(By.TAG_NAME, "input") # 找到所有input标签

# 5. 通过LINK_TEXT定位 - 精确匹配超链接的文本
news_link = driver.find_element(By.LINK_TEXT, "新闻")

# 6. 通过PARTIAL_LINK_TEXT定位 - 部分匹配超链接文本
news_link = driver.find_element(By.PARTIAL_LINK_TEXT, "闻")

# 7. 通过CSS_SELECTOR定位 - 功能强大，语法同CSS选择器
search_box = driver.find_element(By.CSS_SELECTOR, "#kw") # #表示ID
search_box = driver.find_element(By.CSS_SELECTOR, "input.s_ipt") # 标签名+class
search_box = driver.find_element(By.CSS_SELECTOR, "input[name='wd']") # 属性选择器

# 8. 通过XPATH定位 - 最强大也最复杂的定位方式，可以遍历XML/HTML文档树
search_box = driver.find_element(By.XPATH, "//*[@id='kw']") # 找到id为kw的元素
search_box = driver.find_element(By.XPATH, "//input[@class='s_ipt']")

find_element vs find_elements ：

• find_element(By.XX, “value”) ：返回 第一个 匹配到的元素。如果没找到，会抛出 NoSuchElementException 异常。
• find_elements(By.XX, “value”) ：返回一个包含 所有 匹配元素的列表。如果没找到，返回空列表 [] 。

实操心得：如何选择定位方式？

1. 优先级 ：ID > Name > CSS Selector > XPath > 其他。因为ID通常唯一且解析最快。
2. 开发工具是利器 ：在浏览器页面按F12打开开发者工具，使用“检查元素”功能（Ctrl+Shift+C）。你可以右键元素，直接“Copy” -> “Copy selector”（CSS选择器）或“Copy XPath”，作为参考起点。但自动生成的XPath往往很长且脆弱，建议自己编写更简洁稳定的。
3. 相对XPath ：尽量避免使用包含完整路径（如 /html/body/div[3]/div[2]/div/div[1]/input ）的绝对XPath，页面结构微调就会失效。使用基于属性或文本的相对XPath（如 //input[@id='kw'] 或 //a[contains(text(),'登录')] ）更健壮。

3.3 元素交互：模拟人的操作

找到元素后，我们就可以与之交互了。

# 接上，我们已经定位到百度搜索框 search_box
# 1. 输入文本
search_box.send_keys("Python Selenium 教程")

# 2. 清空输入框
search_box.clear()
search_box.send_keys("新的关键词")

# 3. 点击元素
# 先定位到“百度一下”按钮
search_button = driver.find_element(By.ID, "su")
search_button.click()

# 4. 提交表单（如果元素在form表单内，可以替代点击提交按钮）
# search_box.submit()

# 5. 获取元素属性、文本、状态
print(f"搜索框的ID属性：{search_box.get_attribute('id')}")
print(f"搜索框内的值：{search_box.get_attribute('value')}")
print(f"按钮显示的文本：{search_button.text}")
print(f"输入框是否可见：{search_box.is_displayed()}")
print(f"输入框是否可编辑：{search_box.is_enabled()}")
print(f"复选框是否被选中：{some_checkbox.is_selected()}") # 用于单选/复选框

3.4 等待机制：爬虫稳定性的关键

动态网页数据是异步加载的，如果你在元素还没出现时就尝试去定位它，程序会立刻抛出异常。因此，“等待”是 Selenium 爬虫编写中 最重要也最体现功力的部分 。

1. 强制等待 ( time.sleep )

import time
time.sleep(5) # 无条件等待5秒

缺点 ：无论页面是否加载完成，都死等。时间设短了可能元素还没出来，设长了浪费效率。 仅在调试或不得已时使用 。

2. 隐式等待 ( implicitly_wait )

driver.implicitly_wait(10) # 设置一次，全局生效
element = driver.find_element(By.ID, “some_id”)

原理 ：在 driver 的整个生命周期内，每当执行 find_element 等定位操作时，如果找不到元素，不会立即报错，而是轮询查找（默认每0.5秒一次），直到超过设定的时间（10秒）才抛出异常。 优点 ：设置简单，一劳永逸。 缺点 ：不够灵活，只对 find_element 系列方法有效。对于需要等待某个 特定条件 （如元素可点击、文本出现）的情况无能为力。

3. 显式等待 ( WebDriverWait + expected_conditions ) —— 强烈推荐 这是生产级爬虫应该使用的方式。它允许你为某个特定的操作设置等待条件，条件满足则立即执行后续代码，超时则报错。

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

# 设置显式等待，最长等10秒，轮询间隔0.5秒（默认）
wait = WebDriverWait(driver, 10)

# 等待直到ID为‘kw’的元素出现在DOM中并可见
search_box = wait.until(EC.visibility_of_element_located((By.ID, "kw")))
search_box.send_keys("hello")

# 等待直到ID为‘su’的元素可以被点击
search_button = wait.until(EC.element_to_be_clickable((By.ID, "su")))
search_button.click()

# 等待直到页面标题包含“百度一下”
wait.until(EC.title_contains("百度一下"))

常用预期条件（EC） ：

• presence_of_element_located ：元素出现在DOM中（不一定可见）。
• visibility_of_element_located ：元素可见（宽高大于0）。
• element_to_be_clickable ：元素可见且可点击。
• text_to_be_present_in_element ：元素中包含特定文本。
• alert_is_present ：等待警告框出现。

我的经验 ： 90%的等待场景都应该使用显式等待 。它精准、高效，代码意图清晰。将隐式等待作为全局兜底（比如设个3-5秒），具体的关键操作再辅以显式等待，是常见的稳健策略。

3.5 数据提取：获取渲染后的内容

当页面通过等待机制完全渲染好后，我们就可以提取数据了。

# 1. 获取页面完整HTML源码（渲染后的）
page_source = driver.page_source
# 此时，你可以用BeautifulSoup或lxml再次解析page_source，强强联合。
# from bs4 import BeautifulSoup
# soup = BeautifulSoup(page_source, 'html.parser')

# 2. 获取当前页面URL
current_url = driver.current_url

# 3. 获取当前页面标题
title = driver.title

# 4. 获取元素的文本内容（最常用）
element = driver.find_element(By.CSS_SELECTOR, “h1.class_name”)
print(element.text) # 获取该h1标签内的所有文本（包括子标签的文本）

# 5. 获取元素的属性
link = driver.find_element(By.LINK_TEXT, “新闻”)
href = link.get_attribute(“href”) # 获取超链接地址
src = img.get_attribute(“src”) # 获取图片地址
data_value = div.get_attribute(“data-custom”) # 获取自定义属性

# 6. 获取元素的CSS样式值
color = element.value_of_css_property(“color”)
font_size = element.value_of_css_property(“font-size”)

4. 实战：构建一个健壮的动态内容爬虫案例

理论讲完，我们用一个综合案例来串联所有知识点。假设我们要爬取一个模拟的电商网站商品列表，这个列表是滚动到页面底部时通过JavaScript动态加载的。

4.1 案例目标与页面分析

目标网站是一个演示用的动态加载商品列表页。我们观察到：

1. 首次加载只显示10个商品。
2. 当滚动条接近底部时，页面会触发一个AJAX请求，加载下一页的10个商品，并直接追加到当前列表后面（URL不变）。
3. 商品信息包含：商品名称、价格、图片链接。

手动分析步骤（这是爬虫前的必备工作） ：

1. 用Chrome打开目标页面，按F12打开开发者工具。
2. 切换到“Network”（网络）选项卡，勾选“Preserve log”（保留日志）。
3. 滚动页面，触发新的商品加载。
4. 观察网络请求列表，找到加载新商品数据的那个XHR/Fetch请求。查看它的请求URL、参数（如 page=2 ）、响应格式（通常是JSON）。
5. 如果能直接找到这个数据接口，或许可以直接用 requests 库模拟请求，效率更高。但本例我们假设这个接口复杂或有加密，决定用 Selenium 模拟滚动。

4.2 代码实现：模拟滚动与数据抓取

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.action_chains import ActionChains
import time
import json

# 初始化浏览器，设置隐式等待
driver = webdriver.Chrome()
driver.implicitly_wait(5) # 全局隐式等待5秒
driver.get("https://demo-scroll-loading-website.com/products")

# 创建显式等待对象
wait = WebDriverWait(driver, 10)

all_products = []
max_scroll_attempts = 5 # 最多尝试加载5次（即最多抓50个商品）
scroll_attempt = 0

last_height = driver.execute_script("return document.body.scrollHeight")

while scroll_attempt < max_scroll_attempts:
    # 1. 滚动到页面底部
    driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
    
    # 2. 等待新内容加载（通过等待新出现的商品元素）
    try:
        # 假设每个商品都有类名‘product-item’，我们等待第 (scroll_attempt+1)*10 + 1 个商品出现
        target_count = (scroll_attempt + 1) * 10 + 1
        wait.until(lambda d: len(d.find_elements(By.CLASS_NAME, "product-item")) >= target_count)
        print(f"第{scroll_attempt+1}次滚动加载完成，当前商品数：{target_count-1}")
    except Exception as e:
        print(f"第{scroll_attempt+1}次滚动后未检测到新商品，可能已加载完毕或超时。")
        break # 如果等待超时，跳出循环
    
    # 3. 获取当前所有商品信息
    product_items = driver.find_elements(By.CLASS_NAME, "product-item")
    for item in product_items[len(all_products):]: # 只处理新加载的商品
        try:
            name = item.find_element(By.CLASS_NAME, "product-name").text
            price = item.find_element(By.CLASS_NAME, "product-price").text
            # 图片链接可能存在于img标签的src属性，或者div的背景图样式里
            img_element = item.find_element(By.TAG_NAME, "img")
            img_url = img_element.get_attribute("src") or img_element.get_attribute("data-src")
            
            product_info = {
                "name": name,
                "price": price,
                "image_url": img_url
            }
            all_products.append(product_info)
        except Exception as e:
            print(f"提取单个商品信息时出错：{e}")
            continue # 跳过这个出错的商品，继续下一个
    
    # 4. 计算新的滚动高度，判断是否已到底部
    new_height = driver.execute_script("return document.body.scrollHeight")
    if new_height == last_height:
        print("滚动高度未变化，可能已到达页面底部。")
        break
    last_height = new_height
    
    scroll_attempt += 1
    time.sleep(1) # 滚动后短暂停顿，模拟人类行为，避免请求过快

# 打印抓取结果
print(f"总共抓取到 {len(all_products)} 个商品。")
# 将结果保存为JSON文件
with open('products.json', 'w', encoding='utf-8') as f:
    json.dump(all_products, f, ensure_ascii=False, indent=2)

driver.quit()

代码关键点解析 ：

1. driver.execute_script() ：这是 Selenium 执行JavaScript代码的方法。 window.scrollTo 是JS中控制滚动的函数。
2. lambda 函数在等待条件中的应用： wait.until(lambda d: ...) 允许我们自定义复杂的等待条件。这里我们检查商品元素的数量是否达到了预期。
3. 循环控制：通过 max_scroll_attempts 和滚动高度对比，防止无限滚动。
4. 增量抓取： for item in product_items[len(all_products):] 这个切片操作非常巧妙，它只遍历新加载的商品，避免重复处理。
5. 异常处理：在提取单个商品信息时使用 try...except ，确保一个商品解析失败不会导致整个程序崩溃。

4.3 数据存储与结构化

上面的例子中，我们将数据保存为JSON格式，这是一种轻量且通用的数据交换格式。根据项目需求，你还可以选择：

• CSV文件 ：适合表格型数据，可以用Excel直接打开。

  import csv
  with open('products.csv', 'w', newline='', encoding='utf-8-sig') as f:
      writer = csv.DictWriter(f, fieldnames=['name', 'price', 'image_url'])
      writer.writeheader()
      writer.writerows(all_products)
  

• 数据库（如SQLite、MySQL） ：适合数据量大、需要复杂查询和持久化存储的场景。
• 直接打印或用于后续分析 ：如果数据量小，或作为更大流程的一部分。

5. 高级技巧与反反爬策略应对

当你用 Selenium 大规模爬取数据时，很快会被网站识别并屏蔽。因为 Selenium 驱动的浏览器带有一些自动化特征（如 webdriver 属性）。这就需要一些高级技巧来让你的爬虫更像“人”。

5.1 隐藏自动化特征

这是对抗基础反爬虫检测的核心。

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

chrome_options = Options()

# 1. 添加实验性选项，规避检测（核心）
chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
chrome_options.add_experimental_option('useAutomationExtension', False)

# 2. 修改 navigator.webdriver 属性（在启动后通过CDP执行）
driver = webdriver.Chrome(options=chrome_options)
driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
    'source': '''
        Object.defineProperty(navigator, 'webdriver', {
            get: () => undefined
        });
        // 也可以修改其他属性，如plugins, languages等
        Object.defineProperty(navigator, 'plugins', {
            get: () => [1, 2, 3, 4, 5]
        });
    '''
})

# 3. 使用无头模式（不显示浏览器界面，节省资源）
# chrome_options.add_argument('--headless') # 注释掉则在后台运行
# 注意：无头模式更容易被一些网站识别，可配合其他参数使用

# 4. 禁用Blink和Chrome控制特性
chrome_options.add_argument('--disable-blink-features=AutomationControlled')

# 5. 设置常规的用户代理（User-Agent）
chrome_options.add_argument('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')

5.2 模拟人类行为模式

反爬系统会分析你的操作模式。瞬间完成的操作、完美的定时、固定的鼠标轨迹都是机器特征。

• 随机等待时间 ：用 random.uniform(a, b) 代替固定的 time.sleep 。

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

• 随机滚动 ：不要总是滚动到底部。

  import random
  scroll_height = random.randint(300, 800)
  driver.execute_script(f"window.scrollBy(0, {scroll_height});")
  

• 模拟鼠标移动 ：使用 ActionChains 。

  from selenium.webdriver.common.action_chains import ActionChains
  element = driver.find_element(By.ID, “some_id”)
  actions = ActionChains(driver)
  # 将鼠标移动到元素上，模拟悬停
  actions.move_to_element(element).perform()
  time.sleep(random.uniform(0.5, 1.5))
  actions.click().perform()
  

5.3 使用代理IP

如果同一个IP地址在短时间内发出过多请求，很容易被封锁。使用代理IP池是解决IP限制的常用方法。

chrome_options = Options()
proxy = “123.45.67.89:8080” # 替换为你的有效代理IP和端口
chrome_options.add_argument(f'--proxy-server=http://{proxy}')
# 或者对于需要认证的代理
# chrome_options.add_argument(f'--proxy-server=http://user:password@{proxy}')
driver = webdriver.Chrome(options=chrome_options)

注意 ：免费代理大多不稳定、速度慢。商业爬虫项目需要考虑使用付费代理服务，并实现代理IP的自动切换和失效检测。

5.4 应对验证码

遇到验证码是爬虫的终极挑战之一。

1. 规避 ：通过控制请求频率、使用高质量代理、维护会话（Cookie）来尽量避免触发验证码。
2. 人工处理 ：对于小规模或低频爬取，当验证码出现时，程序暂停，弹出提示让用户手动输入。

   input(“请在浏览器中手动完成验证码，然后按回车继续...”)
   

3. 第三方打码平台 ：将验证码图片发送到如超级鹰、图鉴等平台，通过其API获取识别结果，再自动填入。这需要额外成本。
4. 机器学习（高级） ：训练模型识别特定类型的简单验证码（如数字扭曲），但对复杂的滑块、点选验证码效果有限。

6. 常见问题排查与性能优化实录

在实际操作中，你一定会遇到各种报错和性能瓶颈。这里记录了我踩过的坑和解决方案。

6.1 高频错误与解决方案速查表

6.2 性能优化实战心得

Selenium 最大的缺点是慢，因为它要启动完整的浏览器。以下优化手段能显著提升效率：

1. 无头模式与禁用无用功能

chrome_options = Options()
chrome_options.add_argument('--headless') # 无头模式，不显示GUI
chrome_options.add_argument('--disable-gpu') # 禁用GPU加速，某些系统需要
chrome_options.add_argument('--no-sandbox') # 禁用沙盒，解决Linux下的一些权限问题
chrome_options.add_argument('--disable-dev-shm-usage') # 解决共享内存问题
chrome_options.add_argument('--window-size=1920,1080') # 设置窗口大小，无头模式下也需要

# 禁用图片、CSS、JavaScript（谨慎使用，可能破坏页面功能）
prefs = {
    “profile.managed_default_content_settings.images”: 2, # 2为禁用
    # “profile.managed_default_content_settings.stylesheets”: 2,
    # “profile.managed_default_content_settings.javascript”: 2,
}
chrome_options.add_experimental_option(“prefs”, prefs)

driver = webdriver.Chrome(options=chrome_options)

注意 ：禁用JavaScript会使动态网页无法渲染，除非你确定页面不需要JS。通常只禁用图片来加速。

2. 复用浏览器会话 每次 driver = webdriver.Chrome() 都会启动一个新浏览器进程，开销巨大。对于需要连续爬取多个页面的任务，应尽量复用同一个 driver 对象，而不是频繁开关。

3. 使用 page_source 与解析库结合 对于需要提取大量结构化数据的页面，用 Selenium 定位每个元素（ find_element ）很慢。一个优化策略是：用 Selenium 负责渲染和等待，获取完整的 driver.page_source ，然后交给 BeautifulSoup 或 lxml 进行解析和批量提取。后者是纯Python操作，速度比 Selenium 的WebDriver调用快几个数量级。

from bs4 import BeautifulSoup
# ... 使用Selenium等待页面加载完成 ...
html = driver.page_source
soup = BeautifulSoup(html, 'html.parser')
# 使用soup.find_all一次性提取所有商品信息，速度极快
product_list = soup.find_all('div', class_='product-item')
for product in product_list:
    name = product.find('h3').text
    # ... 其他提取操作

4. 并行化与分布式 当任务量极大时，单机单线程的 Selenium 无法满足需求。可以考虑：

• 多线程/多进程 ：在一台机器上启动多个浏览器实例并行爬取。注意控制资源（内存、CPU）和IP被封的风险。
• 分布式爬虫 ：使用 Scrapy 框架结合 Selenium 中间件，或者使用 Celery 等任务队列，将爬取任务分发到多台机器上。这是企业级解决方案的范畴。

6.3 调试技巧：让问题无处遁形

1. 截图 ：当脚本出错或页面状态异常时，立即截图保存现场。

   driver.save_screenshot('error_screenshot.png')
   

2. 打印当前URL和页面标题 ：帮助判断是否跳转到了预期外的页面。

   print(f"Current URL: {driver.current_url}")
   print(f"Page Title: {driver.title}")
   

3. 临时关闭无头模式 ：在调试时，务必使用有界面的浏览器模式，直观地观察每一步操作是否按预期执行。
4. 使用 try...except 包裹关键操作 ：记录错误日志，而不是让程序直接崩溃。

   try:
       element = wait.until(EC.presence_of_element_located((By.ID, “target”)))
       element.click()
   except TimeoutException:
       print(“等待目标元素超时，正在截图...”)
       driver.save_screenshot('timeout.png')
       # 可以尝试备用方案或优雅退出
   

掌握 Selenium 爬虫，是一个从“只会抓静态页面”到“能应对大多数网页”的质变过程。它让你拥有了模拟真人浏览器的能力，代价是速度和资源消耗。在实际项目中，我的策略通常是： 优先分析网站，如果能找到直接的数据接口（XHR/Fetch），就用高效的 requests 库；如果接口复杂、加密或数据确实由前端JS渲染，再祭出 Selenium 这把“重型武器” 。两者结合，才是爬虫工程师的完整技能树。