脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Python - Python下利用BeautifulSoup解析HTML的实现

Python下利用BeautifulSoup解析HTML的实现

2020-04-18 10:55东凌阁 Python

这篇文章主要介绍了Python下利用BeautifulSoup解析HTML的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

摘要

Beautiful Soup 是一个可以从 HTML 或 XML 格式文件中提取数据的 Python 库，他可以将HTML 或 XML 数据解析为Python 对象，以方便通过Python代码进行处理。

文档环境

  • Centos7.5
  • Python2.7
  • BeautifulSoup4

Beautifu Soup 使用说明

Beautiful Soup 的基本功能就是对HTML的标签进行查找及编辑。

基本概念-对象类型

Beautiful Soup 将复杂 HTML 文档转换成一个复杂的树形结构，每个节点都被转换成一个Python 对象，Beautiful Soup将这些对象定义了4 种类型: Tag、NavigableString、BeautifulSoup、Comment 。

 

对象类型 描述
BeautifulSoup 文档的全部内容
Tag HTML的标签
NavigableString 标签包含的文字
Comment 是一种特殊的NavigableString类型，当标签中的NavigableString 被注释时，则定义为该类型

 

安装及引用

?
1
2
3
4
5
6
# Beautiful Soup
pip install bs4
 
# 解析器
pip install lxml
pip install html5lib
?
1
2
3
4
5
6
7
8
9
10
11
12
# 初始化
from bs4 import BeautifulSoup
 
# 方法一，直接打开文件
soup = BeautifulSoup(open("index.html"))
 
# 方法二，指定数据
resp = "<html>data</html>"
soup = BeautifulSoup(resp, 'lxml')
 
# soup 为 BeautifulSoup 类型对象
print(type(soup))

标签搜索及过滤

基本方法

标签搜索有find_all() 和find() 两个基本的搜索方法，find_all() 方法会返回所有匹配关键字的标签列表，find()方法则只返回一个匹配结果。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
soup = BeautifulSoup(resp, 'lxml')
 
# 返回一个标签名为"a"的Tag
soup.find("a")
 
# 返回所有tag 列表
soup.find_all("a")
 
## find_all方法可被简写
soup("a")
 
#找出所有以b开头的标签
for tag in soup.find_all(re.compile("^b")):
  print(tag.name)
 
#找出列表中的所有标签
soup.find_all(["a", "p"])
 
# 查找标签名为p，class属性为"title"
soup.find_all("p", "title")
 
# 查找属性id为"link2"
soup.find_all(id="link2")
 
# 查找存在属性id的
soup.find_all(id=True)
 
#
soup.find_all(href=re.compile("elsie"), id='link1')
 
#
soup.find_all(attrs={"data-foo": "value"})
 
#查找标签文字包含"sisters"
soup.find(string=re.compile("sisters"))
 
# 获取指定数量的结果
soup.find_all("a", limit=2)
 
# 自定义匹配方法
def has_class_but_no_id(tag):
  return tag.has_attr('class') and not tag.has_attr('id')
soup.find_all(has_class_but_no_id)
 
# 仅对属性使用自定义匹配方法
def not_lacie(href):
    return href and not re.compile("lacie").search(href)
soup.find_all(href=not_lacie)
 
# 调用tag的 find_all() 方法时,Beautiful Soup会检索当前tag的所有子孙节点,如果只想搜索tag的直接子节点,可以使用参数 recursive=False
 
soup.find_all("title", recursive=False)

扩展方法

 

ind_parents() 所有父辈节点
find_parent() 第一个父辈节点
find_next_siblings() 之后的所有兄弟节点
find_next_sibling() 之后的第一个兄弟节点
find_previous_siblings() 之前的所有兄弟节点
find_previous_sibling() 之前的第一个兄弟节点
find_all_next() 之后的所有元素
find_next() 之后的第一个元素
find_all_previous() 之前的所有元素
find_previous() 之前的第一个元素

 

CSS选择器

Beautiful Soup支持大部分的CSS选择器 http://www.w3.org/TR/CSS2/selector.html, 在 Tag 或 BeautifulSoup 对象的 .select() 方法中传入字符串参数, 即可使用CSS选择器的语法找到tag。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
html_doc = """
<html>
<head>
 <title>The Dormouse's story</title>
</head>
<body>
 <p class="title"><b>The Dormouse's story</b></p>
 
 <p class="story">
  Once upon a time there were three little sisters; and their names were
  <a href="http://example.com/elsie" rel="external nofollow" class="sister" id="link1">Elsie</a>,
  <a href="http://example.com/lacie" rel="external nofollow" class="sister" id="link2">Lacie</a>
  and
  <a href="http://example.com/tillie" rel="external nofollow" class="sister" id="link3">Tillie</a>;
  and they lived at the bottom of a well.
 </p>
 
 <p class="story">...</p>
"""
 
soup = BeautifulSoup(html_doc)
 
# 所有 a 标签
soup.select("a")
 
# 逐层查找
soup.select("body a")
soup.select("html head title")
 
# tag标签下的直接子标签
soup.select("head > title")
soup.select("p > #link1")
 
# 所有匹配标签之后的兄弟标签
soup.select("#link1 ~ .sister")
 
# 匹配标签之后的第一个兄弟标签
soup.select("#link1 + .sister")
 
# 根据calss类名
soup.select(".sister")
soup.select("[class~=sister]")
 
# 根据ID查找
soup.select("#link1")
soup.select("a#link1")
 
# 根据多个ID查找
soup.select("#link1,#link2")
 
# 根据属性查找
soup.select('a[href]')
 
# 根据属性值查找
soup.select('a[href^="http://example.com/"]')
soup.select('a[href$="tillie"]')
soup.select('a[href*=".com/el"]')
 
# 只获取一个匹配结果
soup.select(".sister", limit=1)
 
# 只获取一个匹配结果
soup.select_one(".sister")

标签对象方法

标签属性

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
soup = BeautifulSoup('<p class="body strikeout" id="1">Extremely bold</p><p class="body strikeout" id="2">Extremely bold2</p>')
# 获取所有的 p标签对象
tags = soup.find_all("p")
# 获取第一个p标签对象
tag = soup.p
# 输出标签类型
type(tag)
# 标签名
tag.name
# 标签属性
tag.attrs
# 标签属性class 的值
tag['class']
# 标签包含的文字内容，对象NavigableString 的内容
tag.string
 
# 返回标签内所有的文字内容
for string in tag.strings:
  print(repr(string))
 
# 返回标签内所有的文字内容, 并去掉空行
for string in tag.stripped_strings:
  print(repr(string))
 
# 获取到tag中包含的所有及包括子孙tag中的NavigableString内容，并以Unicode字符串格式输出
tag.get_text()
## 以"|"分隔
tag.get_text("|")
## 以"|"分隔，不输出空字符
tag.get_text("|", strip=True)
获取子节点
tag.contents # 返回第一层子节点的列表
tag.children # 返回第一层子节点的listiterator 对象
for child in tag.children:
  print(child)
 
tag.descendants # 递归返回所有子节点
for child in tag.descendants:
  print(child)

获取父节点

?
1
2
3
4
5
6
7
8
tag.parent # 返回第一层父节点标签
tag.parents # 递归得到元素的所有父辈节点
 
for parent in tag.parents:
  if parent is None:
    print(parent)
  else:
    print(parent.name)

获取兄弟节点

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 下一个兄弟元素
tag.next_sibling
 
# 当前标签之后的所有兄弟元素
tag.next_siblings
for sibling in tag.next_siblings:
  print(repr(sibling))
 
# 上一个兄弟元素
tag.previous_sibling
 
# 当前标签之前的所有兄弟元素
tag.previous_siblings
for sibling in tag.previous_siblings:
  print(repr(sibling))

元素的遍历

Beautiful Soup中把每个tag定义为一个“element”，每个“element”，被自上而下的在HTML中排列，可以通过遍历命令逐个显示标签

?
1
2
3
4
5
6
7
8
9
10
11
12
# 当前标签的下一个元素
tag.next_element
 
# 当前标签之后的所有元素
for element in tag.next_elements:
  print(repr(element))
 
# 当前标签的前一个元素
tag.previous_element
# 当前标签之前的所有元素
for element in tag.previous_elements:
  print(repr(element))

修改标签属性

?
1
2
3
4
5
6
7
8
9
soup = BeautifulSoup('<b class="boldest">Extremely bold</b>')
tag = soup.b
 
tag.name = "blockquote"
tag['class'] = 'verybold'
tag['id'] = 1
 
tag.string = "New link text."
print(tag)

修改标签内容（NavigableString)

?
1
2
3
soup = BeautifulSoup('<b class="boldest">Extremely bold</b>')
tag = soup.b
tag.string = "New link text."

添加标签内容（NavigableString)

?
1
2
3
4
5
6
7
8
9
10
soup = BeautifulSoup("<a>Foo</a>")
tag = soup.a
tag.append("Bar")
tag.contents
 
# 或者
 
new_string = NavigableString("Bar")
tag.append(new_string)
print(tag)

添加注释(Comment)

注释是一个特殊的NavigableString 对象，所以同样可以通过append() 方法进行添加。

?
1
2
3
4
5
from bs4 import Comment
soup = BeautifulSoup("<a>Foo</a>")
new_comment = soup.new_string("Nice to see you.", Comment)
tag.append(new_comment)
print(tag)

添加标签(Tag)

添加标签方法有两种，一种是在指定标签的内部添加（append方法），另一种是在指定位置添加(insert、insert_before、insert_after方法)

append方法

?
1
2
3
4
5
6
soup = BeautifulSoup("<b></b>")
tag = soup.b
new_tag = soup.new_tag("a", href="http://www.example.com" rel="external nofollow" )
new_tag.string = "Link text."
tag.append(new_tag)
print(tag)

* insert方法，是指在当前标签子节点列表的指定位置插入对象（Tag或NavigableString）

?
1
2
3
4
5
6
html = '<b><a href="http://example.com/" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" >I linked to <i>example.com</i></a></b>'
soup = BeautifulSoup(html)
tag = soup.a
tag.contents
tag.insert(1, "but did not endorse ")
tag.contents

insert_before() 和 insert_after() 方法则在当前标签之前或之后的兄弟节点添加元素

?
1
2
3
4
5
6
html = '<b><a href="http://example.com/" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" >I linked to <i>example.com</i></a></b>'
soup = BeautifulSoup(html)
tag = soup.new_tag("i")
tag.string = "Don't"
soup.b.insert_before(tag)
soup.b

* wrap() 和 unwrap()可以对指定的tag元素进行包装或解包,并返回包装后的结果。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
```python
# 添加包装
soup = BeautifulSoup("<p>I wish I was bold.</p>")
soup.p.string.wrap(soup.new_tag("b"))
#输出 <b>I wish I was bold.</b>
 
soup.p.wrap(soup.new_tag("div"))
#输出 <div><p><b>I wish I was bold.</b></p></div>
 
# 拆解包装
markup = '<a href="http://example.com/" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" >I linked to <i>example.com</i></a>'
soup = BeautifulSoup(markup)
a_tag = soup.a
 
a_tag.i.unwrap()
a_tag
#输出 <a href="http://example.com/" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" >I linked to example.com</a>

删除标签

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
html = '<b><a href="http://example.com/" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" rel="external nofollow" >I linked to <i>example.com</i></a></b>'
soup = BeautifulSoup(html)
# 清楚当前标签的所有子节点
soup.b.clear()
 
# 将当前标签及所有子节点从soup 中移除,返回当前标签。
b_tag=soup.b.extract()
b_tag
soup
 
# 将当前标签及所有子节点从soup 中移除，无返回。
soup.b.decompose()
 
# 将当前标签替换为指定的元素
tag=soup.i
new_tag = soup.new_tag("p")
new_tag.string = "Don't"
tag.replace_with(new_tag)

其他方法

输出

?
1
2
3
# 格式化输出
tag.prettify()
tag.prettify("latin-1")
  • 使用Beautiful Soup解析后,文档都被转换成了Unicode，特殊字符也被转换为Unicode，如果将文档转换成字符串,Unicode编码会被编码成UTF-8.这样就无法正确显示HTML特殊字符了
  • 使用Unicode时,Beautiful Soup还会智能的把“引号”转换成HTML或XML中的特殊字符

文档编码

使用Beautiful Soup解析后,文档都被转换成了Unicode，其使用了“编码自动检测”子库来识别当前文档编码并转换成Unicode编码。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
soup = BeautifulSoup(html)
soup.original_encoding
 
# 也可以手动指定文档的编码
soup = BeautifulSoup(html, from_encoding="iso-8859-8")
soup.original_encoding
 
# 为提高“编码自动检测”的检测效率，也可以预先排除一些编码
soup = BeautifulSoup(markup, exclude_encodings=["ISO-8859-7"])
通过Beautiful Soup输出文档时,不管输入文档是什么编码方式,默认输出编码均为UTF-8编码
文档解析器
Beautiful Soup目前支持, “lxml”, “html5lib”, 和 “html.parser”
 
soup=BeautifulSoup("<a><b /></a>")
soup
#输出： <html><body><a><b></b></a></body></html>
soup=BeautifulSoup("<a></p>", "lxml")
soup
#输出： <html><body><a></a></body></html>
soup=BeautifulSoup("<a></p>", "html5lib")
soup
#输出： <html><head></head><body><a><p></p></a></body></html>
soup=BeautifulSoup("<a></p>", "html.parser")
soup
#输出： <a></a>

参考文档
https://www.crummy.com/software/BeautifulSoup/bs4/doc.zh

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。

原文链接：https://blog.51cto.com/13673090/2466801

  • Python
  • HTML
  • BeautifulSoup

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    2048 　 6006 　 contextlib 　 SLOTS 　 MELIAE 　 FEEDPARSER 　 暂存 　 持久性管理 　 pickle模块 　 THREADING 　 reduce 　 nignx 　 装饰器 　 函数式编程 　 兔子毒药 　 监控文件 　 流量监控 　 Web框架 　 办公工具 　 PIL库 　 高斯模糊 　 wxPython 　 import 　 自定义模块 　 Python开发 　 元类 　 metaclass 　 魔术方法 　 DNSPod 　 动态解析域名 　
    © 2019-2023 脚本之家 | 服务器之家(www.zzvips.com)旗下站点 版权所有关于我们联系我们版权申明网站地图