别再被网站反爬虫拦截了！这个开源工具让Selenium伪装能力提升10倍
在数据采集和自动化测试的世界里，有一个让无数开发者头疼的难题：明明只是想正常访问网页，为什么总是被网站识别为机器人？当你满怀期待地写好Selenium脚本，满以为能够顺利抓取数据时，浏览器却无情地弹出了”检测到自动化软件”的提示。这种挫败感，几乎每个爬虫开发者都曾经历过。
今天要介绍的这个开源项目，正是为了解决这个痛点而生。它就是ultrafunkamsterdam/undetected-chromedriver，一个能够让ChromeDriver完美伪装的开源利器。在GitHub上，这个项目已经获得了超过8000颗星，收获了众多开发者的认可和实际应用验证。如果你也曾被反爬虫机制困扰，或者正在寻找一个可靠的浏览器自动化解决方案，这篇文章将为你提供完整的从入门到精通指南。
为什么传统Selenium总是被识别？
在深入了解undetected-chromedriver之前，我们需要先理解一个核心问题：为什么普通的Selenium总会被网站识别？网站的反爬虫机制主要通过检测以下几个维度来判断访问者是否为真实用户：
浏览器指纹是其中最关键的识别手段。每个浏览器都有其独特的指纹特征，包括但不限于User-Agent字符串、浏览器窗口大小、WebGL渲染信息、Canvas指纹、音频上下文指纹等。普通Selenium启动的浏览器会暴露出大量自动化特征，比如navigator.webdriver属性被设置为true，浏览器会暴露出各种自动化控制接口，甚至Chromedriver的一些特殊属性也会被检测到。
行为分析是另一个重要的识别维度。真实用户的操作具有随机性和不规则性，而自动化脚本的行为往往是高度规律的。网站可以通过分析鼠标移动轨迹、点击频率、页面停留时间等指标来判断是否为机器人。比如，人类用户不会以固定的时间间隔精准地点击同一个位置，也不会在页面加载完成后的精确时间点执行下一步操作。
网络层面的检测同样不可忽视。网站可以检测TCP连接特征、HTTP头部的细微差异、甚至通过JavaScript执行结果来判断是否为自动化浏览器。一些高级的反爬虫系统还会使用机器学习模型来分析访问者的行为模式。
正是因为这些多层次的检测机制，传统的Selenium隐身模式（headless）已经很难逃脱反爬虫系统的追踪。而undetected-chromedriver正是针对这些检测点进行了全面的绕过处理，让自动化浏览器看起来与真实用户无异。
项目核心价值与设计理念
undetected-chromedriver的设计理念可以概括为”让自动化浏览器成为真正的隐形人”。这个项目不仅仅是一个简单的封装库，它深入到ChromeDriver的底层，通过多种技术手段从根本上消除了自动化浏览器的可识别特征。
从技术实现角度来看，这个项目采用了多层次的伪装策略。首先，它会自动修补ChromeDriver本身可能暴露的自动化属性，将navigator.webdriver等关键属性重置为undefined或false。其次，它会修改浏览器的一些核心配置，移除或伪装那些能够暴露自动化身份的API调用结果。此外，项目还提供了参数化配置选项，让用户可以根据不同的目标网站调整伪装策略。
与市场上其他同类方案相比，undetected-chromedriver具有明显的优势。它是一个完全开源免费的项目，代码透明可审计，这对于企业级应用来说非常重要。它不需要依赖额外的浏览器补丁或特殊编译版本，使用标准的Chrome浏览器即可工作。项目的维护更新非常活跃，能够及时跟进Chrome和ChromeDriver的版本更新，保持对最新反爬虫技术的绕过能力。
在实际应用场景中，这个项目已经帮助无数开发者解决了棘手的爬虫问题。无论是电商平台的价格监控、社交媒体的数据采集、还是搜索引擎结果的批量获取，undetected-chromedriver都展现出了强大的适应能力。当然，我们必须强调，任何技术工具都应当被合法合规地使用，遵守网站的robots.txt协议和相关法律法规。
环境搭建与依赖安装
在开始使用undetected-chromedriver之前，我们需要先搭建好合适的开发环境。这个过程并不复杂，但有几个关键点需要特别注意。
首先是Python环境的准备。建议使用Python 3.7或更高版本，因为项目依赖的一些特性需要较新版本的Python支持。你可以通过以下命令检查当前Python版本：
python3 –version
如果版本低于3.7，建议先升级Python。对于macOS用户，可以使用Homebrew进行升级；对于Windows用户，可以从Python官方网站下载最新安装包；对于Linux用户，可以使用apt、yum或其他包管理器进行升级。
接下来是Chrome浏览器的安装。确保你的系统上已经安装了Chrome浏览器，并且版本要与将要使用的ChromeDriver版本相匹配。可以通过在浏览器地址栏输入chrome://settings/help来查看当前Chrome版本号。值得注意的是，Chrome浏览器会频繁更新，每次更新后可能需要相应版本的ChromeDriver。
然后就是安装undetected-chromedriver本身了。项目发布在PyPI上，可以通过pip直接安装：
pip install undetected-chromedriver
这个命令会自动安装项目本身及其所有依赖。不过需要注意的是，安装过程可能会因为网络问题而失败，因为项目需要从GitHub下载ChromeDriver的可执行文件。如果遇到下载问题，可以考虑使用国内镜像源或者手动下载ChromeDriver后放到指定位置。
安装完成后，建议运行一个简单的验证测试，确保一切正常工作：
import undetected_chromedriver as uc
# 尝试启动一个测试浏览器
driver = uc.Chrome()
print("浏览器启动成功！")
driver.quit()
如果上述代码能够正常运行并打印出成功消息，说明环境搭建已经完成。在实际开发中，我们通常还需要安装一些辅助库，比如用于解析网页内容的BeautifulSoup、用于发送HTTP请求的requests库、以及用于处理各种数据格式的pandas等。
pip install beautifulsoup4 requests pandas lxml
需要特别提醒的是，undetected-chromedriver的工作原理涉及到对ChromeDriver的二进制文件进行修补，因此它会创建或修改一些临时文件。确保运行脚本的用户具有相应的读写权限。另外，在某些企业网络环境下，可能需要配置代理才能正常下载ChromeDriver。
核心功能详解
深入理解undetected-chromedriver的核心功能，是掌握这个工具的关键所在。这个项目提供了丰富的配置选项和功能特性，我们可以从多个维度来剖析它的实现原理。
最核心的功能当属浏览器检测规避（Anti-Detection）。传统的Selenium启动的浏览器会暴露多个可检测特征，而undetected-chromedriver会自动处理这些特征。navigator.webdriver这个属性在普通Selenium中会被设置为true，这是许多网站检测自动化的第一线索，而uc会自动将其设置为undefined或直接删除这个属性。window.navigator.plugins和navigator.mimeTypes等属性也会被修改，使其看起来像真实的浏览器。ChromeDriver会在浏览器中添加一些自动化相关的命令参数，uc会自动移除这些参数。
浏览器参数注入是另一个重要功能。在启动浏览器时，uc可以接受大量自定义参数，这些参数会被传递给Chrome浏览器的启动配置。常见的用法包括设置用户数据目录（user-data-dir）、禁用图片加载（blink-settings=imagesEnabled=false）以提升速度、指定代理服务器（proxy-server）等。通过合理配置这些参数，我们可以根据不同的使用场景定制浏览器的行为。
版本自动匹配是uc非常实用的特性。Chrome浏览器更新频繁，而ChromeDriver也需要与Chrome版本匹配才能正常工作。手动下载对应版本的ChromeDriver是一件繁琐的事情，而uc可以自动检测当前系统Chrome的版本，并下载或使用对应版本的ChromeDriver。这大大降低了使用的门槛，也避免了因版本不匹配导致的各种问题。
_headless参数控制是另一个常用功能。uc既支持无头模式（headless）运行，也支持有界面模式运行。在调试阶段，使用有界面模式可以更直观地观察浏览器的行为；而在生产环境或大规模运行时，使用无头模式可以节省系统资源。uc的默认行为在_headless参数控制上提供了灵活的选项。
多实例管理功能允许同时运行多个相互独立的浏览器实例。每个实例都有自己独立的用户数据目录、Cookie存储和会话状态，互不干扰。这对于需要同时登录多个账号、或者需要在隔离环境中执行不同任务的场景非常有用。
下面是一个展示核心配置选项的代码示例：
```python
import undetected_chromedriver as uc
**创建一个配置对象**
options = uc.ChromeOptions()
**基础配置**
options.add_argument('--disable-blink-features=AutomationControlled')
options.add_argument('--no-sandbox')
options.add_argument('--disable-dev-shm-usage')
**性能优化配置**
options.add_argument('--disable-gpu')
options.add_argument('--disable-extensions')
options.add_argument('--disable-images') # 禁用图片加载以提升速度
**隐私配置**
options.add_argument('--disable-infobars')
options.add_argument('--disable-notifications')
**创建带有自定义选项的浏览器实例**
driver = uc.Chrome(options=options, version_main=None)
**设置页面加载策略为普通（等待所有资源加载完成）**
driver.page_load_strategy = 'normal'
在这个示例中，我们展示了如何通过ChromeOptions配置各种参数。–disable-blink-features=AutomationControlled是一个非常重要的参数，它可以帮助绕过某些基于Blink引擎特性的检测。version_main=None表示自动检测Chrome版本并使用对应的ChromeDriver。
进阶配置与高级用法
掌握了基础用法之后，让我们进一步探索undetected-chromedriver的高级特性。这些功能在复杂的实际应用场景中非常有用。
代理服务器配置是很多场景下的必备功能。当需要隐藏真实IP地址、或者需要从特定地区访问网站时，代理是必不可少的解决方案。uc支持多种代理配置方式，包括HTTP代理、HTTPS代理和SOCKS代理。
import undetected_chromedriver as uc
**使用带认证信息的代理服务器**
proxy = "http://username:password@proxy.example.com:8080"
options = uc.ChromeOptions()
options.add_argument(f'--proxy-server={proxy}')
driver = uc.Chrome(options=options, version_main=None)
**访问IP检测网站验证代理是否生效**
driver.get("https://www.whatismyip.com/")
如果代理服务器不需要认证，配置会更加简单，只需要提供代理地址和端口即可。在实际使用中，建议使用高质量的住宅代理（Residential Proxy），因为数据中心代理（Data Center Proxy）更容易被识别。
用户数据管理功能允许持久化保存浏览器的用户配置、Cookie、缓存等信息。这对于需要维持登录状态的场景非常有用。
import undetected_chromedriver as uc
import os
**设置一个持久化的用户数据目录**
user_data_dir = os.path.join(os.getcwd(), "chrome_profile")
**如果目录已存在，可以复用之前的会话**
options = uc.ChromeOptions()
options.add_argument(f'--user-data-dir={user_data_dir}')
driver = uc.Chrome(options=options, version_main=None)
**第一次运行时登录网站，之后的运行会自动保持登录状态**
driver.get("https://example.com/login")
需要注意的是，使用用户数据目录时，必须确保没有其他Chrome进程正在使用该目录，否则会导致冲突。建议在启动浏览器前检查并关闭可能占用该目录的其他进程。
页面等待策略的优化对于爬虫的稳定性和效率都有重要影响。Selenium默认的等待策略可能会导致不必要的等待时间，或者在元素尚未加载完成时就尝试操作。
import undetected_chromedriver as uc
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
import time
driver = uc.Chrome(version_main=None)
**设置隐式等待（全局生效）**
driver.implicitly_wait(10)
**访问目标网站**
driver.get("https://example.com")
**使用显式等待等待特定元素出现**
try:
element = WebDriverWait(driver, 20).until(
EC.presence_of_element_located((By.CLASS_NAME, "target-class"))
)
print("元素已找到")
except Exception as e:
print(f"等待超时: {e}")
**模拟人类行为的随机等待**
time.sleep(random.uniform(1, 3))
在实际应用中，推荐结合使用隐式等待和显式等待。隐式等待设置一个全局的最大等待时间，而显式等待则针对特定元素进行精确等待。这样可以兼顾效率和稳定性。
分页处理和导航操作是很多爬虫项目的常见需求。uc完全支持Selenium的全部导航API，可以方便地进行前进、后退、刷新等操作。
import undetected_chromedriver as uc
driver = uc.Chrome(version_main=None)
**访问首页**
driver.get("https://example.com")
**点击链接进入分页**
driver.find_element("link text", "第2页").click()
**后退到上一页**
driver.back()
**前进到下一页**
driver.forward()
**刷新当前页面**
driver.refresh()
**获取当前页面的所有链接**
links = driver.find_elements("tag name", "a")
for link in links:
print(link.get_attribute("href"))
分步实战教程：构建一个完整的爬虫项目
现在让我们通过一个完整的实战项目，来演示如何使用undetected-chromedriver构建一个功能完善的爬虫。整个项目将涵盖从环境准备到数据存储的完整流程。
假设我们的目标是爬取某个新闻网站的文章列表和内容。这是一个典型的爬虫场景，会涉及到登录（可选）、页面遍历、内容提取、数据清洗和存储等多个环节。
首先，让我们创建一个项目结构：
import undetected_chromedriver as uc
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.common.exceptions import TimeoutException, NoSuchElementException
import time
import random
import json
import csv
from datetime import datetime
import logging
**配置日志记录**
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s',
filename='crawler.log'
)
logger = logging.getLogger(__name__)
class NewsCrawler:
"""
新闻爬虫类
演示如何使用undetected-chromedriver构建一个完整的爬虫项目
"""
def __init__(self, headless=False, use_proxy=False):
"""
初始化爬虫实例
Args:
headless: 是否使用无头模式
use_proxy: 是否使用代理
"""
self.headless = headless
self.use_proxy = use_proxy
self.driver = None
self.article_data = []
def setup_driver(self):
"""
配置并启动浏览器
"""
options = uc.ChromeOptions()
**基础反检测配置**
options.add_argument('--disable-blink-features=AutomationControlled')
options.add_argument('--no-sandbox')
options.add_argument('--disable-dev-shm-usage')
options.add_argument('--disable-gpu')
**用户代理伪装**
user_agents = [
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0'
]
options.add_argument(f'user-agent={random.choice(user_agents)}')
**禁用自动化相关提示栏**
options.add_experimental_option('excludeSwitches', ['enable-automation'])
options.add_experimental_option('useAutomationExtension', False)
**如果启用代理**
if self.use_proxy:
proxy_server = "http://your-proxy-server:port"
options.add_argument(f'--proxy-server={proxy_server}')
**设置无头模式**
if self.headless:
options.add_argument('--headless')
**创建浏览器实例**
self.driver = uc.Chrome(options=options, version_main=None)
**执行反检测脚本**
self._execute_anti_detection()
logger.info("浏览器配置完成")
def _execute_anti_detection(self):
"""
执行额外的反检测JavaScript代码
"""
**移除webdriver属性**
self.driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": """
Object.defineProperty(navigator, 'webdriver', {
get: () => undefined
});
"""
})
**修改navigator.plugins**
self.driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": """
Object.defineProperty(navigator, 'plugins', {
get: () => [1, 2, 3, 4, 5]
});
"""
})
**修改Chrome权限**
self.driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": """
const originalQuery = window.navigator.permissions.query;
window.navigator.permissions.query = (parameters) => (
parameters.name === 'notifications' ?
Promise.resolve({ state: Notification.permission }) :
originalQuery(parameters)
);
"""
})
logger.info("反检测脚本执行完成")
def random_sleep(self, min_seconds=1, max_seconds=3):
"""
模拟人类行为的随机等待
"""
sleep_time = random.uniform(min_seconds, max_seconds)
logger.debug(f"等待 {sleep_time:.2f} 秒")
time.sleep(sleep_time)
def scroll_page(self):
"""
模拟人类滚动页面的行为
"""
total_height = self.driver.execute_script("return document.body.scrollHeight")
viewport_height = self.driver.execute_script("return window.innerHeight")
current_position = 0
while current_position < total_height:
**随机滚动距离**
scroll_amount = random.randint(200, 600)
current_position += scroll_amount
self.driver.execute_script(f"window.scrollTo(0, {current_position});")
self.random_sleep(0.3, 0.8)
def crawl_page(self, url, max_retries=3):
"""
爬取单个页面的文章列表
Args:
url: 目标页面URL
max_retries: 最大重试次数
"""
for attempt in range(max_retries):
try:
logger.info(f"正在访问: {url} (尝试 {attempt + 1}/{max_retries})")
self.driver.get(url)
**等待页面加载**
self.random_sleep(2, 4)
**模拟滚动加载更多内容**
self.scroll_page()
**提取文章信息**
articles = self._extract_articles()
logger.info(f"成功提取 {len(articles)} 篇文章")
return articles
except TimeoutException:
logger.warning(f"页面加载超时，正在重试...")
self.random_sleep(5, 10)
except Exception as e:
logger.error(f"发生错误: {str(e)}")
if attempt < max_retries - 1:
self.random_sleep(10, 20)
return []
def _extract_articles(self):
"""
从当前页面提取文章信息
这个方法需要根据具体网站结构进行调整
"""
articles = []
try:
**假设文章列表在特定的CSS选择器中**
article_elements = self.driver.find_elements(
By.CSS_SELECTOR,
"article.post-item, .article-card, .news-item"
)
for element in article_elements:
try:
article = {}
**提取标题**
title_element = element.find_element(By.CSS_SELECTOR, "h2.title, h3.headline")
article['title'] = title_element.text.strip()
article['url'] = title_element.get_attribute('href')
**提取摘要**
try:
summary_element = element.find_element(By.CSS_SELECTOR, ".excerpt, .summary")
article['summary'] = summary_element.text.strip()
except NoSuchElementException:
article['summary'] = ""
**提取发布时间**
try:
time_element = element.find_element(By.CSS_SELECTOR, ".date, time")
article['publish_date'] = time_element.get_attribute('datetime') or time_element.text
except NoSuchElementException:
article['publish_date'] = ""
**提取作者**
try:
author_element = element.find_element(By.CSS_SELECTOR, ".author")
article['author'] = author_element.text.strip()
except NoSuchElementException:
article['author'] = ""
articles.append(article)
except Exception as e:
logger.warning(f"提取单篇文章信息失败: {str(e)}")
continue
except Exception as e:
logger.error(f"提取文章列表失败: {str(e)}")
return articles
def crawl_article_content(self, url):
"""
爬取单篇文章的详细内容
Args:
url: 文章URL
"""
for attempt in range(3):
try:
self.driver.get(url)
self.random_sleep(2, 4)
**滚动页面加载所有内容**
self.scroll_page()
content = self.driver.find_element(
By.CSS_SELECTOR,
"article.content, .article-body, .post-content"
).text
return content
except Exception as e:
logger.warning(f"获取文章内容失败: {str(e)}")
self.random_sleep(5, 10)
return ""
def save_to_json(self, filename='articles.json'):
"""
将爬取的数据保存为JSON文件
"""
with open(filename, 'w', encoding='utf-8') as f:
json.dump(self.article_data, f, ensure_ascii=False, indent=2)
logger.info(f"数据已保存到 {filename}")
def save_to_csv(self, filename='articles.csv'):
"""
将爬取的数据保存为CSV文件
"""
if not self.article_data:
logger.warning("没有数据可保存")
return
keys = self.article_data[0].keys()
with open(filename, 'w', newline='', encoding='utf-8-sig') as f:
writer = csv.DictWriter(f, fieldnames=keys)
writer.writeheader()
writer.writerows(self.article_data)
logger.info(f"数据已保存到 {filename}")
def run(self, start_url, pages=5):
"""
运行爬虫
Args:
start_url: 起始URL
pages: 要爬取的页数
"""
try:
self.setup_driver()
for page in range(1, pages + 1):
if page == 1:
url = start_url
else:
**根据实际网站的分页URL格式进行调整**
url = f"{start_url}?page={page}"
articles = self.crawl_page(url)
self.article_data.extend(articles)
**页面间随机等待**
if page < pages:
self.random_sleep(5, 15)
except KeyboardInterrupt:
logger.info("用户中断了爬虫运行")
except Exception as e:
logger.error(f"爬虫运行出错: {str(e)}")
finally:
if self.article_data:
self.save_to_json()
self.save_to_csv()
self.cleanup()
def cleanup(self):
"""
清理资源
"""
if self.driver:
try:
self.driver.quit()
logger.info("浏览器已关闭")
except Exception as e:
logger.warning(f"关闭浏览器时出错: {str(e)}")
if __name__ == "__main__":
crawler = NewsCrawler(headless=False, use_proxy=False)
crawler.run("https://example.com/news", pages=3)
这个完整的爬虫项目展示了undetected-chromedriver的多种高级用法。代码中包含了详细的注释，帮助读者理解每一部分的功能和原理。接下来让我们对代码的关键部分进行深入讲解。
浏览器配置部分是我们反检测策略的核心。通过设置user-agent为常见的浏览器字符串，我们可以避免被识别为默认的Selenium User-Agent。add_experimental_option中的excludeSwitches和useAutomationExtension设置可以进一步减少可检测特征。而execute_cdp_cmd方法允许我们注入JavaScript代码来修改浏览器对象，从根本上消除自动化指纹。
随机等待和滚动行为模拟是另一个重要的反检测策略。真实用户的操作具有随机性，而自动化脚本的操作往往过于规律。通过添加随机的时间间隔和滚动距离，我们可以让脚本的行为更接近真实用户。
异常处理和重试机制确保了爬虫的稳定性。在实际运行中，网络问题、目标网站反爬升级等各种情况都可能导致请求失败。良好的异常处理和重试机制可以让爬虫在遇到问题时自动恢复，而不会因为单个错误就完全崩溃。
验证码处理：进阶挑战与解决方案
在实际爬虫项目中，验证码是一个绕不开的话题。当网站检测到异常访问时，往往会弹出验证码来确认访问者是否为人类。虽然undetected-chromedriver能够绕过大多数基础的自动化检测，但对于验证码，我们仍然需要采用其他策略。
第一种方案是使用第三方验证码识别服务。国内有打码平台提供人工或AI识别服务，国外如2Captcha、Anti-Captcha等服务也有良好的口碑。这种方案的优点是识别准确率高，适用于各种类型的验证码；缺点是需要付费，而且会增加爬虫的运行成本。
import undetected_chromedriver as uc
import time
class CaptchaHandler:
"""
验证码处理类
演示如何集成第三方验证码识别服务
"""
def __init__(self, api_key):
"""
初始化验证码处理器
Args:
api_key: 验证码服务商提供的API密钥
"""
self.api_key = api_key
def solve_captcha(self, driver, captcha_type='image'):
"""
使用第三方服务解决验证码
Args:
driver: Selenium WebDriver实例
captcha_type: 验证码类型 (image/reCAPTCHA/hCaptcha等)
"""
if captcha_type == 'image':
return self._solve_image_captcha(driver)
elif captcha_type == 'reCAPTCHA':
return self._solve_recaptcha(driver)
elif captcha_type == 'slider':
return self._solve_slider_captcha(driver)
def _solve_image_captcha(self, driver):
"""
解决图片验证码
"""
try:
**获取验证码图片**
captcha_image = driver.find_element("css selector", "img.captcha-image")
captcha_image.screenshot('captcha.png')
**调用第三方API进行识别**
captcha_text = self._call_captcha_api('captcha.png', 'image')
**输入识别结果**
captcha_input = driver.find_element("css selector", "input[name='captcha']")
captcha_input.clear()
captcha_input.send_keys(captcha_text)
**点击提交按钮**
submit_button = driver.find_element("css selector", "button[type='submit']")
submit_button.click()
time.sleep(2)
return True
except Exception as e:
print(f"处理图片验证码失败: {e}")
return False
def _solve_recaptcha(self, driver):
"""
解决Google reCAPTCHA
"""
try:
**获取site key**
site_key = driver.find_element("css selector", ".g-recaptcha").get_attribute("data-sitekey")
**调用API获取解决方案**
solution = self._call_captcha_api(site_key, 'recaptcha')
**在页面上注入解决方案**
driver.execute_script(f"""
document.getElementById('g-recaptcha-response').innerHTML = '{solution}';
""")
**触发回调函数（如果有）**
driver.execute_script("___grecaptcha_cfg.clients[0].callback(arguments[0])", solution)
return True
except Exception as e:
print(f"处理reCAPTCHA失败: {e}")
return False
def _solve_slider_captcha(self, driver):
"""
解决滑块验证码
这是一个简化版本，实际使用中可能需要更复杂的算法
"""
try:
from selenium.webdriver.common.action_chains import ActionChains
**获取滑块和缺口位置（需要根据具体网站调整）**
slider = driver.find_element("css selector", ".slider")
缺口元素 = driver.find_element("css selector", ".gap")
**简单的滑动实现**
actions = ActionChains(driver)
actions.click_and_hold(slider)
actions.move_by_offset(200, 0)
actions.release()
actions.perform()
time.sleep(1)
return True
except Exception as e:
print(f"处理滑块验证码失败: {e}")
return False
def _call_captcha_api(self, data, captcha_type):
"""
调用第三方验证码识别API
Args:
data: 验证码数据（图片路径或site key）
captcha_type: 验证码类型
Returns:
str: 识别的验证码结果
"""
import requests
if captcha_type == 'image':
with open(data, 'rb') as f:
files = {'file': f}
data_dict = {'key': self.api_key}
response = requests.post('https://api.2captcha.com/in.php', data=data_dict, files=files)
else:
data_dict = {
'key': self.api_key,
'method': 'userrecaptcha',
'googlekey': data,
'pageurl': driver.current_url
}
response = requests.post('https://api.2captcha.com/in.php', data=data_dict)
result = response.json()
if result['status'] == 1:
captcha_id = result['request']
**轮询获取结果**
for _ in range(30):
time.sleep(5)
res = requests.get(f'https://api.2captcha.com/res.php?key={self.api_key}&action=get&id={captcha_id}')
res_json = res.json()
if res_json['status'] == 1:
return res_json['request']
raise Exception("验证码识别超时")
else:
raise Exception(f"验证码识别失败: {result}")
验证码处理的复杂性在于不同网站使用的验证码类型和验证机制各不相同。在实际项目中，建议先分析目标网站的验证码机制，再选择合适的处理方案。有时候，简单地降低访问频率、增加随机性，反而能够避免触发验证码。
分布式爬虫架构：提升采集效率
当单机爬虫无法满足数据采集的时效性和规模要求时，我们需要考虑分布式爬虫架构。undetected-chromedriver可以在分布式环境中发挥作用，但需要额外的配置来管理多个浏览器实例。
分布式爬虫的核心挑战包括：任务调度、结果汇总、状态管理和反检测策略的协同。以下是一个简化的分布式爬虫框架示例：
import undetected_chromedriver as uc
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import time
import random
import json
import hashlib
from collections import deque
from threading import Thread, Lock
import redis
class DistributedCrawler:
"""
分布式爬虫框架
使用Redis作为任务队列，支持多进程/多机器协同工作
"""
def __init__(self, redis_host='localhost', redis_port=6379):
"""
初始化分布式爬虫
Args:
redis_host: Redis服务器地址
redis_port: Redis服务器端口
"""
self.redis_client = redis.Redis(host=redis_host, port=redis_port, decode_responses=True)
self.seen_urls = set()
self.lock = Lock()
def _generate_fingerprint(self, url):
"""
生成URL指纹，用于去重
"""
return hashlib.md5(url.encode()).hexdigest()
def add_task(self, url, metadata=None):
"""
添加爬取任务到队列
Args:
url: 待爬取的URL
metadata: 附加的元数据（如优先级、来源等）
"""
fingerprint = self._generate_fingerprint(url)
**检查是否已经处理过**
if self.redis_client.sismember('processed_urls', fingerprint):
return False
task = {
'url': url,
'fingerprint': fingerprint,
'metadata': metadata or {},
'add_time': time.time()
}
**添加到任务队列**
self.redis_client.lpush('crawler_tasks', json.dumps(task))
return True
def get_task(self, timeout=5):
"""
从队列获取任务
Args:
timeout: 阻塞等待超时时间（秒）
Returns:
dict: 任务对象，如果没有任务返回None
"""
result = self.redis_client.brpop('crawler_tasks', timeout=timeout)
if result:
_, task_json = result
return json.loads(task_json)
return None
def mark_processed(self, url):
"""
标记URL为已处理
"""
fingerprint = self._generate_fingerprint(url)
self.redis_client.sadd('processed_urls', fingerprint)
def save_result(self, task, data):
"""
保存爬取结果
Args:
task: 原始任务对象
data: 爬取到的数据
"""
result = {
'url': task['url'],
'fingerprint': task['fingerprint'],
'metadata': task['metadata'],
'data': data,
'crawl_time': time.time()
}
self.redis_client.lpush('crawl_results', json.dumps(result))
def setup_driver(self, user_agent=None):
"""
配置浏览器实例
Args:
user_agent: 自定义User-Agent
"""
options = uc.ChromeOptions()
**反检测配置**
options.add_argument('--disable-blink-features=AutomationControlled')
options.add_argument('--no-sandbox')
options.add_argument('--disable-dev-shm-usage')
options.add_argument('--disable-gpu')
if user_agent:
options.add_argument(f'--user-agent={user_agent}')
else:
**随机选择User-Agent**
ua_list = [
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
]
options.add_argument(f'--user-agent={random.choice(ua_list)}')
options.add_experimental_option('excludeSwitches', ['enable-automation'])
options.add_experimental_option('useAutomationExtension', False)
driver = uc.Chrome(options=options, version_main=None)
**注入反检测脚本**
driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": """
Object.defineProperty(navigator, 'webdriver', {
get: () => undefined
});
Object.defineProperty(navigator, 'plugins', {
get: () => [1, 2, 3, 4, 5]
});
"""
})
return driver
def crawl_single_url(self, driver, url):
"""
爬取单个URL
Args:
driver: WebDriver实例
url: 目标URL
Returns:
dict: 爬取结果
"""
result = {
'title': '',
'content': '',
'links': [],
'success': False
}
try:
driver.get(url)
time.sleep(random.uniform(2, 5))
**提取页面标题**
try:
result['title'] = driver.title
except Exception:
pass
**提取主要内容**
try:
main_content = driver.find_element(By.CSS_SELECTOR, "main, article, .content")
result['content'] = main_content.text[:5000] # 限制内容长度
except Exception:
pass
**提取页面链接**
try:
link_elements = driver.find_elements(By.CSS_SELECTOR, "a[href^='http']")
for link in link_elements[:50]: # 限制链接数量
href = link.get_attribute('href')
if href and href not in self.seen_urls:
result['links'].append(href)
self.seen_urls.add(href)
except Exception:
pass
result['success'] = True
except Exception as e:
result['error'] = str(e)
return result
def worker(self, worker_id, proxy=None):
"""
爬虫工作进程
Args:
worker_id: 工作进程ID
proxy: 代理服务器地址（可选）
"""
print(f"Worker {worker_id} 启动")
options = uc.ChromeOptions()
options.add_argument('--disable-blink-features=AutomationControlled')
options.add_argument('--no-sandbox')
options.add_argument('--disable-dev-shm-usage')
if proxy:
options.add_argument(f'--proxy-server={proxy}')
ua_list = [
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
]
options.add_argument(f'--user-agent={random.choice(ua_list)}')
options.add_experimental_option('excludeSwitches', ['enable-automation'])
driver = uc.Chrome(options=options, version_main=None)
try:
while True:
task = self.get_task(timeout=10)
if task is None:
print(f"Worker {worker_id}: 队列为空，等待中...")
time.sleep(30)
continue
url = task['url']
print(f"Worker {worker_id} 开始处理: {url}")
result = self.crawl_single_url(driver, url)
self.save_result(task, result)
self.mark_processed(url)
**添加新发现的链接到任务队列**
for link in result.get('links', []):
self.add_task(link, {'source': url})
**任务间随机等待**
time.sleep(random.uniform(5, 15))
except KeyboardInterrupt:
print(f"Worker {worker_id} 收到停止信号")
except Exception as e:
print(f"Worker {worker_id} 发生错误: {e}")
finally:
driver.quit()
print(f"Worker {worker_id} 已关闭")
def start_workers(self, num_workers=3, proxies=None):
"""
启动多个工作进程
Args:
num_workers: 工作进程数量
proxies: 代理服务器列表
"""
threads = []
proxies = proxies or [None] * num_workers
for i in range(num_workers):
proxy = proxies[i] if i < len(proxies) else None
t = Thread(target=self.worker, args=(i+1, proxy))
t.daemon = True
t.start()
threads.append(t)
print(f"已启动 {num_workers} 个工作进程")
try:
for t in threads:
t.join()
except KeyboardInterrupt:
print("主进程收到停止信号，正在关闭...")
def get_statistics(self):
"""
获取爬虫运行统计信息
"""
stats = {
'pending_tasks': self.redis_client.llen('crawler_tasks'),
'processed_urls': self.redis_client.scard('processed_urls'),
'results_count': self.redis_client.llen('crawl_results')
}
return stats
def main():
"""
分布式爬虫主函数
"""
crawler = DistributedCrawler(redis_host='localhost', redis_port=6379)
**添加初始任务**
crawler.add_task('https://example.com', {'type': 'homepage'})
crawler.add_task('https://example.com/category/news', {'type': 'category'})
**启动3个工作进程**
crawler.start_workers(num_workers=3)
**输出统计信息**
stats = crawler.get_statistics()
print(f"爬虫统计: {stats}")
if __name__ == "__main__":
main()
这个分布式爬虫框架使用了Redis作为消息队列，实现了任务的分布式处理。在实际部署中，可以将工作进程部署在多台机器上，通过共享的Redis服务器实现任务协调。这种架构的优势在于可以水平扩展，通过增加工作节点来提升采集速度。
不过需要注意的是，分布式爬虫带来的不仅仅是效率提升，也带来了额外的复杂性。你需要考虑网络延迟、任务重复处理、系统资源协调等各种问题。在实际项目中，建议根据具体需求选择合适的架构复杂度。
反反爬虫：理解网站检测机制
想要更好地绕过网站的反爬虫检测，我们需要了解网站是如何检测自动化访问的。只有理解了检测机制，才能有针对性地采取措施。
JavaScript指纹检测是最常见的检测方式。网站会通过JavaScript代码收集浏览器的大量特征信息，用于生成唯一的指纹。常见的指纹维度包括：
User-Agent是最基础的指纹信息，它表明了浏览器的类型和版本。navigator.userAgent返回的字符串应当与请求头中的User-Agent一致。
navigator.webdriver属性在Selenium控制下的浏览器中会被设置为true，这是最直接的自动化检测点。
Canvas指纹通过让浏览器渲染特定的Canvas图形来获取。不同浏览器、显卡驱动、字体渲染等因素会导致生成的Canvas数据存在微小差异。
WebGL指纹可以获取显卡的供应商、渲染器名称等硬件信息。
AudioContext指纹通过处理音频数据来生成唯一的指纹。
字体指纹通过检测浏览器能够渲染的字体列表来判断。
时序攻击是一种更隐蔽的检测方式。某些操作在不同环境下的执行时间存在差异，网站可以通过分析这些时序特征来判断是否为自动化访问。
网络层面的检测包括TCP连接特征、TCP时间戳选项、TCP窗口大小等底层网络参数的差异。
对于这些检测机制，undetected-chromedriver已经做了一定的处理，但你也可以根据具体情况添加额外的对策：
import undetected_chromedriver as uc
import random
class AntiDetectionManager:
"""
高级反检测管理器
提供更全面的反检测配置
"""
@staticmethod
def get_random_user_agent():
"""
从常见User-Agent列表中随机选择一个
"""
user_agents = [
**Chrome on Windows**
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36',
**Chrome on macOS**
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
**Firefox on Windows**
'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:120.0) Gecko/20100101 Firefox/120.0',
**Firefox on Linux**
'Mozilla/5.0 (X11; Linux x86_64; rv:121.0) Gecko/20100101 Firefox/121.0',
**Safari on macOS**
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15',
]
return random.choice(user_agents)
@staticmethod
def setup_stealth_driver(version_main=None):
"""
配置高度隐形的浏览器
Args:
version_main: Chrome主版本号，None表示自动检测
"""
options = uc.ChromeOptions()
**基础配置**
options.add_argument('--disable-blink-features=AutomationControlled')
options.add_argument('--no-sandbox')
options.add_argument('--disable-dev-shm-usage')
options.add_argument('--disable-gpu')
options.add_argument('--disable-extensions')
options.add_argument('--disable-infobars')
options.add_argument('--disable-notifications')
options.add_argument('--disable-popup-blocking')
**视口配置**
viewports = [
(1920, 1080),
(1366, 768),
(1536, 864),
(1440, 900),
(1280, 720),
]
width, height = random.choice(viewports)
options.add_argument(f'--window-size={width},{height}')
**User-Agent配置**
user_agent = AntiDetectionManager.get_random_user_agent()
options.add_argument(f'--user-agent={user_agent}')
**语言配置**
languages = ['en-US,en;q=0.9', 'en-GB,en;q=0.9', 'zh-CN,zh;q=0.9', 'ja-JP,ja;q=0.9']
options.add_argument(f'--lang={random.choice(languages)}')
**时区配置（模拟真实用户）**
timezones = ['America/New_York', 'America/Los_Angeles', 'Europe/London', 'Asia/Shanghai']
options.add_argument(f'--timezone={random.choice(timezones)}')
**禁用自动化相关选项**
options.add_experimental_option('excludeSwitches', [
'enable-automation',
'enable-logging',
'disable-background-networking'
])
options.add_experimental_option('useAutomationExtension', False)
**创建浏览器实例**
driver = uc.Chrome(options=options, version_main=version_main)
**移除webdriver属性**
driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": """
Object.defineProperty(navigator, 'webdriver', {
get: () => undefined
});
"""
})
**伪装navigator.plugins**
driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": """
Object.defineProperty(navigator, 'plugins', {
get: () => {
const plugins = [];
for (let i = 0; i < 5; i++) {
plugins.push({
name: `Plugin ${i}`,
description: 'A plugin',
filename: `plugin${i}.dll`
});
}
Object.defineProperty(navigator, 'plugins', {
value: plugins,
writable: false,
configurable: false
});
return plugins;
}
});
"""
})
**伪装navigator.languages**
driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": f"""
Object.defineProperty(navigator, 'languages', {{
get: () => ['{random.choice(languages).split(",")[0]}', 'en-US', 'en']
}});
"""
})
**移除Chrome runtime相关属性**
driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": """
if (window.chrome) {
window.chrome.runtime = {
connect: function() {},
sendMessage: function() {}
};
}
"""
})
**伪装permissions**
driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": """
const originalQuery = window.navigator.permissions.query;
window.navigator.permissions.query = (parameters) => (
parameters.name === 'notifications' ?
Promise.resolve({ state: Notification.permission }) :
originalQuery(parameters)
);
"""
})
**伪造Canvas指纹**
driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": """
const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
HTMLCanvasElement.prototype.toDataURL = function() {
// 添加微小的随机噪声来模拟不同机器的渲染差异
if (this.width > 0 && this.height > 0) {
const ctx = this.getContext('2d');
if (ctx) {
const imageData = ctx.getImageData(0, 0, this.width, this.height);
// 添加微小噪声
for (let i = 0; i < imageData.data.length; i += 4) {
imageData.data[i] += Math.random() * 0.1;
imageData.data[i + 1] += Math.random() * 0.1;
imageData.data[i + 2] += Math.random() * 0.1;
}
ctx.putImageData(imageData, 0, 0);
}
}
return originalToDataURL.apply(this, arguments);
};
"""
})
**移除automation相关的事件监听器**
driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": """
window.addEventListener = function() {
const handler = arguments[1];
if (typeof handler === 'function' && handler.toString().includes('webdriver')) {
return;
}
return originalAddEventListener.apply(this, arguments);
};
const originalAddEventListener = window.addEventListener;
"""
})
return driver
@staticmethod
def simulate_human_behavior(driver):
"""
模拟人类行为模式的JavaScript代码
"""
driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": """
// 重写一些可能用于检测的关键函数
window.requestAnimationFrame = function(callback) {
return setTimeout(function() {
callback(Date.now());
}, Math.random() * 10 + 10);
};
// 伪装Date.now()
const originalDateNow = Date.now;
Date.now = function() {
return originalDateNow() + Math.floor(Math.random() * 10);
};
// 伪装performance.now()
const originalPerfNow = performance.now.bind(performance);
performance.now = function() {
return originalPerfNow() + Math.random() * 5;
};
"""
})
这段代码展示了更高级的反检测配置。需要强调的是，过度追求隐蔽性可能会影响爬虫的效率和稳定性，找到平衡点非常重要。有时候，简单的降低访问频率、避免峰值时段访问，反而比复杂的反检测措施更有效。
常见应用场景与实战技巧
了解了undetected-chromedriver的核心功能和配置方法后，让我们来看看它在不同场景下的实际应用。
电商数据采集是应用最广泛的场景之一。无论是竞品价格监控、用户评价分析还是商品信息聚合，都需要稳定可靠的数据采集能力。以下是一个电商数据采集的实战示例：
import undetected_chromedriver as uc
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import time
import random
import json
from datetime import datetime
import logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
class EcommerceScraper:
"""
电商数据采集器
演示如何采集电商平台的商品信息
"""
def __init__(self):
self.driver = None
self.data = []
def setup(self):
"""
配置浏览器
"""
options = uc.ChromeOptions()
options.add_argument('--disable-blink-features=AutomationControlled')
options.add_argument('--no-sandbox')
options.add_argument('--disable-dev-shm-usage')
options.add_argument('--disable-gpu')
options.add_argument('--window-size=1920,1080')
options.add_experimental_option('excludeSwitches', ['enable-automation'])
**使用随机的User-Agent**
user_agents = [
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
]
options.add_argument(f'--user-agent={random.choice(user_agents)}')
self.driver = uc.Chrome(options=options, version_main=None)
**反检测脚本**
self.driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": "Object.defineProperty(navigator, 'webdriver', {get: () => undefined});"
})
def random_delay(self, min_sec=1, max_sec=3):
"""
随机延迟，模拟人类操作
"""
time.sleep(random.uniform(min_sec, max_sec))
def search_product(self, keyword, pages=5):
"""
搜索商品并采集数据
Args:
keyword: 搜索关键词
pages: 要采集的页数
"""
try:
**访问搜索页面**
search_url = f"https://example-ecommerce.com/search?q={keyword.replace(' ', '+')}"
logger.info(f"开始搜索: {keyword}")
for page in range(1, pages + 1):
url = f"{search_url}&page={page}" if page > 1 else search_url
self.driver.get(url)
self.random_delay(2, 4)
**滚动加载更多商品**
self._scroll_and_load()
**提取商品列表**
products = self._extract_product_list()
logger.info(f"第 {page} 页提取到 {len(products)} 个商品")
for product in products:
**访问商品详情页**
detail_data = self._crawl_product_detail(product['url'])
product.update(detail_data)
self.data.append(product)
**详情页间延迟**
self.random_delay(3, 6)
**翻页间延迟**
if page < pages:
self.random_delay(5, 10)
except Exception as e:
logger.error(f"采集过程出错: {e}")
def _scroll_and_load(self):
"""
滚动页面以加载更多内容
"""
total_scrolls = random.randint(3, 5)
for _ in range(total_scrolls):
scroll_amount = random.randint(300, 700)
self.driver.execute_script(f"window.scrollBy(0, {scroll_amount});")
self.random_delay(0.5, 1.5)
**回到顶部**
self.driver.execute_script("window.scrollTo(0, 0);")
self.random_delay(1, 2)
def _extract_product_list(self):
"""
从搜索结果页面提取商品列表信息
"""
products = []
try:
**选择器需要根据实际网站结构调整**
items = self.driver.find_elements(
By.CSS_SELECTOR,
".product-item, .goods-item, [data-sku]"
)
for item in items:
try:
product = {}
**商品名称**
try:
title_elem = item.find_element(By.CSS_SELECTOR, ".product-title, .goods-name, .item-title")
product['title'] = title_elem.text.strip()
product['url'] = title_elem.get_attribute('href')
except Exception:
continue
**价格**
try:
price_elem = item.find_element(By.CSS_SELECTOR, ".price, .goods-price, .item-price")
product['price'] = price_elem.text.strip()
except Exception:
product['price'] = ''
**销量**
try:
sales_elem = item.find_element(By.CSS_SELECTOR, ".sales, .sold-count")
product['sales'] = sales_elem.text.strip()
except Exception:
product['sales'] = ''
**店铺名称**
try:
shop_elem = item.find_element(By.CSS_SELECTOR, ".shop-name, .seller-name")
product['shop'] = shop_elem.text.strip()
except Exception:
product['shop'] = ''
products.append(product)
except Exception as e:
logger.warning(f"提取商品信息失败: {e}")
continue
except Exception as e:
logger.error(f"提取商品列表失败: {e}")
return products
def _crawl_product_detail(self, url):
"""
访问商品详情页，提取更多信息
Args:
url: 商品详情页URL
Returns:
dict: 商品详情数据
"""
detail = {}
try:
self.driver.get(url)
self.random_delay(2, 4)
**提取商品描述**
try:
desc_elem = self.driver.find_element(By.CSS_SELECTOR, ".product-desc, .goods-desc")
detail['description'] = desc_elem.text.strip()[:500]
except Exception:
detail['description'] = ''
**提取评分**
try:
rating_elem = self.driver.find_element(By.CSS_SELECTOR, ".rating, .score")
detail['rating'] = rating_elem.text.strip()
except Exception:
detail['rating'] = ''
**提取评价数量**
try:
reviews_elem = self.driver.find_element(By.CSS_SELECTOR, ".reviews-count, .comment-count")
detail['reviews_count'] = reviews_elem.text.strip()
except Exception:
detail['reviews_count'] = ''
**提取库存状态**
try:
stock_elem = self.driver.find_element(By.CSS_SELECTOR, ".stock-status, .inventory")
detail['stock'] = stock_elem.text.strip()
except Exception:
detail['stock'] = ''
except Exception as e:
logger.warning(f"提取详情失败: {e}")
return detail
def save_data(self, filename='ecommerce_data.json'):
"""
保存采集的数据
"""
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
output_file = f"{filename.replace('.json', '')}_{timestamp}.json"
with open(output_file, 'w', encoding='utf-8') as f:
json.dump(self.data, f, ensure_ascii=False, indent=2)
logger.info(f"数据已保存到 {output_file}，共 {len(self.data)} 条记录")
def close(self):
"""
关闭浏览器
"""
if self.driver:
self.driver.quit()
logger.info("浏览器已关闭")
if __name__ == "__main__":
scraper = EcommerceScraper()
scraper.setup()
try:
**搜索并采集商品数据**
scraper.search_product("笔记本电脑", pages=3)
finally:
scraper.save_data()
scraper.close()
社交媒体数据采集是另一个重要场景。无论是舆情监控、用户研究还是内容分析，都需要从社交平台获取数据。以下示例展示了如何采集社交媒体帖子的信息：
import undetected_chromedriver as uc
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
import time
import random
import json
from datetime import datetime
class SocialMediaScraper:
"""
社交媒体数据采集器
"""
def __init__(self):
self.driver = None
def setup(self):
"""
配置浏览器
"""
options = uc.ChromeOptions()
options.add_argument('--disable-blink-features=AutomationControlled')
options.add_argument('--no-sandbox')
options.add_argument('--disable-dev-shm-usage')
options.add_argument('--disable-gpu')
options.add_argument('--window-size=1920,1080')
options.add_experimental_option('excludeSwitches', ['enable-automation'])
self.driver = uc.Chrome(options=options, version_main=None)
**反检测配置**
self.driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": """
Object.defineProperty(navigator, 'webdriver', {get: () => undefined});
Object.defineProperty(navigator, 'plugins', {
get: () => [1, 2, 3, 4, 5]
});
"""
})
def login(self, username, password):
"""
登录社交媒体账号
Args:
username: 用户名
password: 密码
"""
logger.info("开始登录...")
try:
**访问登录页面**
self.driver.get("https://example-social.com/login")
time.sleep(3)
**输入用户名**
username_input = self.driver.find_element(By.CSS_SELECTOR, "input[name='username'], input[type='email']")
username_input.clear()
username_input.send_keys(username)
time.sleep(random.uniform(0.5, 1))
**输入密码**
password_input = self.driver.find_element(By.CSS_SELECTOR, "input[name='password'], input[type='password']")
password_input.clear()
password_input.send_keys(password)
time.sleep(random.uniform(0.5, 1))
**点击登录按钮**
login_button = self.driver.find_element(By.CSS_SELECTOR, "button[type='submit'], .login-btn")
login_button.click()
**等待登录完成**
time.sleep(5)
logger.info("登录成功")
except Exception as e:
logger.error(f"登录失败: {e}")
def search_hashtag(self, hashtag, max_posts=100):
"""
搜索话题标签并采集帖子
Args:
hashtag: 话题标签（不含#号）
max_posts: 最大采集帖子数
"""
posts = []
try:
**访问话题页面**
search_url = f"https://example-social.com/hashtag/{hashtag}"
self.driver.get(search_url)
time.sleep(3)
scroll_count = 0
max_scrolls = (max_posts // 20) + 10 # 每屏大约20个帖子
while len(posts) < max_posts and scroll_count < max_scrolls:
**提取当前屏幕的帖子**
post_elements = self.driver.find_elements(By.CSS_SELECTOR, ".post-item, article.post")
for elem in post_elements:
if len(posts) >= max_posts:
break
post = self._extract_post_data(elem)
if post:
posts.append(post)
**滚动到下一屏**
self.driver.execute_script("window.scrollBy(0, 800);")
time.sleep(random.uniform(2, 4))
scroll_count += 1
logger.info(f"已采集 {len(posts)} 条帖子")
return posts
except Exception as e:
logger.error(f"采集帖子失败: {e}")
return posts
def _extract_post_data(self, post_element):
"""
提取单条帖子数据
Args:
post_element: 帖子元素
Returns:
dict: 帖子数据
"""
post = {}
try:
**提取作者**
try:
author_elem = post_element.find_element(By.CSS_SELECTOR, ".author-name, .user-name")
post['author'] = author_elem.text.strip()
except Exception:
post['author'] = ''
**提取内容**
try:
content_elem = post_element.find_element(By.CSS_SELECTOR, ".post-content, .content, p")
post['content'] = content_elem.text.strip()
except Exception:
post['content'] = ''
**提取发布时间**
try:
time_elem = post_element.find_element(By.CSS_SELECTOR, ".post-time, time")
post['timestamp'] = time_elem.get_attribute('datetime') or time_elem.text.strip()
except Exception:
post['timestamp'] = ''
**提取互动数据**
try:
likes_elem = post_element.find_element(By.CSS_SELECTOR, ".likes-count, .like-count")
post['likes'] = likes_elem.text.strip()
except Exception:
post['likes'] = '0'
try:
comments_elem = post_element.find_element(By.CSS_SELECTOR, ".comments-count, .comment-count")
post['comments'] = comments_elem.text.strip()
except Exception:
post['comments'] = '0'
try:
shares_elem = post_element.find_element(By.CSS_SELECTOR, ".shares-count, .share-count")
post['shares'] = shares_elem.text.strip()
except Exception:
post['shares'] = '0'
except Exception as e:
logger.warning(f"提取帖子数据失败: {e}")
return None
return post
def crawl_user_profile(self, username):
"""
采集用户资料信息
Args:
username: 用户名
"""
profile = {}
try:
profile_url = f"https://example-social.com/user/{username}"
self.driver.get(profile_url)
time.sleep(3)
**提取用户基本信息**
try:
name_elem = self.driver.find_element(By.CSS_SELECTOR, ".profile-name, .user-name")
profile['name'] = name_elem.text.strip()
except Exception:
profile['name'] = ''
try:
bio_elem = self.driver.find_element(By.CSS_SELECTOR, ".profile-bio, .bio")
profile['bio'] = bio_elem.text.strip()
except Exception:
profile['bio'] = ''
**提取统计数据**
stats = {}
try:
followers_elem = self.driver.find_element(By.CSS_SELECTOR, ".followers-count")
stats['followers'] = followers_elem.text.strip()
except Exception:
stats['followers'] = '0'
try:
following_elem = self.driver.find_element(By.CSS_SELECTOR, ".following-count")
stats['following'] = following_elem.text.strip()
except Exception:
stats['following'] = '0'
try:
posts_elem = self.driver.find_element(By.CSS_SELECTOR, ".posts-count")
stats['posts'] = posts_elem.text.strip()
except Exception:
stats['posts'] = '0'
profile['stats'] = stats
except Exception as e:
logger.error(f"采集用户资料失败: {e}")
return profile
def save_posts(self, posts, filename='social_posts.json'):
"""
保存帖子数据
"""
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
output_file = f"{filename.replace('.json', '')}_{timestamp}.json"
with open(output_file, 'w', encoding='utf-8') as f:
json.dump(posts, f, ensure_ascii=False, indent=2)
logger.info(f"数据已保存到 {output_file}")
def close(self):
"""
关闭浏览器
"""
if self.driver:
self.driver.quit()
def main():
scraper = SocialMediaScraper()
scraper.setup()
try:
**可选：登录账号**
**scraper.login("your_username", "your_password")**
**搜索话题采集帖子**
posts = scraper.search_hashtag("technology", max_posts=50)
scraper.save_posts(posts)
**采集特定用户资料**
profile = scraper.crawl_user_profile("example_user")
print(f"用户资料: {profile}")
finally:
scraper.close()
if __name__ == "__main__":
main()
这两个实战示例展示了undetected-chromedriver在电商和社交媒体场景下的应用。需要注意的是，这些示例中的CSS选择器都是示例性的，实际使用时需要根据目标网站的具体结构进行调整。
调试技巧与问题排查
在使用undetected-chromedriver的过程中，难免会遇到各种问题。掌握一些调试技巧可以帮助我们快速定位和解决问题。
浏览器启动失败的排查是最常见的问题之一。当你运行代码时遇到类似”Chrome failed to start”的错误，首先需要检查以下几点：
确认Chrome浏览器已经正确安装在系统上。在终端中运行google-chrome –version（Linux）或在浏览器地址栏输入chrome://settings/help来确认。
检查是否有其他Chrome进程正在运行，这可能会导致端口冲突。在Windows上可以使用任务管理器查看，Linux上可以使用ps aux | grep chrome命令。
确认ChromeDriver版本与Chrome浏览器版本兼容。版本不匹配是导致启动失败的常见原因。
确认用户数据目录没有被其他进程占用。如果使用了user-data-dir参数，确保没有其他Chrome实例正在使用该目录。
当浏览器能够启动但被网站检测到时，我们需要更深入的调试。以下是一些有用的调试技巧：
检查浏览器指纹。使用浏览器的开发者工具（F12），在Console中输入以下命令来检查关键属性：
// 检查webdriver属性
console.log(navigator.webdriver);
// 检查plugins
console.log(navigator.plugins);
// 检查languages
console.log(navigator.languages);
// 检查userAgent
console.log(navigator.userAgent);
// 检查是否有自动化相关的条件判断
console.log(window.callPhantom);
console.log(window._phantom);
console.log(window.__webdriver_evaluate);
console.log(window.__selenium_evaluate);
console.log(window.__webdriver_script_function);
console.log(window.__webdriver_script_func);
console.log(window.__webdriver_script_fn);
如果上述任何检查返回非预期值，说明反检测配置还不够完善。
网络请求分析是另一个重要的调试手段。通过开发者工具的Network标签页，我们可以查看页面加载过程中的所有网络请求，包括：
XHR/Fetch请求：查看异步加载的数据接口
文档请求：查看HTML文档及其加载的资源
错误请求：检查是否有请求返回错误状态码
可疑请求：有些反爬虫系统会加载特定的检测脚本
Cookie和Session分析有时也能发现问题。某些网站会通过Cookie来识别自动化访问，检查Cookie的设置和传递是否正常。
性能优化也是调试的一部分。当爬虫运行缓慢时，我们需要分析瓶颈在哪里。以下是一个性能分析工具的示例：
import undetected_chromedriver as uc
import time
import logging
from functools import wraps
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def timing_decorator(func):
"""
装饰器：测量函数执行时间
"""
@wraps(func)
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
elapsed = end_time - start_time
logger.info(f"{func.__name__} 执行耗时: {elapsed:.2f} 秒")
return result
return wrapper
class PerformanceAnalyzer:
"""
性能分析器
用于分析爬虫各环节的执行时间
"""
def __init__(self):
self.timings = {}
def measure(self, operation_name):
"""
上下文管理器：测量操作耗时
"""
return TimingContext(self.timings, operation_name)
def report(self):
"""
生成性能报告
"""
total_time = sum(self.timings.values())
logger.info("=" * 50)
logger.info("性能分析报告")
logger.info("=" * 50)
sorted_timings = sorted(self.timings.items(), key=lambda x: x[1], reverse=True)
for name, elapsed in sorted_timings:
percentage = (elapsed / total_time * 100) if total_time > 0 else 0
logger.info(f"{name}: {elapsed:.2f}秒 ({percentage:.1f}%)")
logger.info(f"总耗时: {total_time:.2f}秒")
logger.info("=" * 50)
@timing_decorator
def setup_browser(self):
"""
模拟浏览器启动过程
"""
options = uc.ChromeOptions()
options.add_argument('--disable-blink-features=AutomationControlled')
options.add_argument('--no-sandbox')
driver = uc.Chrome(options=options, version_main=None)
time.sleep(1)
driver.quit()
@timing_decorator
def page_navigation(self, url):
"""
模拟页面导航
"""
options = uc.ChromeOptions()
options.add_argument('--headless')
driver = uc.Chrome(options=options, version_main=None)
driver.get(url)
time.sleep(2)
driver.quit()
@timing_decorator
def element_extraction(self, url):
"""
模拟元素提取
"""
options = uc.ChromeOptions()
options.add_argument('--headless')
driver = uc.Chrome(options=options, version_main=None)
driver.get(url)
**模拟提取多个元素**
for _ in range(10):
try:
driver.find_elements("css selector", "div")
except Exception:
pass
time.sleep(0.1)
driver.quit()
if __name__ == "__main__":
analyzer = PerformanceAnalyzer()
**运行性能测试**
test_url = "https://example.com"
with analyzer.measure("浏览器启动"):
analyzer.setup_browser()
with analyzer.measure("页面导航"):
analyzer.page_navigation(test_url)
with analyzer.measure("元素提取"):
analyzer.element_extraction(test_url)
**输出性能报告**
analyzer.report()
通过性能分析，我们可以发现爬虫的瓶颈所在，并针对性地进行优化。常见的性能问题包括：页面加载等待时间过长、频繁的滚动操作浪费了大量时间、没有合理使用缓存等。
最佳实践与经验总结
在长期使用undetected-chromedriver的过程中，我积累了一些最佳实践和经验教训，希望能够帮助你更好地使用这个工具。
合理控制请求频率是最基本也是最重要的原则。即使使用了最先进的反检测技术，过高的请求频率仍然会引起网站的注意。建议根据目标网站的规模和反爬虫强度，设置合理的请求间隔。一般来说，热门网站的反爬虫更严格，需要更长的间隔；而一些小网站则相对宽松。
使用高质量的代理服务可以显著提高采集成功率。住宅代理（Residential Proxy）比数据中心代理（Data Center Proxy）更难被识别，因为它们来自真实的家庭网络地址。虽然成本更高，但在对抗严格的反爬虫系统时，物有所值。
维护好登录会话是持续采集的关键。如果需要登录才能访问数据，应该妥善管理Cookie和会话信息。使用持久化的用户数据目录可以保持登录状态，避免频繁登录带来的风险和检测风险。
做好异常处理和日志记录让你的爬虫更加健壮。网络波动、网站改版、验证码弹窗等情况都可能导致脚本失败。良好的异常处理可以让你在出现问题时快速定位原因，而详细的日志则可以帮助你了解爬虫的运行状态。
定期更新代码以适应网站变化。反爬虫系统会不断升级，目标网站的页面结构也可能发生变化。保持代码的灵活性，定期检查和维护爬虫脚本，是确保持续可用的关键。
遵守法律法规和网站规则是使用任何爬虫工具的前提。尊重robots.txt文件的规定，不采集敏感个人信息，不将数据用于非法用途，这些不仅是法律要求，也是互联网社区的基本规范。
与相关AI项目的协同
undetected-chromedriver作为一个专注于浏览器自动化的工具，与当前火热的人工智能领域有着广泛的结合点。了解这些相关项目可以帮助你构建更强大的自动化和智能化解决方案。
在数据采集层面，undetected-chromedriver可以与各种AI辅助工具结合使用。例如，可以使用OpenAI的GPT模型来帮助理解页面内容、生成更自然的交互行为，或者帮助解析复杂的JavaScript渲染页面。
在图像识别领域，结合PaddleOCR或其他OCR工具，可以处理验证码识别问题；而结合YOLO等目标检测模型，则可以更精准地从页面中提取所需信息。
在自然语言处理方面，完成数据采集后，可以使用jieba进行中文分词、使用transformers库进行情感分析、使用文本摘要模型提取关键信息等。这些处理可以让你从海量原始数据中提炼出有价值的洞察。
如果你对AI辅助的数据采集感兴趣，以下是一些值得关注的开源项目：
Scrapy + Selenium/Playwright组合：传统爬虫框架与现代浏览器自动化的结合，适合构建复杂的爬虫系统。
Playwright：微软开发的浏览器自动化工具，与Selenium类似但提供了更现代的API和一些独特的特性。
Puppeteer/PuppeteerSharp：Google Chrome团队维护的Node.js/C#浏览器自动化库。
DrissionPage：国产的网页自动化工具，提供了简洁的中文API和强大的功能。
Antigate/CaptchaBreaker：专注于验证码识别的开源或商业解决方案。
相关资源链接
为了帮助你更好地学习和使用undetected-chromedriver，以下是一些有用的资源链接：
GitHub项目主页：https://github.com/ultrafunkamsterdam/undetected-chromedriver – 项目的源代码和问题反馈渠道
PyPI发布页面：https://pypi.org/project/undetected-chromedriver/ – 官方发布的Python包
官方文档和示例：项目GitHub页面中的README.md文件包含了详细的使用说明和示例代码
Selenium官方文档：https://www.selenium.dev/documentation/ – Selenium WebDriver的完整文档
Chrome选项参考：https://peter.sh/experiments/chromium-command-line-switches/ – Chrome启动参数的完整列表
Chrome DevTools Protocol文档：https://chromedevtools.github.io/devtools-protocol/ – CDP命令的详细说明
结语
undetected-chromedriver为浏览器自动化提供了一个强大而灵活的解决方案。通过深入理解其工作原理、熟练掌握其配置方法，并结合良好的编程实践，我们可以构建出稳定、高效、隐蔽的自动化采集系统。
正如文章开头所说，这个工具真正解决了爬虫开发者长期以来的痛点。它让自动化浏览器变得难以被识别，大大提高了数据采集的成功率。但我们也要记住，技术工具本身是中性的，关键在于使用者的意图和方式。
在人工智能快速发展的今天，undetected-chromedriver与各类AI工具的结合将开辟出更多可能性。从智能化的数据采集到自动化的内容分析，从机器学习模型的训练数据准备到实时舆情监控系统的构建，这个开源工具都扮演着重要的角色。
希望这篇教程能够帮助你全面掌握undetected-chromedriver的使用方法。无论你是刚刚入门的新手，还是有一定经验的开发者，都能从中获得有价值的信息。如果你在使用过程中遇到问题或有新的发现，欢迎在评论区分享交流。让我们一起探索技术的边界，创造更多的可能性。
“`
评论区