如何用Python解析HTML（BeautifulSoup/lxml）？

夢幻星辰

发布时间：2025-09-05 22:44:02

847人浏览过

来源于php中文网

原创

答案是BeautifulSoup和lxml各有优势，适用于不同场景。BeautifulSoup容错性强、API直观，适合处理不规范HTML和快速开发；lxml基于C实现，解析速度快，适合处理大规模数据和高性能需求。两者可结合使用，兼顾易用性与性能。

如何用python解析html（beautifulsoup/lxml）？

用Python解析HTML，我们主要依赖像BeautifulSoup和lxml这样的库。它们能把杂乱无章的HTML文本结构化，变成我们方便操作的对象，无论是提取数据还是修改内容，都变得相对简单。选择哪个，往往取决于你的具体需求和对性能的考量。

解决方案

在我看来，掌握BeautifulSoup和lxml是Python处理HTML的基石。它们各有侧重，但都能高效地完成任务。

使用BeautifulSoup解析HTML

BeautifulSoup是一个非常人性化的库，它能从HTML或XML文件中提取数据。它的优点是容错性强，即使HTML结构不太规范也能很好地处理。

立即学习“Python免费学习笔记（深入）”；

安装：

pip install beautifulsoup4
pip install lxml # BeautifulSoup可以使用lxml作为解析器，通常推荐安装以提高性能

基本用法：

from bs4 import BeautifulSoup
import requests

# 假设我们有一个简单的HTML字符串
html_doc = """
我的测试页面

一些标题

这是一个故事。
Elsie,
Lacie 和
Tillie;
他们住在底部。

...

"""

# 使用lxml解析器创建BeautifulSoup对象
soup = BeautifulSoup(html_doc, 'lxml')

print("文档标题:", soup.title.string)

# 查找所有p标签
print("\n所有p标签:")
for p_tag in soup.find_all('p'):
    print(p_tag.get_text(strip=True)) # strip=True 可以去除多余的空白字符

# 查找所有class为sister的a标签
print("\n所有class为sister的链接:")
for link in soup.find_all('a', class_='sister'):
    print(f"文本: {link.get_text()}, URL: {link.get('href')}")

# 使用CSS选择器
print("\n使用CSS选择器查找所有a标签:")
for link in soup.select('a.sister'):
    print(f"文本: {link.get_text()}, URL: {link.get('href')}")

# 从网络获取内容并解析
try:
    response = requests.get('http://quotes.toscrape.com/') # 这是一个公开的爬虫练习网站
    response.raise_for_status() # 检查请求是否成功
    web_soup = BeautifulSoup(response.text, 'lxml')
    print("\n从网页获取的第一个作者名:", web_soup.find('small', class_='author').get_text())
except requests.exceptions.RequestException as e:
    print(f"请求失败: {e}")

使用lxml解析HTML

lxml是一个高性能的XML和HTML解析库，它基于C语言实现，所以速度非常快。它支持XPath和CSS选择器，对于需要处理大量数据或追求性能的场景非常适用。

安装：

pip install lxml

基本用法：

from lxml import html
import requests

html_doc = """
我的测试页面

一些标题

这是一个故事。
Elsie,
Lacie 和
Tillie;
他们住在底部。

...

"""

# 从字符串解析HTML
tree = html.fromstring(html_doc)

# 使用XPath查找标题
title_xpath = tree.xpath('//title/text()')
print("文档标题 (XPath):", title_xpath[0] if title_xpath else "未找到")

# 使用XPath查找所有p标签的文本
p_texts_xpath = tree.xpath('//p/text()')
# 注意：lxml的text()会返回标签内部的直接文本节点，不包含子标签的文本。
# 如果要获取包含子标签的完整文本，通常需要迭代或使用string()函数（在某些上下文中）
print("\n所有p标签的直接文本 (XPath):")
for text in p_texts_xpath:
    if text.strip(): # 过滤掉空白文本节点
        print(text.strip())

# 使用XPath查找所有class为sister的a标签的href属性和文本
print("\n所有class为sister的链接 (XPath):")
links_xpath = tree.xpath('//a[@class="sister"]')
for link in links_xpath:
    print(f"文本: {link.text}, URL: {link.get('href')}")

# 使用CSS选择器（lxml也支持）
print("\n所有class为sister的链接 (CSS选择器):")
links_css = tree.cssselect('a.sister')
for link in links_css:
    print(f"文本: {link.text}, URL: {link.get('href')}")

# 从网络获取内容并解析
try:
    response = requests.get('http://quotes.toscrape.com/')
    response.raise_for_status()
    web_tree = html.fromstring(response.text)
    # 使用XPath查找第一个作者名
    author_xpath = web_tree.xpath('//small[@class="author"]/text()')
    print("\n从网页获取的第一个作者名 (lxml XPath):", author_xpath[0] if author_xpath else "未找到")
except requests.exceptions.RequestException as e:
    print(f"请求失败: {e}")

BeautifulSoup与lxml在HTML解析中的性能差异及适用场景是什么？

这真的是一个老生常谈但又不得不提的问题。在我个人使用经验里，它们俩就像是跑车和SUV，各有各的用武之地。

性能差异： 毋庸置疑，lxml在性能上通常远超BeautifulSoup。lxml底层是C语言实现的，这意味着它在处理大量HTML文本时，解析速度会非常快，内存占用也相对更低。尤其是在需要爬取海量数据，或者解析的HTML文件本身就非常庞大时，lxml的优势就体现得淋漓尽致。我曾经在一个需要处理几十GB HTML数据的项目里，如果用BeautifulSoup，可能要等上好几个小时甚至更久，而lxml则能在短时间内完成。

BeautifulSoup则完全是Python实现，它的解析过程相对慢一些。但话说回来，对于大多数中小规模的爬虫任务，或者仅仅是解析几个页面，这种性能差异对用户体验来说几乎可以忽略不计。

适用场景：

BeautifulSoup：
- HTML质量不佳时： 这是BeautifulSoup的杀手锏。它对不规范、残缺的HTML有着惊人的容错能力。很多网站的HTML代码写得并不标准，标签闭合混乱，或者存在各种语法错误。lxml在面对这种“脏数据”时可能会报错，或者生成意想不到的解析树，而BeautifulSoup往往能“猜”出你的意图，并构建出一个相对合理的解析树。我个人觉得，如果你不确定目标网站的HTML质量，或者懒得去处理各种解析异常，BeautifulSoup是更省心的选择。
- 学习和快速原型开发： 它的API设计非常直观，上手快，文档也详细。对于初学者来说，BeautifulSoup的学习曲线更平缓，可以更快地写出可用的代码。
- 不追求极致性能的小型项目： 如果你的爬虫任务量不大，或者对解析速度没有严格要求，BeautifulSoup的易用性会让你更舒服。
lxml：
- 追求极致性能和效率： 当你需要处理海量数据，或者爬虫速度是核心指标时，lxml是你的不二之选。
- HTML结构相对规范时： lxml对HTML的解析更严格，如果目标网站的HTML代码质量较高，那么lxml能提供更准确、更可预测的解析结果。
- 熟悉XPath或CSS选择器： lxml对XPath和CSS选择器有原生且强大的支持，如果你习惯使用这些查询语言来定位元素，lxml能让你如鱼得水。我个人非常喜欢XPath的表达能力，特别是在处理复杂层级或特定属性的元素时，它比BeautifulSoup的
```
find_all
```
  组合要简洁得多。
- 与其他XML/HTML工具链集成： 如果你的项目需要与更多基于XML/HTML标准的工具进行交互，lxml作为标准兼容性更好的库，会是更自然的选择。

我的个人选择倾向： 通常，我会在项目初期或进行快速验证时，先用BeautifulSoup来摸索HTML结构，因为它更宽容。一旦确定了解析逻辑，并且发现性能是瓶颈时，我可能会考虑切换到lxml，或者更巧妙地，将BeautifulSoup与lxml的解析器结合使用（

BeautifulSoup(html_doc, 'lxml')

），这样既能享受到BeautifulSoup的API便利性，又能利用lxml的解析速度。这种混合模式，在我看来，是很多时候的“甜点”。

在Python中处理复杂或不规范HTML结构时有哪些常见挑战及应对策略？

处理HTML，尤其是那些“野路子”的网站，总会遇到一些让人挠头的问题。这就像是解谜，有时候你觉得找到了线索，结果发现是个陷阱。

1. HTML结构混乱或不规范：

挑战： 标签未闭合、嵌套错误、属性值缺失引号、随意插入注释或不规范的实体字符。这些问题会让解析器“懵圈”，导致解析树不符合预期，或者直接报错。
应对策略：
- 使用BeautifulSoup的容错性： 这是最直接的方法。BeautifulSoup在这方面表现出色，它会尝试修正这些错误，生成一个尽可能合理的解析树。我经常发现，一些在浏览器里看起来没问题的页面，用lxml直接解析会出问题，而BeautifulSoup就能搞定。
- 手动清理（预处理）： 在某些极端情况下，你可能需要在解析前对HTML字符串进行简单的正则替换或字符串操作，去除一些明显的干扰项，比如某些不必要的
  注释，或者修正一些明显的标签错误。但这种方法要小心，过度清理可能会破坏原有结构。
- 检查编码： HTML的编码问题常常是导致乱码或解析失败的隐形杀手。确保你用正确的编码（比如UTF-8）读取和解析HTML。
```
requests
```
  库通常能自动检测，但如果不行，你需要手动指定
```
response.encoding
```
  或在
```
BeautifulSoup
```
  构造函数中传入
```
from_encoding
```
  参数。

2. 动态加载内容（JavaScript渲染）：

Narration Box

Narration Box是一种语音生成服务，用户可以创建画外音、旁白、有声读物、音频页面、播客等

下载

挑战： 很多现代网站的内容并非直接包含在初始HTML中，而是通过JavaScript在页面加载后异步请求数据并渲染出来的。这意味着你通过
```
requests
```
库获取到的HTML可能只是一个骨架，真正的数据并不在里面。
应对策略：
- 检查网络请求： 在浏览器开发者工具（F12）的网络（Network）面板中观察页面加载过程。看看是否有XHR/Fetch请求返回了你需要的数据（通常是JSON格式）。如果是，直接模拟这些API请求通常比模拟浏览器渲染更高效。
- 使用无头浏览器： 如果数据确实是通过JavaScript复杂渲染出来的，那么
```
Selenium
```
  或
```
Playwright
```
  等无头浏览器是唯一的解决方案。它们能模拟真实浏览器行为，执行JavaScript，等待页面加载完成，然后你再从渲染后的页面中提取HTML进行解析。当然，这会显著增加爬取的速度和资源消耗。

3. 相对URL与绝对URL：

挑战： 页面中的链接、图片等资源往往使用相对URL（如
```
/images/logo.png
```
），直接提取出来无法访问。

应对策略：

结合基准URL： 在提取到相对URL后，你需要将其与页面的基准URL（通常是当前页面的URL）拼接成完整的绝对URL。Python的

urllib.parse.urljoin()

函数是处理这个问题的利器。

from urllib.parse import urljoin
base_url = "http://example.com/path/"
relative_url = "../images/logo.png"
absolute_url = urljoin(base_url, relative_url) # http://example.com/images/logo.png

4. 复杂的CSS选择器或XPath表达式：

挑战： 某些元素可能没有唯一的ID或class，或者被嵌套在多层复杂的结构中，导致很难用简单的选择器定位。
应对策略：
- 利用开发者工具： 浏览器开发者工具的“检查元素”功能非常强大。右键点击目标元素，选择“Copy” -> “Copy selector”或“Copy XPath”，可以快速获取到可用的选择器。虽然这些自动生成的选择器可能过于冗长，但它们是很好的起点。
- 组合多个属性： 不要只盯着ID或class。结合元素的标签名、
```
data-*
```
  属性、
```
aria-*
```
  属性，甚至父子关系、兄弟关系来构建更精确的选择器。
- XPath的强大： 在处理复杂层级或基于文本内容的定位时，XPath往往比CSS选择器更有优势。例如，
```
//div[contains(text(), '关键词')]
```
  可以查找包含特定文本的div。
- 迭代和调试： 我个人的经验是，先写一个宽泛的选择器，然后逐步细化，通过打印结果来验证。这比一次性写出完美的表达式要靠谱得多。

处理这些问题，没有银弹，更多的是经验和耐心。就像医生看病，先诊断，再对症下药。

除了基本的数据提取，BeautifulSoup和lxml还能实现哪些高级HTML操作？

除了我们最常用的数据提取，BeautifulSoup和lxml在HTML操作方面其实还有很多“隐藏技能”，能让你对HTML文档进行更深层次的控制。我个人觉得，这些高级操作在很多场景下都非常有用，比如数据清洗、文档转换甚至生成新的HTML。

1. 修改解析树：

这可能是最直接的高级操作了。你可以像操作Python列表或字典一样，增、删、改HTML文档中的元素和属性。

修改标签内容：

# BeautifulSoup
soup.p.string = "这是一个新的段落内容。" # 直接修改文本
# lxml
element = tree.xpath('//p[@class="title"]')[0]
element.text = "新的标题内容"

修改属性：

# BeautifulSoup
link = soup.find('a', id='link1')
link['href'] = 'http://new-example.com/new_link'
link['target'] = '_blank' # 添加新属性
del link['class'] # 删除属性
# lxml
element = tree.xpath('//a[@id="link1"]')[0]
element.set('href', 'http://new-example.com/new_link_lxml')
element.set('data-custom', 'value') # 添加新属性
del element.attrib['class'] # 删除属性

添加/删除元素：

# BeautifulSoup
new_tag = soup.new_tag("li")
new_tag.string = "新列表项"
soup.ul.append(new_tag) # 假设存在一个ul标签
soup.find('a', id='link3').decompose() # 删除元素及其所有子孙
# lxml
new_div = html.Element("div")
new_div.text = "这是新添加的div"
tree.body.append(new_div)
# 删除元素
element_to_remove = tree.xpath('//a[@id="link3"]')[0]
element_to_remove.getparent().remove(element_to_remove)

2. 创建新的HTML文档或片段：

你可以完全从零开始构建HTML结构，或者基于现有文档创建新的片段。这在需要生成报告、邮件模板或者动态HTML页面时非常有用。

# BeautifulSoup
new_soup = BeautifulSoup("", 'lxml')
new_div = new_soup.new_tag("div", id="container")
new_h1 = new_soup.new_tag("h1")
new_h1.string = "欢迎"
new_div.append(new_h1)
new_soup.body.append(new_div)
print(new_soup.prettify())

# lxml
root = html.Element("html")
head = html.SubElement(root, "head")
title = html.SubElement(head, "title")
title.text = "新文档"
body = html.SubElement(root, "body")
p = html.SubElement(body, "p")
p.text = "这是lxml创建的段落。"
print(html.tostring(root, pretty_print=True, encoding='unicode'))

3. 格式化输出（Pretty Printing）：

当你的HTML经过修改或生成后，通常会变得不那么美观。这两个库都提供了格式化输出的功能，让HTML代码更具可读性。

# BeautifulSoup
print(soup.prettify())

# lxml
print(html.tostring(tree, pretty_print=True, encoding='unicode'))

4. 文档遍历和导航：

除了

find_all

或XPath，它们还提供了更精细的遍历方法，比如访问父节点、兄弟节点、子节点等，这在处理复杂文档结构时非常有用。

# BeautifulSoup
# 获取父节点
print(soup.title.parent.name) # head
# 获取兄弟节点
link1 = soup.find('a', id='link1')
print(link1.next_sibling.next_sibling.name) # a (跳过文本节点)

# lxml
# 获取父节点
element = tree.xpath('//title')[0]
print(element.getparent().tag) # head
# 获取兄弟节点
element = tree.xpath('//a[@id="link1"]')[0]
print(element.getnext().tag) # a (直接获取下一个元素节点)

5. 错误处理与健壮性：

在实际项目中，我们总会遇到各种意想不到的HTML结构。编写健壮的代码至关重要。

检查元素是否存在： 在尝试访问元素的属性或内容之前，始终检查元素是否已被找到，避免

NoneType

错误。

# BeautifulSoup
element = soup.find('div', class_='non-existent')
if element:
    print(element.text)
else:
    print("元素未找到")

# lxml
elements = tree.xpath('//div[@class="non-existent"]')
if elements:
    print(elements[0].text)
else:
    print("元素未找到")