Beautiful Soup的使用

第 2 章介绍了正则表达式的相关用法，只是一旦正则表达式写得有问题，得到的结果就可能不是我们想要的了。而且每一个网页都有一定的特殊结构和层级关系，很多节点都用 id 或 class 作区分，所以借助它们的结构和属性来提取不也可以吗?

本节我们就介绍一个强大的解析工具——Beautiful Soup，其借助网页的结构和属性等特性来解析网页。有了它，我们不需要写复杂的正则表达式，只需要简单的几个语句，就可以完成网页中某个元素的提取。

废话不多说，接下来就感受一下 Beautiful Soup 的强大之处吧。

Beautiful Soup的简介

简单来说，Beautiful Soup 是 Python 的一个 HTML 或 XML 的解析库，我们用它可以方便地从网页中提取数据，其官方解释如下：

Beautiful Soup 提供一些简单的、Python 式的函数来处理导航、搜索、修改分析树等功能。它是一个工具箱，通过解析文档为用户提供需要抓取的数据，因为简单，所以无须很多代码就可以写出一个完整的应用程序。Beautiful Soup 自动将输入文档转换为 Unicode 编码，将输出文档转换为 utf-8 编码。你不需要考虑编码方式，除非文档没有指定具体的编码方式，这时你仅仅需要说明一下原始编码方式就可以了。Beautiful Soup 已成为和 lxml、html5lib 一样出色的 Python 解释器，为用户灵活提供不同的解析策略或强劲的速度。

总而言之，利用 Beautiful Soup 可以省去很多烦琐的提取工作，提高解析网页的效率。

解析器

实际上，Beautiful Soup 在解析时是依赖解析器的，它除了支持 Python 标准库中的 HTML 解析器，还支持一些第三方解析器（例如 lxml）。表 3-3 列出了 Beautiful Soup 支持的解析器。

Table 1. 表3-3 Beautiful Soup 支持的解析器
解析器	使用方法	优势	劣势
Python 标准库	BeautifulSoup(markup, 'html.parser')	Python 的内置标准库、执行速度适中、文档容错能力强	Python 2.7.3 或 3.2.2 前的版本中文容错能力差
LXML HTML 解析器	BeautifulSoup(markup, 'lxml')	速度快、文档容错能力强	需要安装 C 语言库
LXML XML 解析器	BeautifulSoup(markup, 'xml')	速度快、唯一支持 XML 的解析器	需要安装 C 语言库
html5lib	BeautifulSoup(markup, 'html5lib')	提供最好的容错性、以浏览器的方式解析文档、生成 HTML5 格式的文档	速度慢、不依赖外部扩展

通过表 3-3 的对比可以看出，LXML 解析器有解析 HTML 和 XML 的功能，而且速度快、容错能力强，所以推荐使用它。

使用 LXML 解析器，只需在初始化 Beautiful Soup 时，把第二个参数改为 lxml 即可：

from bs4 import BeautifulSoup
soup = BeautifulSoup('<p>Hello</p>', 'lxml')
print(soup.p.string)

在后面，统一用这个解析器演示 Beautiful Soup 的用法实例。

准备工作

在开始之前，请确保已经正确安装好 Beautiful Soup 和 lxml 这两个库。Beautiful Soup 直接使用 pip3 安装即可，命令如下：

pip3 install beautifulsoup4

更加详细的安装说明可以参考： https://setup.scrape.center/beautifulsoup 。

另外，我们使用的是 lxml 这个解析器，所以还需要额外安装 lxml 这个库，其安装方法见 3.1 节。

以上两个库都安装完成后，就可以进行接下来的学习了。

基本使用

下面首先通过实例看看 Beautiful Soup 的基本用法：

html = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title" name="dromouse"><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" class="sister" id="link1"></a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie </a>;
and they lived at the bottom of a well.</p>
<p class="story">...</p>
"""

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
print(soup.prettify())
print(soup.title.string)

运行结果如下：

<html>
 <head>
  <title>
   The Dormouse's story
  </title>
 </head>
 <body>
  <p class="title" name="dromouse">
   <b>
    The Dormouse's story
   </b>
  </p>
  <p class="story">
   Once upon a time there were three little sisters; and their names were
   <a class="sister" href="http://example.com/elsie" id="link1">
   </a>
   ,
   <a class="sister" href="http://example.com/lacie" id="link2">
    Lacie
   </a>
   and
   <a class="sister" href="http://example.com/tillie" id="link3">
    Tillie
   </a>
   ;
and they lived at the bottom of a well.
  </p>
  <p class="story">
   ...
  </p>
 </body>
</html>

这里首先声明一个变量 html，这是一个 HTML 字符串。但是需要注意的是，它并不是一个完整的 HTML 字符串，因为 body 节点和 html 节点都没有闭合。接着，我们将它当作第一个参数传给 BeautifulSoup 对象，该对象的第二个参数为解析器的类型（这里使用 lxml），此时就完成了 BeaufulSoup 对象的初始化。然后，将这个对象赋值给 soup 变量。

之后就可以调用 soup 的各个方法和属性解析这串 HTML 代码了。

首先，调用 prettify 方法。这个方法可以把要解析的字符串以标准的缩进格式输出。这里需要注意的是，输出结果里包含 body 和 html 节点，也就是说对于不标准的 HTML 字符串 BeautifulSoup，可以自动更正格式。这一步不是由 prettify 方法完成的，而是在初始化 BeautifulSoup 的时候就完成了。

然后调用 soup.title.string，这实际上是输出 HTML 中 title 节点的文本内容。所以，通过 soup.title 选出 HTML 中的 title 节点，再调用 string 属性就可以得到 title 节点里面的文本了。你看，我们通过简单调用几个属性就完成了文本提取，是不是非常方便？

节点选择器

直接调用节点的名称即可选择节点，然后调用 string 属性就可以得到节点内的文本了。这种选择方式速度非常快，当单个节点结构层次非常清晰时，可以选用这种方式来解析。

下面再用一个例子详细说明选择节点的方法：

html = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title" name="dromouse"><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" class="sister" id="link1"></a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie </a>;
and they lived at the bottom of a well.</p>
<p class="story">...</p>
"""

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
print(soup.title)
print(type(soup.title))
print(soup.title.string)
print(soup.head)
print(soup.p)

运行结果：

<title>The Dormouse's story</title>
<class 'bs4.element.Tag'>
The Dormouse's story
<head><title>The Dormouse's story</title></head>
<p class="title" name="dromouse"><b>The Dormouse's story</b></p>

这里依然使用刚才的 HTML 代码，首先打印出 title 节点的选择结果，输出结果正是 title 节点及里面的文字内容。接下来，输出 title 节点的类型，是 bs4.element.Tag，这是 Beautiful Soup 中一个重要的数据结构，经过选择器选择的结果都是这种 Tag 类型。Tag 具有一些属性，例如 string 属性，调用该属性可以得到节点的文本内容，所以类型的输出结果正是节点的文本内容。

输出文本内容后，又尝试选择了 head 节点，结果也是节点加其内部的所有内容。最后，选择了 p 节点。不过这次情况比较特殊，因为结果是第一个 p 节点的内容，后面的几个 p 节点并没有选取到。也就是说，当有多个节点时，这种选择方式只会选择到第一个匹配的节点，后面的其他节点都会忽略。

提取信息

上面演示了通过调用 string 属性获取文本的值，那么如何获取节点名称？如何获取节点属性的值呢？接下来我们就统一梳理一下信息的提取方式。

获取名称

利用 name 属性可以获取节点的名称。还是以上面的文本为例，先选取 title 节点，再调用 name 属性就可以得到节点名称：

print(soup.title.name)

运行结果：

title

获取属性

一个节点可能有多个属性，例如 id 和 class 等，选择这个节点元素后，可以调用 attrs 获取其所有属性：

print(soup.p.attrs)
print(soup.p.attrs['name'])

运行结果：

{'class':['title'], 'name':'dromouse'}
dromouse

可以看到，调用 attrs 属性的返回结果是字典形式，包括所选择节点的所有属性和属性值。因此要获取 name 属性，相当于从字典中获取某个键值，只需要用中括号加属性名就可以了。例如通过 attrs['name'] 获取 name 属性。

其实这种方式有点烦琐，还有一种更为简单的获取属性值的方式：不用写 attrs，直接在节点元素后面加中括号，然后传入属性名就可以了。样例如下：

print(soup.p['name'])
print(soup.p['class'])

运行结果如下：

dromouse
['title']

这里需要注意，有的返回结果是字符串，有的返回结果是由字符串组成的列表。例如，name 属性的值是唯一的，于是返回结果就是单个字符串。而对于 class 属性，一个节点元素可能包含多个 class，所以返回的就是列表。在实际处理过程中，我们要注意判断类型。

获取内容

这点在前面也提到过，可以利用 string 属性获取节点元素包含的文本内容，例如用如下实例获取第一个 p 节点的文本：

print(soup.p.string)

运行结果如下：

TheDormouse's story

再次注意一下，这里选取的 p 节点是第一个 p 节点，获取的文本也是第一个 p 节点里面的文本。

嵌套选择

在上面的例子中，我们知道所有返回结果都是 bs4.element.Tag 类型，Tag 类型的对象同样可以继续调用节点进行下一步的选择。例如，我们获取了 head 节点，就可以继续调用 head 选取其内部的 head 节点：

html = """
<html><head><title>The Dormouse's story</title></head>
<body>
""" # Incomplete HTML from the image snippet

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
print(soup.head.title)
print(type(soup.head.title))
print(soup.head.title.string)

运行结果如下：

<title>The Dormouse's story</title>
<class 'bs4.element.Tag'>
The Dormouse's story

运行结果的第一行是调用 head 之后再调用 title，而选择的 title 节点。第二行打印出了它的类型，可以看到，仍然是 bs4.element.Tag 类型。也就是说，我们在 Tag 类型的基础上再次选择，得到的结果依然是 Tag 类型。既然每次返回的结果都相同，那么就可以做嵌套选择了。

最后一行结果输出了 title 节点的 string 属性，也就是节点里的文本内容。

关联选择

在做选择的过程中，有时不能一步就选到想要的节点，需要先选中某一个节点，再以它为基准选子节点、父节点、兄弟节点等，下面就介绍一下如何选择这些节点。

子节点和子孙节点

选取节点之后，如果想要获取它的直接子节点，可以调用 contents 属性，实例如下：

html = """
<html>
<head>
<title>The Dormouse's story</title>
</head>
<body>
<p class="story">
Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">
<span>Elsie</span>
</a>
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a>
and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>
and they lived at the bottom of a well.
</p>
<p class="story">...</p>
"""

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
print(soup.p.contents)

运行结果如下：

['\nOnce upon a time there were three little sisters; and their names were\n', <a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>, '\n', <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, '\nand\n', <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>, '\nand they lived at the bottom of a well.\n']

可以看到，返回结果是列表形式。p 节点里既包含文本，又包含节点，这些内容会以列表形式统一返回。

需要注意的是，列表中的每个元素都是 p 节点的直接子节点。像第一个 a 节点里面包含的 span 节点，就相当于孙子节点，但是返回结果并没有把 span 节点单独选出来。所以说，contents 属性得到的结果是直接子节点组成的列表。

同样，我们可以调用 children 属性得到相应的结果：

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
print(soup.p.children)
for i, child in enumerate(soup.p.children):
    print(i, child)

运行结果如下：

<generator object Tag.children.<locals>.<genexpr> at 0x00000261B25B9A80>
0
Once upon a time there were three little sisters; and their names were

1 <a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
2

3 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
4
and

5 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
6
and they lived at the bottom of a well.

还是同样的 HTML 文本，这里调用 children 属性来选择，返回结果是生成器类型。然后，我们用 for 循环输出了相应的内容。

如果要得到所有的子孙节点，则可以调用 descendants 属性：

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
print(soup.p.descendants)
for i, child in enumerate(soup.p.children):
    print(i, child)

运行结果如下：

<generator object Tag.descendants at 0x0000025344D49A80>
0
Once upon a time there were three little sisters; and their names were

1 <a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
2

3 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
4
and

5 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
6
and they lived at the bottom of a well.

你会发现，此时返回结果还是生成器。遍历输出一下可以看到，这次的输出结果中就包含了 span 节点，因为 descendants 会递归查询所有子节点，得到所有的子孙节点。

父节点和祖先节点

如果要获取某个节点元素的父节点，可以调用 parent 属性：

html = """
<html>
<head>
<title>The Dormouse's story</title>
</head>
<body>
<p class="story">
Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">
<span>Elsie</span>
</a>
</p>
<p class="story">...</p>
""" # Incomplete HTML from the image snippet

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
print(soup.a.parent)

运行结果如下：

<p class="story">
Once upon a time there were three little sisters; and their names were
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>

这里我们选择的是第一个 a 节点的父节点元素。很明显，a 节点的父节点是 p 节点，所以输出结果便是 p 节点及其内部内容。

需要注意，这里输出的仅仅是 a 节点的直接父节点，而没有再向外寻找父节点的祖先节点。如果想获取所有祖先节点，可以调用 parents 属性：

html = """
<html>
<body>
<p class="story">
<a href="http://example.com/elsie" class="sister" id="link1">
<span>Elsie</span>
</a>
</p>
""" # Incomplete HTML from the image snippet

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
print(type(soup.a.parents))
print(list(enumerate(soup.a.parents)))

运行结果如下：

<class 'generator'>
[(0, <p class="story">
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>), (1, <body>
<p class="story">
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>
</body>), (2, <html>
<body>
<p class="story">
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>
</body></html>), (3, <html>
<body>
<p class="story">
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>
</body></html>)]

可以发现，返回结果是生成器类型。这里用列表输出了其索引和内容，列表中的元素就是 a 节点的祖先节点。

兄弟节点

子节点和父节点的获取方式已经介绍完毕，如果要获取同级节点，也就是兄弟节点，又该怎么办呢？实例如下：

html = """
<html>
<body>
<p class="story">
Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">
<span>Elsie</span>
</a>
Hello
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a>
and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>
and they lived at the bottom of a well.
</p>
""" # The provided HTML snippet is cut off at the end.

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
print('Next Sibling', soup.a.next_sibling)
print('Prev Sibling', soup.a.previous_sibling)
print('Next Siblings', list(enumerate(soup.a.next_siblings)))
print('Prev Siblings', list(enumerate(soup.a.previous_siblings)))

运行结果如下：

Next Sibling
Hello

Prev Sibling
Once upon a time there were three little sisters; and their names were

Next Siblings [(0, '\nHello\n'), (1, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>), (2, '\nand\n'), (3, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>), (4, '\nand they lived at the bottom of a well.\n')]
Prev Siblings [(0, '\nOnce upon a time there were three little sisters; and their names were\n')]

可以看到，这里调用了 4 个属性。next_sibling 和 previous_sibling 分别用于获取节点的下一个和上一个兄弟节点，next_siblings 和 previous_siblings 则分别返回后面和前面的所有兄弟节点。

提取信息

前面讲过关联元素节点的选择方法，如果想要获取它们的一些信息，例如文本、属性等，也可以用同样的方法，实例如下：

html = """
<html>
<body>
<p class="story">
Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Bob</a><a href="http://example.com/lacie" class="sister" id="link2">Lacie</a>
</p>
""" # Incomplete HTML from the image snippet

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
print('Next Sibling:')
print(type(soup.a.next_sibling))
print(soup.a.next_sibling)
print(soup.a.next_sibling.string)
print('Parent:')
print(type(soup.a.parents))
print(list(soup.a.parents)[0])
print(list(soup.a.parents)[0].attrs['class'])

运行结果如下：

Next Sibling:
<class 'bs4.element.Tag'>
<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
Lacie
Parent:
<class 'generator'>
<p class="story">
Once upon a time there were three little sisters; and their names were
<a class="sister" href="http://example.com/elsie" id="link1">Bob</a><a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
</p>
['story']

如果返回结果是单个节点，那么可以直接调用 string、attrs 等属性获得其文本和属性；如果返回结果是包含多个节点的生成器，则可以先将结果转为列表，再从中取出某个元素，之后调用 string、 attrs 等属性即可获取对应节点的文本和属性。

方法选择器

前面讲的选择方法都是基于属性来选择的，这种方法虽然快，但是在进行比较复杂的选择时，会变得比较烦锁，不够灵活。幸好，Beautiful Soup 还为我们提供了一些查询方法，例如 find_all 和 find 等。调用这些方法。然后传入相应的参数。就可以灵活查询了。

find_all

find_all，顾名思义就是查询所有符合条件的元素，可以给它传入一些属性或文本来得到符合条件的元素，功能十分强大。它的 API 如下：

find_all(name, attrs, recursive, text, **kwargs）

name

我们可以根据 name 参数来查询元素，下面用一个实例来感受一下：

html='''
<div class="panel">
<div class="panel-heading">
<h4>Hello</h4>
</div>
<div class="panel-body">
<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>
<ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>
</div>
''' # The provided HTML snippet is cut off at the end.

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
print(soup.find_all(name='ul'))
print(type(soup.find_all(name='ul')[0]))

运行结果如下：

[<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>, <ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>]
<class 'bs4.element.Tag'>

这里我们调用了 find_all 方法，向其中传入 name 参数，其参数值为 ul，意思是查询所有 ul 节点。返回结果是列表类型，长度为 2，列表中每个元素依然都是 bs4.element.Tag 类型。

因为都是 Tag 类型，所以依然可以进行嵌套查询。下面这个实例还是以同样的文本为例，先查询所有 ul 节点，查出后再继续查询其内部的 li 节点：

for ul in soup.find_all(name='ul'):
    print(ul.find_all(name='li'))

运行结果如下：

[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>]
[<li class="element">Foo</li>, <li class="element">Bar</li>]

返回结果是列表类型，列表中的每个元素依然是 Tag 类型。

接下来我们就可以遍历每个 li 节点，并获取它的文本内容了。

for ul in soup.find_all(name='ul'):
    print(ul.find_all(name='li'))
    for li in ul.find_all(name='li'):
        print(li.string)

运行结果如下：

[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>]
Foo
Bar
Jay
[<li class="element">Foo</li>, <li class="element">Bar</li>]
Foo
Bar

attrs

除了根据节点名查询，我们也可以传入一些属性进行查询，下面用一个实例感受一下：

html='''
<div class="panel">
<div class="panel-heading">
<h4>Hello</h4>
</div>
<div class="panel-body">
<ul class="list" id="list-1" name="elements">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>
<ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>
</div>
''' # The provided HTML snippet is cut off at the end.

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
print(soup.find_all(attrs={'id': 'list-1'}))
print(soup.find_all(attrs={'name': 'elements'}))

运行结果如下：

[<ul class="list" id="list-1" name="elements">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>]
[<ul class="list" id="list-1" name="elements">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>]

这里查询的时候，传入的是 attrs 参数，其属于字典类型。例如，要查询 id 为 list-1 的节点，就可以传入 attrs={'id'："list-1"} 作为查询条件，得到的结果是列表形式，列表中的内容就是符合 id 为 list-1 这一条件的所有节点。在上面的实例中，符合条件的元素个数是 1，所以返回结果是长度为 1 的列表。

对于一些常用的属性，例如 id 和 class 等，我们可以不用 attrs 传递。例如，要查询 id 为 list-1 的节点，可以直接传入 id 这个参数。还是使用上面的文本，只不过换一种方式来查询：

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
print(soup.find_all(id='list-1'))
print(soup.find_all(class_='element'))

运行结果如下：

[<ul class="list" id="list-1" name="elements">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>]
[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>, <li class="element">Foo</li>, <li class="element">Bar</li>]

这里直接传入 id='list-1'，就可以查询 id 为 list-1 的节点元素了。而对于 class 来说，由于 class 在 Python 里是一个关键字，所以后面需要加一个下划线，即 class_='element'，返回结果依然是 Tag 对象组成的列表。

text

text 参数可以用来匹配节点的文本，其传入形式可以是字符串，也可以是正则表达式对象，实例如下：

import re

html = '''
<div class="panel">
    <div class="panel-body">
        <a>Hello, this is a link</a>
        <a>Hello, this is a link, too</a>
    </div>
</div>
'''

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
# text 参数过时，替换为 string
print(soup.find_all(string=re.compile('link')))

运行结果如下：

['Hello, this is a link', 'Hello, this is a link, too']

这里有两个 a 节点，其内部包含文本信息。这里在 find_all 方法中传入 text 参数，该参数为正则表达式对象，返回结果是由所有与正则表达式相匹配的节点文本组成的列表。

find

除了 find_all 方法，还有 find 方法也可以查询符合条件的元素，只不过 find 方法返回的是单个元素，也就是第一个匹配的元素，而 find_all 会返回由所有匹配的元素组成的列表。实例如下：

html = '''
<div class="panel">
    <div class="panel-heading">
        <h4>Hello</h4>
    </div>
    <div class="panel-body">
        <ul class="list" id="list-1">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
            <li class="element">Jay</li>
        </ul>
        <ul class="list list-small" id="list-2">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
        </ul>
    </div>
</div>
'''

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
print(soup.find(name='ul'))
print(type(soup.find(name='ul')))
print(soup.find(class_='list'))

运行结果如下：

<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>
<class 'bs4.element.Tag'>
<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>

可以看到，返回结果不再是列表形式，而是第一个匹配的节点元素，类型依然是 Tag 类型。

另外还有许多查询方法，用法与介绍过的 find_all、find 完全相同，区别在于查询范围不同，在此做一下简单的说明。

find_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 选择器。如果你熟悉 Web 开发，那么肯定对 CSS 选择器不陌生。

使用 CSS 选择器，只需要调用 select 方法，传入相应的 CSS 选择器即可。我们用一个实例感受下：

html = '''
<div class="panel">
    <div class="panel-heading">
        <h4>Hello</h4>
    </div>
    <div class="panel-body">
        <ul class="list" id="list-1">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
            <li class="element">Jay</li>
        </ul>
        <ul class="list list-small" id="list-2">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
        </ul>
    </div>
</div>
'''

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
print(soup.select('.panel .panel-heading'))
print(soup.select('ul li'))
print(soup.select('#list-2 .element'))
print(type(soup.select('ul')[0]))

运行结果如下：

[<div class="panel-heading">
<h4>Hello</h4>
</div>]
[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>, <li class="element">Foo</li>, <li class="element">Bar</li>]
[<li class="element">Foo</li>, <li class="element">Bar</li>]
<class 'bs4.element.Tag'>

这里我们用了 3 次 CSS 选择器，返回结果均是由符合 CSS 选择器的节点组成的列表。例如，select('ul li') 表示选择所有 ul 节点下面的所有 li 节点，结果便是所有 li 节点组成的列表。

在最后一句中，我们打印输出了列表中元素的类型。可以看到，类型依然是 Tag 类型。

嵌套选择

select 方法同样支持嵌套选择，例如先选择所有 ul 节点，再遍历每个 ul 节点，选择其 li 节点，实例如下：

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
for ul in soup.select('ul'):
    print(ul.select('li'))

运行结果如下：

[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>]
[<li class="element">Foo</li>, <li class="element">Bar</li>]

可以看到，正常输出了每个 ul 节点下所有 li 节点组成的列表

获取属性

既然知道节点是 Tag 类型，于是获取属性依然可以使用原来的方法。还是基于上面的 HTML 文本，这里尝试获取每个 ul 节点的 id 属性：

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
for ul in soup.select('ul'):
    print(ul['id'])
    print(ul.attrs['id'])

运行结果如下：

list-1
list-1
list-2
list-2

可以看到，直接将属性名传入中括号和通过 attrs 属性获取属性值，都是可以成功获取属性的。

获取文本

要获取文本，当然也可以用前面所讲的 string 属性。除此之外，还有一个方法，就是 get_text，实例如下：

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
for li in soup.select('li'):
    print('Get Text:', li.get_text())
    print('String:', li.string)

运行结果如下：

Get Text: Foo
String: Foo
Get Text: Bar
String: Bar
Get Text: Jay
String: Jay
Get Text: Foo
String: Foo
Get Text: Bar
String: Bar

二者的实现效果完全一致，都可以获取节点的文本值。

总结

到此，Beautiful Soup 的介绍基本就结束了，最后做一下简单的总结。

推荐使用 LXML 解析库，必要时使用 html.parser。
节点选择器筛选功能弱，但是速度快。
建议使用 find、find_all 方法查询匹配的单个结果或者多个结果。
如果对 CSS 选择器熟悉，则可以使用 select 选择法。

本节代码参见: https://github.com/Python3WebSpider/BeautifulSoupTest 。