Python中使用XPath进行网页数据提取的实用示例教程与技巧分享让你轻松掌握XML和HTML解析方法及常见问题解决方案

威震华夏关云长

XPath基础概念与语法

XPath（XML Path Language）是一种在XML和HTML文档中查找信息的语言，它可以用来在文档中通过元素和属性进行导航。XPath最初设计用于XML文档，但由于HTML与XML的相似性，它同样适用于HTML文档的解析。

XPath基本语法

XPath使用路径表达式来选取XML文档中的节点或节点集。这些路径表达式看起来非常类似于我们在文件系统中使用的路径表达式。

下面是一些基本的XPath表达式：

• nodename：选取此节点的所有子节点
• /：从根节点选取
• //：从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置
• .：选取当前节点
• ..：选取当前节点的父节点
• @：选取属性

XPath谓语（Predicates）

谓语用来查找某个特定的节点或者包含某个指定值的节点，它们被嵌在方括号中。

• /bookstore/book[1]：选取属于bookstore子元素的第一个book元素
• /bookstore/book[last()]：选取属于bookstore子元素的最后一个book元素
• /bookstore/book[price>35.00]：选取bookstore元素的所有book元素，且其中的price元素的值须大于35.00

XPath通配符

• *：匹配任何元素节点
• @*：匹配任何属性节点
• node()：匹配任何类型的节点

Python中处理XPath的库

在Python中，有几个库可以用来处理XPath，其中最常用的是lxml。此外，xml.etree.ElementTree也是Python标准库中处理XML的工具，但它的XPath支持相对有限。

安装lxml库

在使用lxml之前，我们需要先安装它：

2. pip install lxml

复制代码

lxml库的基本使用

lxml库提供了两个主要的类来处理HTML和XML文档：lxml.html和lxml.etree。

2. from lxml import html
3. import requests
5. # 获取网页内容
6. url = "https://example.com"
7. response = requests.get(url)
8. tree = html.fromstring(response.content)
10. # 使用XPath提取数据
11. title = tree.xpath('//title/text()')
12. print(title)  # 输出网页标题

复制代码

从HTML中提取数据的实用示例

让我们通过一些实际的例子来学习如何使用XPath从HTML中提取数据。

示例1：提取网页标题和链接

2. from lxml import html
3. import requests
5. # 获取网页内容
6. url = "https://news.ycombinator.com"
7. response = requests.get(url)
8. tree = html.fromstring(response.content)
10. # 提取所有新闻标题
11. titles = tree.xpath('//tr[@class="athing"]/td[3]/a/text()')
12. # 提取所有新闻链接
13. links = tree.xpath('//tr[@class="athing"]/td[3]/a/@href')
15. # 打印结果
16. for title, link in zip(titles, links):
17.     print(f"标题: {title}")
18.     print(f"链接: {link}\n")

复制代码

示例2：提取表格数据

假设我们有一个包含员工信息的HTML表格，我们需要提取所有员工的信息：

2. from lxml import html
4. # 假设的HTML表格数据
5. html_content = """
6. <table id="employees">
7.     <tr>
8.         <th>Name</th>
9.         <th>Position</th>
10.         <th>Salary</th>
11.     </tr>
12.     <tr>
13.         <td>John Doe</td>
14.         <td>Software Engineer</td>
15.         <td>$95,000</td>
16.     </tr>
17.     <tr>
18.         <td>Jane Smith</td>
19.         <td>Project Manager</td>
20.         <td>$105,000</td>
21.     </tr>
22.     <tr>
23.         <td>Mike Johnson</td>
24.         <td>Data Analyst</td>
25.         <td>$85,000</td>
26.     </tr>
27. </table>
28. """
30. tree = html.fromstring(html_content)
32. # 提取所有行（除标题行）
33. rows = tree.xpath('//table[@id="employees"]/tr[position()>1]')
35. for row in rows:
36.     name = row.xpath('./td[1]/text()')[0]
37.     position = row.xpath('./td[2]/text()')[0]
38.     salary = row.xpath('./td[3]/text()')[0]
39.     print(f"姓名: {name}, 职位: {position}, 薪资: {salary}")

复制代码

示例3：提取嵌套数据

有时候我们需要提取嵌套在多层元素中的数据：

2. from lxml import html
4. # 假设的HTML内容
5. html_content = """
6. <div class="products">
7.     <div class="product">
8.         <h2 class="product-name">Laptop</h2>
9.         <div class="product-details">
10.             <span class="price">$999.99</span>
11.             <span class="rating">4.5</span>
12.         </div>
13.         <div class="description">
14.             <p>A powerful laptop for professionals.</p>
15.         </div>
16.     </div>
17.     <div class="product">
18.         <h2 class="product-name">Smartphone</h2>
19.         <div class="product-details">
20.             <span class="price">$699.99</span>
21.             <span class="rating">4.2</span>
22.         </div>
23.         <div class="description">
24.             <p>Latest smartphone with advanced features.</p>
25.         </div>
26.     </div>
27. </div>
28. """
30. tree = html.fromstring(html_content)
32. # 提取所有产品
33. products = tree.xpath('//div[@class="product"]')
35. for product in products:
36.     name = product.xpath('.//h2[@class="product-name"]/text()')[0]
37.     price = product.xpath('.//span[@class="price"]/text()')[0]
38.     rating = product.xpath('.//span[@class="rating"]/text()')[0]
39.     description = product.xpath('.//div[@class="description"]/p/text()')[0]
40.    
41.     print(f"产品名称: {name}")
42.     print(f"价格: {price}")
43.     print(f"评分: {rating}")
44.     print(f"描述: {description}\n")

复制代码

从XML中提取数据的实用示例

XML（eXtensible Markup Language）是一种标记语言，设计用来传输和存储数据。XPath同样适用于XML文档的数据提取。

示例1：提取XML元素和属性

2. from lxml import etree
4. # 假设的XML内容
5. xml_content = """
6. <bookstore>
7.     <book category="COOKING">
8.         <title lang="en">Everyday Italian</title>
9.         <author>Giada De Laurentiis</author>
10.         <year>2005</year>
11.         <price>30.00</price>
12.     </book>
13.     <book category="CHILDREN">
14.         <title lang="en">Harry Potter</title>
15.         <author>J.K. Rowling</author>
16.         <year>2005</year>
17.         <price>29.99</price>
18.     </book>
19.     <book category="WEB">
20.         <title lang="en">Learning XML</title>
21.         <author>Erik T. Ray</author>
22.         <year>2003</year>
23.         <price>39.95</price>
24.     </book>
25. </bookstore>
26. """
28. # 解析XML内容
29. tree = etree.fromstring(xml_content)
31. # 提取所有书籍的标题
32. titles = tree.xpath('//book/title/text()')
33. print("所有书籍标题:", titles)
35. # 提取category属性为"WEB"的书籍
36. web_books = tree.xpath('//book[@category="WEB"]')
37. for book in web_books:
38.     title = book.xpath('./title/text()')[0]
39.     author = book.xpath('./author/text()')[0]
40.     print(f"WEB类书籍 - 标题: {title}, 作者: {author}")
42. # 提取lang属性为"en"的所有标题
43. english_titles = tree.xpath('//title[@lang="en"]/text()')
44. print("英文标题:", english_titles)

复制代码

示例2：处理命名空间

在处理带有命名空间的XML文档时，我们需要特别处理：

2. from lxml import etree
4. # 带有命名空间的XML内容
5. xml_content = """
6. <root xmlns:ns="http://example.com/ns">
7.     <ns:person>
8.         <ns:name>John Doe</ns:name>
9.         <ns:age>30</ns:age>
10.         <ns:address>
11.             <ns:street>123 Main St</ns:street>
12.             <ns:city>New York</ns:city>
13.         </ns:address>
14.     </ns:person>
15.     <ns:person>
16.         <ns:name>Jane Smith</ns:name>
17.         <ns:age>25</ns:age>
18.         <ns:address>
19.             <ns:street>456 Oak Ave</ns:street>
20.             <ns:city>Los Angeles</ns:city>
21.         </ns:address>
22.     </ns:person>
23. </root>
24. """
26. # 解析XML内容
27. tree = etree.fromstring(xml_content)
29. # 定义命名空间
30. namespaces = {'ns': 'http://example.com/ns'}
32. # 提取所有人员姓名
33. names = tree.xpath('//ns:name/text()', namespaces=namespaces)
34. print("所有人员姓名:", names)
36. # 提取第一个人员的地址
37. first_person_address = tree.xpath('//ns:person[1]/ns:address', namespaces=namespaces)[0]
38. street = first_person_address.xpath('./ns:street/text()', namespaces=namespaces)[0]
39. city = first_person_address.xpath('./ns:city/text()', namespaces=namespaces)[0]
40. print(f"第一个人员的地址: {street}, {city}")

复制代码

高级XPath技巧

使用XPath函数

XPath提供了许多内置函数，可以帮助我们更灵活地处理数据：

2. from lxml import html
4. # 假设的HTML内容
5. html_content = """
6. <div class="products">
7.     <div class="product" data-id="101">
8.         <h2>Laptop</h2>
9.         <span class="price">$999.99</span>
10.     </div>
11.     <div class="product" data-id="102">
12.         <h2>Smartphone</h2>
13.         <span class="price">$699.99</span>
14.     </div>
15.     <div class="product" data-id="103">
16.         <h2>Tablet</h2>
17.         <span class="price">$399.99</span>
18.     </div>
19. </div>
20. """
22. tree = html.fromstring(html_content)
24. # 使用contains函数查找包含特定文本的元素
25. laptop_element = tree.xpath('//h2[contains(text(), "Lap")]')
26. print("包含'Lap'的标题:", laptop_element[0].text)
28. # 使用starts-with函数查找属性以特定值开头的元素
29. products_with_data_id = tree.xpath('//div[starts-with(@data-id, "10")]')
30. print(f"找到 {len(products_with_data_id)} 个data-id以'10'开头的产品")
32. # 使用string-length函数查找文本长度大于特定值的元素
33. long_titles = tree.xpath('//h2[string-length(text()) > 6]')
34. print(f"找到 {len(long_titles)} 个标题长度大于6的产品")
36. # 使用position函数选取特定位置的元素
37. second_product = tree.xpath('//div[@class="product"][position()=2]')
38. print("第二个产品的名称:", second_product[0].xpath('./h2/text()')[0])

复制代码

使用XPath轴（Axes）

XPath轴提供了相对于当前节点的节点集：

2. from lxml import html
4. # 假设的HTML内容
5. html_content = """
6. <div class="content">
7.     <h1>Main Title</h1>
8.     <p>Introduction paragraph.</p>
9.     <div class="section">
10.         <h2>Section 1</h2>
11.         <p>Paragraph in section 1.</p>
12.     </div>
13.     <div class="section">
14.         <h2>Section 2</h2>
15.         <p>Paragraph in section 2.</p>
16.     </div>
17.     <p>Conclusion paragraph.</p>
18. </div>
19. """
21. tree = html.fromstring(html_content)
23. # 使用ancestor轴选取祖先元素
24. section_1 = tree.xpath('//h2[text()="Section 1"]')[0]
25. content_div = section_1.xpath('./ancestor::div[@class="content"]')
26. print("Section 1的祖先content元素:", content_div[0].tag)
28. # 使用following-sibling轴选取后续兄弟元素
29. section_1 = tree.xpath('//h2[text()="Section 1"]')[0]
30. next_section = section_1.xpath('./following-sibling::div[@class="section"]')
31. if next_section:
32.     print("Section 1后的下一个section的标题:", next_section[0].xpath('./h2/text()')[0])
34. # using preceding-sibling axis to select preceding sibling elements
35. section_2 = tree.xpath('//h2[text()="Section 2"]')[0]
36. prev_section = section_2.xpath('./preceding-sibling::div[@class="section"]')
37. if prev_section:
38.     print("Section 2前的上一个section的标题:", prev_section[0].xpath('./h2/text()')[0])
40. # using descendant axis to select all descendants
41. content = tree.xpath('//div[@class="content"]')[0]
42. all_paragraphs = content.xpath('./descendant::p')
43. print(f"Content元素中的所有段落数量: {len(all_paragraphs)}")

复制代码

常见问题及解决方案

问题1：XPath表达式返回空列表

问题描述：XPath表达式没有返回任何结果，即使你确定文档中存在匹配的元素。

可能原因及解决方案：

1. 命名空间问题：如果XML文档使用了命名空间，你需要在XPath表达式中指定命名空间。

2. from lxml import etree
4. xml_content = """
5. <root xmlns="http://example.com">
6.     <item>Example item</item>
7. </root>
8. """
10. tree = etree.fromstring(xml_content)
12. # 错误的方式 - 没有考虑命名空间
13. items = tree.xpath('//item')
14. print(f"找到的项目数（错误方式）: {len(items)}")  # 输出: 0
16. # 正确的方式 - 考虑命名空间
17. namespaces = {'default': 'http://example.com'}
18. items = tree.xpath('//default:item', namespaces=namespaces)
19. print(f"找到的项目数（正确方式）: {len(items)}")  # 输出: 1

复制代码

1. HTML结构问题：有时候网页的实际结构与你在浏览器中看到的不同，可能是因为JavaScript动态修改了DOM。

2. from lxml import html
3. import requests
5. url = "https://example.com"
6. response = requests.get(url)
7. tree = html.fromstring(response.content)
9. # 检查实际加载的HTML
10. # print(etree.tostring(tree, encoding='unicode'))
12. # 尝试更通用的XPath表达式
13. # 例如，如果原来的表达式是 '//div[@class="content"]/p[1]'
14. # 可以尝试更通用的表达式 '//p'

复制代码

1. XPath表达式错误：检查XPath表达式是否有语法错误。

2. from lxml import html
4. html_content = """
5. <div>
6.     <p>Paragraph 1</p>
7.     <p>Paragraph 2</p>
8. </div>
9. """
11. tree = html.fromstring(html_content)
13. # 错误的XPath表达式
14. try:
15.     paragraphs = tree.xpath('//div[')  # 语法错误
16. except etree.XPathEvalError as e:
17.     print(f"XPath表达式错误: {e}")
19. # 正确的XPath表达式
20. paragraphs = tree.xpath('//div/p')
21. print(f"找到的段落数: {len(paragraphs)}")

复制代码

问题2：处理动态加载的内容

问题描述：网页内容是通过JavaScript动态加载的，直接请求URL获取的HTML中不包含所需数据。

解决方案：使用Selenium或Playwright等工具模拟浏览器行为，获取JavaScript渲染后的HTML。

2. from selenium import webdriver
3. from selenium.webdriver.common.by import By
4. from lxml import html
5. import time
7. # 设置Selenium WebDriver
8. driver = webdriver.Chrome()  # 确保已安装ChromeDriver
10. # 访问网页
11. url = "https://example.com"  # 替换为实际URL
12. driver.get(url)
14. # 等待JavaScript加载完成
15. time.sleep(3)  # 简单等待，实际应用中应使用显式等待
17. # 获取渲染后的HTML
18. html_content = driver.page_source
20. # 使用lxml解析HTML
21. tree = html.fromstring(html_content)
23. # 使用XPath提取数据
24. data = tree.xpath('//div[@class="dynamic-content"]/text()')
25. print("动态加载的内容:", data)
27. # 关闭浏览器
28. driver.quit()

复制代码

问题3：处理大型XML/HTML文件

问题描述：当处理大型XML或HTML文件时，内存使用量过高，导致性能问题。

解决方案：使用lxml的迭代解析功能，避免一次性加载整个文档。

2. from lxml import etree
4. # 大型XML文件示例
5. large_xml_content = """
6. <root>
7.     <item id="1">Item 1</item>
8.     <item id="2">Item 2</item>
9.     <!-- 假设有成千上万个item元素 -->
10.     <item id="9999">Item 9999</item>
11. </root>
12. """
14. # 将XML内容写入文件（模拟大型XML文件）
15. with open('large_file.xml', 'w') as f:
16.     f.write(large_xml_content)
18. # 使用迭代解析处理大型XML文件
19. context = etree.iterparse('large_file.xml', events=('end',), tag='item')
21. for event, elem in context:
22.     # 处理每个item元素
23.     item_id = elem.get('id')
24.     item_text = elem.text
25.     print(f"处理项目: ID={item_id}, Text={item_text}")
26.    
27.     # 清理已处理的元素以节省内存
28.     elem.clear()
29.     while elem.getprevious() is not None:
30.         del elem.getparent()[0]
32. # 删除临时文件
33. import os
34. os.remove('large_file.xml')

复制代码

问题4：XPath表达式过于复杂

问题描述：XPath表达式变得非常复杂，难以理解和维护。

解决方案：将复杂的XPath表达式分解为多个简单的表达式，或者使用Python代码进行进一步处理。

2. from lxml import html
4. html_content = """
5. <div class="products">
6.     <div class="product" data-category="electronics">
7.         <h2>Laptop</h2>
8.         <div class="details">
9.             <span class="price">$999.99</span>
10.             <span class="rating">4.5</span>
11.         </div>
12.     </div>
13.     <div class="product" data-category="electronics">
14.         <h2>Smartphone</h2>
15.         <div class="details">
16.             <span class="price">$699.99</span>
17.             <span class="rating">4.2</span>
18.         </div>
19.     </div>
20.     <div class="product" data-category="home">
21.         <h2>Blender</h2>
22.         <div class="details">
23.             <span class="price">$49.99</span>
24.             <span class="rating">4.0</span>
25.         </div>
26.     </div>
27. </div>
28. """
30. tree = html.fromstring(html_content)
32. # 复杂的XPath表达式（不推荐）
33. complex_xpath = '//div[@class="product" and @data-category="electronics"]/div[@class="details"]/span[@class="price" and number(translate(text(), "$", "")) > 700]/text()'
34. expensive_electronics = tree.xpath(complex_xpath)
35. print("昂贵的电子产品价格（复杂XPath）:", expensive_electronics)
37. # 分解为简单的XPath表达式（推荐）
38. # 1. 获取所有电子产品
39. electronics = tree.xpath('//div[@class="product" and @data-category="electronics"]')
40. expensive_prices = []
42. # 2. 遍历每个电子产品，检查价格
43. for product in electronics:
44.     price_text = product.xpath('.//span[@class="price"]/text()')[0]
45.     price = float(price_text.replace('$', ''))
46.     if price > 700:
47.         expensive_prices.append(price_text)
49. print("昂贵的电子产品价格（分解XPath）:", expensive_prices)

复制代码

最佳实践和性能优化

1. 使用绝对路径与相对路径

在可能的情况下，优先使用相对路径（以//开头）而不是绝对路径（以/开头），因为相对路径更加灵活，对文档结构的变化不那么敏感。

2. from lxml import html
4. html_content = """
5. <html>
6.     <body>
7.         <div class="content">
8.             <div class="section">
9.                 <p>Paragraph 1</p>
10.             </div>
11.         </div>
12.     </body>
13. </html>
14. """
16. tree = html.fromstring(html_content)
18. # 绝对路径 - 如果文档结构稍有变化就会失效
19. paragraph_abs = tree.xpath('/html/body/div/div/p/text()')
21. # 相对路径 - 更加灵活
22. paragraph_rel = tree.xpath('//p/text()')
24. print("绝对路径结果:", paragraph_abs)
25. print("相对路径结果:", paragraph_rel)

复制代码

2. 缓存解析结果

如果需要多次使用同一组XPath查询结果，最好将其缓存到变量中，而不是重复执行XPath查询。

2. from lxml import html
4. html_content = """
5. <div class="products">
6.     <div class="product">
7.         <h2>Product 1</h2>
8.         <span class="price">$10.00</span>
9.     </div>
10.     <div class="product">
11.         <h2>Product 2</h2>
12.         <span class="price">$20.00</span>
13.     </div>
14. </div>
15. """
17. tree = html.fromstring(html_content)
19. # 不好的方式 - 重复查询
20. for i in range(3):
21.     products = tree.xpath('//div[@class="product"]')
22.     print(f"第{i+1}次查询，找到{len(products)}个产品")
24. # 好的方式 - 缓存结果
25. products = tree.xpath('//div[@class="product"]')
26. for i in range(3):
27.     print(f"第{i+1}次使用缓存，找到{len(products)}个产品")

复制代码

3. 使用更具体的XPath表达式

尽量使用更具体的XPath表达式，以减少不必要的搜索和提高性能。

2. from lxml import html
4. html_content = """
5. <div class="content">
6.     <div class="section">
7.         <p>Paragraph in section</p>
8.     </div>
9.     <div class="footer">
10.         <p>Paragraph in footer</p>
11.     </div>
12. </div>
13. """
15. tree = html.fromstring(html_content)
17. # 不够具体的XPath表达式
18. all_paragraphs = tree.xpath('//p/text()')
19. print("所有段落:", all_paragraphs)
21. # 更具体的XPath表达式
22. section_paragraphs = tree.xpath('//div[@class="section"]/p/text()')
23. print("Section中的段落:", section_paragraphs)

复制代码

4. 使用CSS选择器作为替代

在某些情况下，CSS选择器可能比XPath更简洁易读。lxml库支持CSS选择器。

2. from lxml import html
4. html_content = """
5. <div class="products">
6.     <div class="product featured">
7.         <h2>Product 1</h2>
8.         <span class="price">$10.00</span>
9.     </div>
10.     <div class="product">
11.         <h2>Product 2</h2>
12.         <span class="price">$20.00</span>
13.     </div>
14. </div>
15. """
17. tree = html.fromstring(html_content)
19. # 使用XPath
20. featured_products_xpath = tree.xpath('//div[contains(@class, "product") and contains(@class, "featured")]')
21. print("使用XPath找到的特色产品数:", len(featured_products_xpath))
23. # 使用CSS选择器
24. featured_products_css = tree.cssselect('div.product.featured')
25. print("使用CSS选择器找到的特色产品数:", len(featured_products_css))

复制代码

实战案例：构建一个简单的网页爬虫

让我们结合所学知识，构建一个简单的网页爬虫，从新闻网站提取新闻标题和链接。

2. import requests
3. from lxml import html
4. import csv
5. import time
7. def scrape_news(url, output_file):
8.     """
9.     从新闻网站爬取新闻标题和链接，并保存到CSV文件
10.    
11.     参数:
12.         url (str): 新闻网站的URL
13.         output_file (str): 输出CSV文件的路径
14.     """
15.     # 发送HTTP请求
16.     headers = {
17.         'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
18.     }
19.    
20.     try:
21.         response = requests.get(url, headers=headers)
22.         response.raise_for_status()  # 如果请求失败，抛出异常
23.         
24.         # 解析HTML内容
25.         tree = html.fromstring(response.content)
26.         
27.         # 提取新闻标题和链接
28.         # 注意：以下XPath表达式需要根据实际网站结构调整
29.         titles = tree.xpath('//h2[@class="title"]/a/text()')
30.         links = tree.xpath('//h2[@class="title"]/a/@href')
31.         
32.         # 确保标题和链接数量匹配
33.         if len(titles) != len(links):
34.             print("警告：标题和链接数量不匹配")
35.             min_length = min(len(titles), len(links))
36.             titles = titles[:min_length]
37.             links = links[:min_length]
38.         
39.         # 将数据保存到CSV文件
40.         with open(output_file, 'w', newline='', encoding='utf-8') as csvfile:
41.             writer = csv.writer(csvfile)
42.             writer.writerow(['Title', 'Link'])  # 写入标题行
43.             
44.             for title, link in zip(titles, links):
45.                 writer.writerow([title.strip(), link.strip()])
46.         
47.         print(f"成功爬取 {len(titles)} 条新闻，并保存到 {output_file}")
48.         
49.     except requests.exceptions.RequestException as e:
50.         print(f"请求错误: {e}")
51.     except Exception as e:
52.         print(f"发生错误: {e}")
54. # 使用示例
55. if __name__ == "__main__":
56.     news_url = "https://news.ycombinator.com"  # 替换为实际新闻网站URL
57.     output_csv = "news_data.csv"
58.    
59.     scrape_news(news_url, output_csv)
60.    
61.     # 添加延迟，避免过于频繁的请求
62.     time.sleep(1)

复制代码

总结

XPath是一种强大的查询语言，用于在XML和HTML文档中查找和提取数据。在Python中，lxml库提供了对XPath的完整支持，使我们能够高效地解析和提取网页数据。

本文介绍了XPath的基础语法、Python中使用lxml库处理XPath的方法、从HTML和XML中提取数据的实用示例、高级XPath技巧、常见问题及解决方案，以及最佳实践和性能优化建议。通过这些知识，你应该能够轻松掌握使用XPath进行网页数据提取的技能。

记住，实践是最好的学习方式。尝试使用XPath解析你感兴趣的网站，处理不同的数据结构，解决遇到的问题，这样你将更加熟练地掌握XPath的使用。