使用XPath精准提取HTML文本：从入门到精通的实战技巧与常见问题解析

Hello World

• Item 1
• Item 2

和

是
的子节点
“Hello World”是

的文本节点
1.2 基本路径表达式
XPath使用路径表达式来选择节点，类似于文件系统中的路径：
绝对路径
从根节点开始的完整路径：
/html/body/div/p
相对路径
从当前节点开始的路径：
./p
通配符
*
：匹配任意元素节点
@*
：匹配任意属性节点
示例：
# Python中使用lxml库的示例
from lxml import html

html_content = “””



Hello World

• Item 1
• Item 2



“””

tree = html.fromstring(html_content)

# 使用绝对路径
p_element = tree.xpath(‘/html/body/div/p/text()’)[0]
print(f”绝对路径提取: {p_element}”)

# 使用相对路径
div = tree.xpath(‘/html/body/div’)[0]
p_relative = div.xpath(‘./p/text()’)[0]
print(f”相对路径提取: {p_relative}”)

# 使用通配符
all_elements = tree.xpath(‘//*’)
print(f”文档中所有元素数量: {len(all_elements)}”)
1.3 谓词（Predicates）
谓词用于过滤节点集，是XPath强大功能的核心。谓词用方括号
[]
表示，可以包含条件表达式。
常用谓词类型：
索引谓词
：选择特定位置的节点
//li[1] # 选择第一个li元素
//li[last()] # 选择最后一个li元素
//li[position() <= 2] # 选择前两个li元素 属性谓词 ：基于属性值选择节点 //div[@id='container'] # 选择id为container的div //p[@class] # 选择具有class属性的p元素 文本谓词 ：基于文本内容选择节点 //li[text()='Item 1'] # 选择文本为Item 1的li元素 //p[contains(text(), 'Hello')] # 选择包含Hello文本的p元素 函数组合谓词 ：使用函数进行复杂过滤 //div[contains(@class, 'main') and @id] # 选择同时满足条件的div 谓词实战示例： from lxml import html html_content = """

Featured Post

2024-01-15


Regular Post

2024-01-14


Another Post

2024-01-13


“””

tree = html.fromstring(html_content)

# 选择第一个article
first_post = tree.xpath(‘//article[1]/h2/text()’)[0]
print(f”第一个帖子标题: {first_post}”)

# 选择最后一个article
last_post = tree.xpath(‘//article[last()]/h2/text()’)[0]
print(f”最后一个帖子标题: {last_post}”)

# 选择具有featured类的article
featured_post = tree.xpath(‘//article[contains(@class, “featured”)]/h2/text()’)[0]
print(f”精选帖子标题: {featured_post}”)

# 选择data-id大于101的article
posts = tree.xpath(‘//article[number(@data-id) > 101]/h2/text()’)
print(f”ID大于101的帖子: {posts}”)

# 选择日期在2024-01-14之后的帖子
recent_posts = tree.xpath(‘//article[span[@class=”date”] >= “2024-01-14″]/h2/text()’)
print(f”最近帖子: {recent_posts}”)
第二部分：高级XPath技巧
2.1 轴（Axes）的使用
轴定义了相对于当前节点的节点集合，是XPath高级查询的核心。
常用轴及其语法：
轴名称
语法
描述
child
child::
当前节点的子节点（默认轴）
parent
parent::
当前节点的父节点
ancestor
ancestor::
当前节点的所有祖先节点
descendant
descendant::
当前节点的所有后代节点
following-sibling
following-sibling::
当前节点之后的所有同级节点
preceding-sibling
preceding-sibling::
当前节点之前的所有同级节点
attribute
attribute::
当前节点的属性
轴使用示例：
from lxml import html

html_content = “””

• Home
• About
• Contact

Content here

“””

tree = html.fromstring(html_content)

# 使用child轴（默认）
home = tree.xpath(‘//li[@id=”home”]/child::text()’)[0]
print(f”使用child轴: {home}”)

# 使用parent轴
ul = tree.xpath(‘//li[@id=”home”]/parent::ul’)[0]
print(f”父节点标签: {ul.tag}”)

# 使用following-sibling轴
about = tree.xpath(‘//li[@id=”home”]/following-sibling::li[1]/text()’)[0]
print(f”下一个兄弟节点: {about}”)

# 使用preceding-sibling轴
contact = tree.xpath(‘//li[@id=”contact”]/preceding-sibling::li[1]/text()’)[0]
print(f”上一个兄弟节点: {contact}”)

# 使用ancestor轴
div = tree.xpath(‘//li[@id=”home”]/ancestor::div[@class=”menu”]’)[0]
print(f”祖先div的class: {div.get(‘class’)}”)

# 使用attribute轴
id_value = tree.xpath(‘//li[@id=”home”]/attribute::id’)[0]
print(f”属性id的值: {id_value}”)
2.2 函数的高级应用
XPath提供了丰富的内置函数，可以处理字符串、数值、节点集等。
字符串函数：
concat(str1, str2, …)
：连接字符串
contains(str, substr)
：检查是否包含子串
starts-with(str, substr)
：检查是否以子串开头
string-length(str)
：获取字符串长度
normalize-space(str)
：去除首尾空白并标准化内部空白
数值函数：
number(arg)
：转换为数字
sum(node-set)
：求和
floor(number)
：向下取整
ceiling(number)
：向上取整
round(number)
：四舍五入
节点函数：
last()
：返回节点集中的最后一个位置
position()
：返回当前节点的位置
count(node-set)
：计算节点数量
id(id)
：通过ID选择节点
local-name(node)
：返回节点的本地名称
namespace-uri(node)
：返回节点的命名空间URI
函数高级应用示例：
from lxml import html

html_content = “””

Product A
Electronics

Product B
Books

Product C
Electronics

“””

tree = html.fromstring(html_content)

# 字符串函数：连接产品名称和价格
products = tree.xpath(‘//div[@class=”product”]’)
for product in products:
name = product.xpath(‘./span[@class=”name”]/text()’)[0]
price = product.xpath(‘./@data-price’)[0]
# 使用concat函数
info = product.xpath(‘concat(“产品: “, span[@class=”name”]/text(), ” – 价格: $”, @data-price)’)[0]
print(info)

# 数值函数：计算总库存和平均价格
total_stock = tree.xpath(‘sum(//div[@class=”product”]/@data-stock)’)[0]
avg_price = tree.xpath(‘avg(//div[@class=”product”]/@data-price)’)[0] # 注意：avg不是标准函数，需要计算
prices = tree.xpath(‘//div[@class=”product”]/@data-price’)
avg_price_manual = sum(float(p) for p in prices) / len(prices)
print(f”总库存: {total_stock}”)
print(f”平均价格: ${avg_price_manual:.2f}”)

# 节点函数：筛选价格大于50的产品
expensive_products = tree.xpath(‘//div[@class=”product”][number(@data-price) > 50]/span[@class=”name”]/text()’)
print(f”价格大于50的产品: {expensive_products}”)

# 使用字符串函数进行模糊匹配
electronics = tree.xpath(‘//div[@class=”product”][contains(span[@class=”category”], “Electronics”)]/span[@class=”name”]/text()’)
print(f”电子产品: {electronics}”)
2.3 运算符与条件表达式
XPath支持多种运算符，可以构建复杂的查询条件。
算术运算符：
+
,
–
,
*
,
div
（除法）,
mod
（取模）
比较运算符：
=
,
!=
,
< , >
,
<= , >=
逻辑运算符：
and
,
or
,
not()
运算符实战示例：
from lxml import html

html_content = “””


John Doe


Jane Smith


Bob Johnson


Alice Brown


“””

tree = html.fromstring(html_content)

# 使用算术运算符：金额大于100的订单
high_value_orders = tree.xpath(‘//order[number(@amount) > 100]/customer/text()’)
print(f”高价值订单客户: {high_value_orders}”)

# 使用逻辑运算符：已完成且金额大于100的订单
completed_high = tree.xpath(‘//order[@status=”completed” and number(@amount) > 100]/customer/text()’)
print(f”已完成的高价值订单: {completed_high}”)

# 使用not()函数：未完成的订单
pending_orders = tree.xpath(‘//order[not(@status=”completed”)]/customer/text()’)
print(f”未完成订单客户: {pending_orders}”)

# 使用or运算符：高优先级或金额大于200的订单
urgent_orders = tree.xpath(‘//order[@priority=”high” or number(@amount) > 200]/customer/text()’)
print(f”紧急订单客户: {urgent_orders}”)

# 组合运算符：已完成的高优先级订单，金额在100-250之间
complex_orders = tree.xpath(
‘//order[@status=”completed” and @priority=”high” and number(@amount) >= 100 and number(@amount) <= 250]/customer/text()' ) print(f"复杂条件订单: {complex_orders}") 第三部分：实战技巧与最佳实践 3.1 处理动态生成的HTML 现代Web应用大量使用JavaScript动态生成内容，这给XPath提取带来了挑战。 解决方案： 使用浏览器开发者工具 ： 在Elements面板中检查最终渲染的DOM结构 使用Console测试XPath表达式 使用无头浏览器 ： Selenium + XPath Playwright + XPath 等待策略 ： 显式等待元素出现 隐式等待 Selenium + XPath 实战示例： 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.chrome.options import Options # 配置无头浏览器 chrome_options = Options() chrome_options.add_argument("--headless") chrome_options.add_argument("--no-sandbox") chrome_options.add_argument("--disable-dev-shm-usage") driver = webdriver.Chrome(options=chrome_options) try: # 访问动态内容页面 driver.get("https://example.com/dynamic-content") # 等待特定元素出现（使用XPath） wait = WebDriverWait(driver, 10) dynamic_element = wait.until( EC.presence_of_element_located((By.XPATH, "//div[@class='loaded-content']")) ) # 提取动态生成的内容 title = driver.find_element(By.XPATH, "//h1[@class='dynamic-title']").text items = driver.find_elements(By.XPATH, "//ul[@class='item-list']/li") print(f"动态标题: {title}") print("动态列表项:") for item in items: print(f" - {item.text}") finally: driver.quit() 3.2 处理复杂的HTML结构 技巧1：使用多个条件组合 from lxml import html html_content = """

Tech Article 1

John
2024-01-15

…

Science Article 1

Jane
2024-01-14

…

“””

tree = html.fromstring(html_content)

# 提取科技类精选文章的标题和作者
featured_tech = tree.xpath(
‘//article[@data-category=”tech” and @data-featured=”true”]//h2[@class=”title”]/text()’
)
authors = tree.xpath(
‘//article[@data-category=”tech” and @data-featured=”true”]//span[@class=”author”]/text()’
)

print(f”精选科技文章: {featured_tech}”)
print(f”作者: {authors}”)
技巧2：使用
|
运算符合并多个路径
# 提取多个不同位置的标题
titles = tree.xpath(‘//h1/text() | //h2/text() | //h3/text()’)
print(f”所有标题: {titles}”)
抸巧3：使用
//
进行深层搜索
# 无论嵌套多深，都能找到class为title的元素
deep_titles = tree.xpath(‘//*[contains(@class, “title”)]/text()’)
print(f”深层标题: {deep_titles}”)
3.3 性能优化技巧
1. 避免使用
//
开头的表达式
# 不推荐：从根节点遍历所有节点
slow = tree.xpath(‘//div/p’)

# 推荐：指定具体路径
fast = tree.xpath(‘/html/body/div/p’)
2. 使用具体的选择器
# 不推荐：使用通配符
slow = tree.xpath(‘//*[@class=”item”]’)

# 推荐：指定具体标签
fast = tree.xpath(‘//div[@class=”item”]’)
3. 限制搜索范围
# 先定位到父容器，再在容器内搜索
container = tree.xpath(‘//div[@id=”main-content”]’)[0]
items = container.xpath(‘.//li’)
4. 使用索引和位置
# 只取前10个元素
first_ten = tree.xpath(‘//li[position() <= 10]') 第四部分：常见问题解析 4.1 问题1：XPath表达式返回空结果 原因分析： HTML结构不匹配 ：实际HTML与预期结构不符 命名空间问题 ：HTML文档包含XML命名空间 动态内容 ：内容由JavaScript生成，初始HTML中不存在 大小写敏感 ：XPath对标签名和属性名大小写敏感 解决方案： from lxml import html # 问题示例：HTML包含命名空间 html_with_ns = """


Content



“””

tree = html.fromstring(html_with_ns)

# 错误：普通XPath无法找到元素
result1 = tree.xpath(‘//div[@id=”test”]/text()’)
print(f”普通XPath结果: {result1}”) # 输出: []

# 正确：使用local-name()忽略命名空间
result2 = tree.xpath(‘//*[local-name()=”div” and @id=”test”]/text()’)
print(f”忽略命名空间结果: {result2}”) # 输出: [‘Content’]

# 或者注册命名空间
tree = html.fromstring(html_with_ns)
tree.getroottree().xpath_register_namespace(‘h’, ‘http://www.w3.org/1999/xhtml’)
result3 = tree.xpath(‘//h:div[@id=”test”]/text()’)
print(f”注册命名空间结果: {result3}”) # 输出: [‘Content’]
4.2 问题2：提取文本时包含不需要的内容
原因分析：
HTML中可能包含注释、脚本、样式等干扰内容
文本节点可能包含大量空白字符
解决方案：
from lxml import html

html_content = “””

这是一个段落。



这是继续的文本。

“””

tree = html.fromstring(html_content)

# 方法1：使用string()函数获取所有文本
all_text = tree.xpath(‘//div[@class=”article”]/p/string()’)[0]
print(f”所有文本: ‘{all_text}’”)

# 方法2：使用text()只获取直接文本节点
direct_text = tree.xpath(‘//div[@class=”article”]/p/text()’)
print(f”直接文本节点: {direct_text}”)

# 方法3：使用normalize-space()清理空白
clean_text = tree.xpath(‘normalize-space(//div[@class=”article”]/p)’)[0]
print(f”清理后的文本: ‘{clean_text}’”)

# 方法4：排除特定元素
filtered_text = tree.xpath(
‘//div[@class=”article”]/p[not(self::script) and not(self::style)]/text()’
)
print(f”过滤后的文本: {filtered_text}”)
4.3 问题3：处理编码问题
原因分析：
HTML文档可能使用不同的字符编码
特殊字符（如中文、emoji）可能导致提取错误
解决方案：
from lxml import html
import requests

# 从URL获取HTML并处理编码
def extract_with_encoding(url, xpath_expression):
response = requests.get(url)

# 自动检测编码
response.encoding = response.apparent_encoding

# 或者手动指定编码
# response.encoding = ‘utf-8’

tree = html.fromstring(response.content)

# 处理编码后的文本
result = tree.xpath(xpath_expression)

# 如果结果是字符串，确保正确解码
if result and isinstance(result[0], str):
# Python 3中字符串已经是Unicode
return result

return result

# 示例：提取中文内容
html_cn = “””






这是一个中文段落



“””

tree = html.fromstring(html_cn.encode(‘utf-8’))
text = tree.xpath(‘//div[@class=”content”]/text()’)[0]
print(f”中文文本: {text}”)
4.4 问题4：XPath在不同解析器中的差异
问题描述：
不同解析器（lxml、BeautifulSoup、Selenium等）对XPath的支持程度和行为可能不同。
解决方案：
# 1. lxml解析器
from lxml import html
tree = html.fromstring(html_content)
result = tree.xpath(‘//div[@class=”test”]’)

# 2. BeautifulSoup + lxml解析器
from bs4 import BeautifulSoup
soup = BeautifulSoup(html_content, ‘lxml’)
result = soup.select(‘div.test’) # CSS选择器，但可以转换为XPath

# 3. Selenium
from selenium import webdriver
driver = webdriver.Chrome()
driver.get(url)
result = driver.find_elements(By.XPATH, ‘//div[@class=”test”]’)

# 4. 使用统一的XPath库
from lxml import etree
parser = etree.XMLParser(recover=True) # 容错模式
tree = etree.fromstring(html_content, parser=parser)
result = tree.xpath(‘//div[@class=”test”]’)
4.5 问题5：处理AJAX加载的内容
解决方案：
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
import time

def extract_ajax_content(url, wait_xpath, extract_xpath):
driver = webdriver.Chrome()
try:
driver.get(url)

# 等待AJAX内容加载完成
wait = WebDriverWait(driver, 10)
wait.until(EC.presence_of_element_located((By.XPATH, wait_xpath)))

# 额外等待确保内容完全渲染
time.sleep(2)

# 提取内容
elements = driver.find_elements(By.XPATH, extract_xpath)
return [elem.text for elem in elements]

finally:
driver.quit()

# 示例：提取动态加载的评论
comments = extract_ajax_content(
“https://example.com/article”,
wait_xpath=”//div[@class=’comments-loaded’]”,
extract_xpath=”//div[@class=’comment’]/text()”
)
print(f”提取的评论: {comments}”)
第五部分：高级主题与进阶技巧
5.1 XPath 2.0/3.0 特性
虽然大多数浏览器和工具只支持XPath 1.0，但了解更高版本的特性有助于在支持的环境中使用。
XPath 2.0+ 新增功能：
序列处理
：更强大的节点集操作
类型系统
：支持更多数据类型
正则表达式
：
matches()
函数
条件表达式
：
if-then-else
用户自定义函数
示例（XPath 2.0+）：
# 注意：需要支持XPath 2.0的解析器，如Saxon

# XPath 2.0: 使用正则表达式
# //div[matches(@class, “^item-\d+$”)]

# XPath 2.0: 条件表达式
# //div[if (@featured) then @priority = “high” else @priority = “normal”]

# XPath 2.0: 序列操作
# (//div[@class=”item”])[1 to 5]
5.2 XPath与CSS选择器的对比与结合
对比：
特性
XPath
CSS选择器
文本提取
支持
不支持
逆向选择
支持（parent::）
不支持
复杂条件
强大
有限
性能
较慢
较快
学习曲线
陡峭
平缓
结合使用：
from selenium import webdriver
from selenium.webdriver.common.by import By

driver = webdriver.Chrome()

# 混合使用CSS和XPath
# 先用CSS定位，再用XPath筛选
container = driver.find_element(By.CSS_SELECTOR, “div#main”)
items = container.find_elements(By.XPATH, “.//li[contains(@class, ‘active’)]”)

# 或者反过来
items = driver.find_elements(By.CSS_SELECTOR, “li.active”)
# 然后用XPath提取属性
for item in items:
data_id = item.get_attribute(“data-id”) # CSS定位后提取属性
5.3 XPath在自动化测试中的应用
测试用例示例：
import unittest
from selenium import webdriver
from selenium.webdriver.common.by import By

class TestWebApp(unittest.TestCase):
def setUp(self):
self.driver = webdriver.Chrome()
self.driver.get(“https://example.com”)

def test_login_form(self):
# 使用XPath验证登录表单元素存在
username = self.driver.find_element(By.XPATH, “//input[@name=’username’]”)
password = self.driver.find_element(By.XPATH, “//input[@name=’password’]”)
submit = self.driver.find_element(By.XPATH, “//button[@type=’submit’]”)

# 验证元素属性
self.assertEqual(username.get_attribute(“placeholder”), “Enter username”)
self.assertEqual(submit.text, “Login”)

def test_navigation(self):
# 验证导航链接
nav_links = self.driver.find_elements(By.XPATH, “//nav//a”)
self.assertGreater(len(nav_links), 0)

# 验证特定链接文本
about_link = self.driver.find_element(By.XPATH, “//nav//a[contains(text(), ‘About’)]”)
self.assertTrue(about_link.is_displayed())

def tearDown(self):
self.driver.quit()

if __name__ == ‘__main__’:
unittest.main()
5.4 XPath在数据科学中的应用
数据清洗与提取：
import pandas as pd
from lxml import html
import requests

def extract_table_to_dataframe(url, table_xpath):
“””从HTML表格提取数据到Pandas DataFrame”””
response = requests.get(url)
tree = html.fromstring(response.content)

# 提取表头
headers = tree.xpath(f'{table_xpath}/thead/tr/th/text()’)

# 提取数据行
rows = tree.xpath(f'{table_xpath}/tbody/tr’)

data = []
for row in rows:
cells = row.xpath(‘./td/text()’)
data.append(cells)

return pd.DataFrame(data, columns=headers)

# 示例：提取股票数据
df = extract_table_to_dataframe(
“https://example.com/stocks”,
table_xpath=”//table[@id=’stock-table’]”
)
print(df.head())
第六部分：工具与资源推荐
6.1 XPath测试工具
浏览器开发者工具
：
Chrome DevTools Console:
$x(“//div[@class=’test’]”)
Firefox DevTools: 支持XPath测试
在线XPath测试器
：
XPath Tester
FreeFormatter XPath Tester
IDE插件
：
Visual Studio Code: XPath Notebook
PyCharm: XPath支持
6.2 推荐的Python库
lxml
：高性能XML/HTML解析器
pip install lxml
parsel
：Scrapy使用的解析库，支持XPath和CSS
pip install parsel
selenium
：浏览器自动化，支持XPath
pip install selenium
beautifulsoup4
：虽然主要使用CSS选择器，但可以通过lxml后端支持XPath
pip install beautifulsoup4
6.3 学习资源
官方文档
：
W3C XPath规范
MDN XPath文档
在线教程
：
XPath Tutorial
XPath at ZetCode
书籍推荐
：
《XPath 2.0 Programmer’s Reference》
《Web Scraping with Python》
第七部分：实战案例完整解析
案例：电商网站产品信息提取
需求：
从电商网站提取产品名称、价格、评分、库存状态等信息。
HTML结构示例：

Wireless Mouse

Featured

$29.99
$39.99

★★★★☆
(127 reviews)

In Stock

Mechanical Keyboard

$89.99

★★★★★
(89 reviews)

Low Stock

完整提取代码：
from lxml import html
import requests
import json
from typing import List, Dict

class ProductExtractor:
def __init__(self, html_content: str):
self.tree = html.fromstring(html_content)

def extract_all_products(self) -> List[Dict]:
“””提取所有产品信息”””
products = []

# 获取所有产品容器
product_elements = self.tree.xpath(‘//div[@class=”product-item”]’)

for product in product_elements:
# 提取产品ID
product_id = product.xpath(‘./@data-id’)[0]

# 提取产品名称
name = product.xpath(‘.//h3[@class=”product-name”]/text()’)[0]

# 提取当前价格（移除$符号）
current_price_text = product.xpath(‘.//span[@class=”current-price”]/text()’)[0]
current_price = float(current_price_text.replace(‘$’, ”))

# 提取原价（如果存在）
original_price = None
original_price_elements = product.xpath(‘.//span[@class=”original-price”]/text()’)
if original_price_elements:
original_price = float(original_price_elements[0].replace(‘$’, ”))

# 提取评分
stars = product.xpath(‘.//span[@class=”stars”]/text()’)[0]

# 提取评论数（移除括号）
review_count_text = product.xpath(‘.//span[@class=”count”]/text()’)[0]
review_count = int(review_count_text.strip(‘()’))

# 提取库存状态
stock_element = product.xpath(‘.//div[contains(@class, “stock”)]’)[0]
stock_status = stock_element.text.strip()
is_in_stock = ‘in-stock’ in stock_element.get(‘class’, ”)

# 提取是否为精选产品
is_featured = len(product.xpath(‘.//span[@class=”badge featured”]’)) > 0

product_data = {
‘id’: product_id,
‘name’: name,
‘current_price’: current_price,
‘original_price’: original_price,
‘discount’: round((original_price – current_price) / original_price * 100, 2) if original_price else 0,
‘rating’: stars,
‘review_count’: review_count,
‘stock_status’: stock_status,
‘is_in_stock’: is_in_stock,
‘is_featured’: is_featured
}

products.append(product_data)

return products

def extract_by_price_range(self, min_price: float, max_price: float) -> List[Dict]:
“””按价格范围筛选产品”””
all_products = self.extract_all_products()
return [p for p in all_products if min_price <= p['current_price'] <= max_price] def extract_featured_products(self) -> List[Dict]:
“””提取精选产品”””
all_products = self.extract_all_products()
return [p for p in all_products if p[‘is_featured’]]

# 使用示例
html_content = “””

Wireless Mouse

Featured

$29.99
$39.99

★★★★☆
(127 reviews)

In Stock

Mechanical Keyboard

$89.99

★★★★★
(89 reviews)

Low Stock

“””

extractor = ProductExtractor(html_content)

# 提取所有产品
all_products = extractor.extract_all_products()
print(“所有产品:”)
print(json.dumps(all_products, indent=2, ensure_ascii=False))

# 提取价格在$20-$50之间的产品
affordable_products = extractor.extract_by_price_range(20, 50)
print(“\n价格在$20-$50之间的产品:”)
print(json.dumps(affordable_products, indent=2, ensure_ascii=False))

# 提取精选产品
featured = extractor.extract_featured_products()
print(“\n精选产品:”)
print(json.dumps(featured, indent=2, ensure_ascii=False))
输出结果：
所有产品:
[
{
“id”: “1001”,
“name”: “Wireless Mouse”,
“current_price”: 29.99,
“original_price”: 39.99,
“discount”: 25.0,
“rating”: “★★★★☆”,
“review_count”: 127,
“stock_status”: “In Stock”,
“is_in_stock”: true,
“is_featured”: true
},
{
“id”: “1002”,
“name”: “Mechanical Keyboard”,
“current_price”: 89.99,
“original_price”: null,
“discount”: 0,
“rating”: “★★★★★”,
“review_count”: 89,
“stock_status”: “Low Stock”,
“is_in_stock”: false,
“is_featured”: false
}
]

价格在$20-$50之间的产品:
[
{
“id”: “1001”,
“name”: “Wireless Mouse”,
“current_price”: 29.99,
“original_price”: 39.99,
“discount”: 25.0,
“rating”: “★★★★☆”,
“review_count”: 127,
“stock_status”: “In Stock”,
“is_in_stock”: true,
“is_featured”: true
}
]

精选产品:
[
{
“id”: “1001”,
“name”: “Wireless Mouse”,
“current_price”: 29.99,
“original_price”: 39.99,
“discount”: 25.0,
“rating”: “★★★★☆”,
“review_count”: 127,
“stock_status”: “In Stock”,
“is_in_stock”: true,
“is_featured”: true
}
]
第八部分：调试与故障排除
8.1 XPath调试技巧
1. 使用浏览器控制台测试
// Chrome DevTools Console
$x(“//div[@class=’product-item’]”) // 返回匹配的元素数组
$x(“//div[@class=’product-item’]”)[0] // 返回第一个匹配元素
$x(“//div[@class=’product-item’]/h3/text()”) // 返回文本内容
2. Python调试代码
def debug_xpath(tree, xpath_expr):
“””调试XPath表达式”””
try:
result = tree.xpath(xpath_expr)
print(f”XPath: {xpath_expr}”)
print(f”结果数量: {len(result)}”)
if result:
print(f”第一个结果类型: {type(result[0])}”)
print(f”第一个结果: {result[0]}”)
return result
except Exception as e:
print(f”XPath错误: {xpath_expr}”)
print(f”错误信息: {e}”)
return []

# 使用示例
tree = html.fromstring(html_content)
debug_xpath(tree, ‘//div[@class=”product-item”]’)
8.2 常见错误代码及解决方案
错误类型
表现
解决方案
语法错误
XPathEvalError
检查括号匹配、引号闭合
命名空间错误
返回空结果
使用
local-name()
或注册命名空间
编码错误
UnicodeDecodeError
指定正确编码或使用
response.encoding
动态内容
返回空结果
使用Selenium等待元素加载
复杂表达式性能差
执行缓慢
简化表达式，增加具体路径
8.3 性能监控与优化
import time
from lxml import html

def benchmark_xpath(tree, xpath_expr, iterations=100):
“””基准测试XPath性能”””
start_time = time.time()

for _ in range(iterations):
tree.xpath(xpath_expr)

end_time = time.time()
avg_time = (end_time – start_time) / iterations

print(f”XPath: {xpath_expr}”)
print(f”平均执行时间: {avg_time:.6f} 秒”)
print(f”每秒执行次数: {1/avg_time:.0f}”)

return avg_time

# 测试不同表达式的性能
html_content = “

” + “

Item

” * 1000 + “

”
tree = html.fromstring(html_content)

# 慢表达式
benchmark_xpath(tree, ‘//p’) # 从根遍历所有节点

# 快表达式
benchmark_xpath(tree, ‘/div/p’) # 指定路径
第九部分：总结与最佳实践
9.1 XPath编写最佳实践
具体性优先
：使用最具体的路径
“`xpath
好
/html/body/div[@id=‘main’]/ul/li[@class=‘item’]
# 不好
//li
“`
避免过度使用
//
：除非必要，否则指定完整路径
使用有意义的属性
：优先使用id、class等稳定属性
测试表达式
：在浏览器控制台或工具中先测试
处理异常
：在代码中添加try-catch
文档化
：为复杂表达式添加注释
9.2 安全考虑
避免执行恶意代码
：不要从不可信来源获取XPath表达式
输入验证
：验证HTML内容，防止XSS攻击
速率限制
：爬虫场景下避免对目标网站造成压力
9.3 未来趋势
AI辅助XPath生成
：通过自然语言生成XPath
更强大的选择器
：如CSS选择器的扩展
WebAssembly支持
：在浏览器中更高效地处理XPath
结语
XPath是Web数据提取的利器，从简单的元素定位到复杂的数据提取，都能胜任。通过本文的系统学习，你应该能够：
掌握基础语法
：路径、谓词、轴和函数
运用高级技巧
：处理动态内容、复杂结构
解决常见问题
：调试、性能优化、异常处理
实践完整案例
：从简单到复杂的数据提取
记住，优秀的XPath表达式应该是
具体、高效、可维护
的。持续练习和实际项目应用是掌握XPath的关键。随着Web技术的不断发展，XPath也在进化，保持学习的热情，你将能够应对各种数据提取挑战。
延伸阅读建议
：
实践更多真实网站的数据提取
学习Scrapy框架中的XPath应用
探索XPath在API测试中的应用
了解XPath 3.1的新特性
祝你在XPath的学习和应用道路上取得成功！

---