51CTO首页
AI.x社区
博客
学堂
精品班
软考社区
免费课
企业培训
鸿蒙开发者社区
WOT技术大会
IT证书
公众号矩阵
移动端
短视频免费课程课程排行直播课软考学堂
全部课程厂商认证IT技术24年11月软考PMP项目管理免费题库
在线学习
文章资源问答课堂专栏直播
51CTO
鸿蒙开发者社区
51CTO技术栈
51CTO官微
51CTO学堂
51CTO博客
CTO训练营
鸿蒙开发者社区订阅号
51CTO软考
51CTO学堂APP
51CTO学堂企业版APP
鸿蒙开发者社区视频号
51CTO软考题库
账号设置 退出

Python3中BeautifulSoup的使用方法

作者：崔庆才
大数据
这一节我们就介绍一个强大的解析工具，叫做BeautiSoup，它就是借助网页的结构和属性等特性来解析网页的工具，有了它我们不用再去写一些复杂的正则，只需要简单的几条语句就可以完成网页中某个元素的提取。

[[193228]]

BeautifulSoup的使用

我们学习了正则表达式的相关用法，但是一旦正则写的有问题，可能得到的就不是我们想要的结果了，而且对于一个网页来说，都有一定的特殊的结构和层级关系，而且很多标签都有id或class来对作区分，所以我们借助于它们的结构和属性来提取不也是可以的吗?

所以，这一节我们就介绍一个强大的解析工具，叫做BeautiSoup，它就是借助网页的结构和属性等特性来解析网页的工具，有了它我们不用再去写一些复杂的正则，只需要简单的几条语句就可以完成网页中某个元素的提取。

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

BeautifulSoup简介

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

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

所以说，利用它我们可以省去很多繁琐的提取工作，提高解析效率。

安装

使用之前，我们当然需要首先说明一下它的安装方式。目前BeautifulSoup的***版本是4.x版本，之前的版本已经停止开发了，推荐使用pip来安装，安装命令如下：

  1. pip3 install beautifulsoup4 

当然也可以从pypi下载whl文件安装，链接如下：

https://pypi.python.org/pypi/beautifulsoup4

好，安装完成之后可以验证一下，写一段Python程序试验一下。

  1. from bs4 import BeautifulSoup 
  2.  
  3. soup = BeautifulSoup('<p>Hello</p>', 'html.parser') 
  4.  
  5. print(soup.p.string) 

运行结果

  1. Hello 

如果没有报错，则证明安装没有问题，关于它的解析用法我们在后面会详细介绍。

注意在这里我们虽然安装的是beautifulsoup4这个包，但是在引入的时候是引入的bs4，这是因为这个包源代码本身的库文件夹名称就是bs4，所以安装完成之后，这个库文件夹就被移入到我们本机Python3的lib库里，所以识别到的库文件名称就叫做bs4，所以我们引入的时候就引入bs4这个包。因此，包本身的名称和我们使用时导入的包的名称并不一定是一致的。

解析器

BeautifulSoup在解析的时候实际上是依赖于解析器的，它除了支持Python标准库中的HTML解析器，还支持一些第三方的解析器比如lxml，下面我们对BeautifulSoup支持的解析器及它们的一些优缺点做一个简单的对比。

解析器使用方法优势劣势

Python标准库BeautifulSoup(markup, “html.parser”)Python的内置标准库、执行速度适中 、文档容错能力强Python 2.7.3 or 3.2.2)前的版本中文容错能力差

lxml HTML 解析器BeautifulSoup(markup, “lxml”)速度快、文档容错能力强需要安装C语言库

lxml XML 解析器BeautifulSoup(markup, “xml”)速度快、唯一支持XML的解析器需要安装C语言库

html5libBeautifulSoup(markup, “html5lib”)***的容错性、以浏览器的方式解析文档、生成HTML5格式的文档速度慢、不依赖外部扩展

所以通过以上对比可以看出，lxml这个解析器有解析HTML和XML的功能，而且速度快，容错能力强，所以推荐使用这个库来进行解析，但是这里的劣势是必须安装一个C语言库，它叫做lxml，我们在这里依然使用pip安装即可，命令如下：

  1. pip3 install lxml 

安装完成之后，我们就可以使用lxml这个解析器来解析了，在初始化的时候我们可以把第二个参数改为lxml，如下：

  1. from bs4 import BeautifulSoup 
  2.  
  3. soup = BeautifulSoup('<p>Hello</p>', 'lxml') 
  4.  
  5. print(soup.p.string) 

运行结果是完全一致的，后面BeautifulSoup的用法实例也统一用这个库来演示。

基本使用

下面我们首先用一个实例来感受一下BeautifulSoup的基本使用：

  1. html = """ 
  2.  
  3. <html><head><title>The Dormouse's story</title></head> 
  4.  
  5. <body> 
  6.  
  7. <p class="title" name="dromouse"><b>The Dormouse's story</b></p> 
  8.  
  9. <p class="story">Once upon a time there were three little sisters; and their names were 
  10.  
  11. <a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>, 
  12.  
  13. <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and 
  14.  
  15. <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>; 
  16.  
  17. and they lived at the bottom of a well.</p> 
  18.  
  19. <p class="story">...</p> 
  20.  
  21. """ 
  22.  
  23. from bs4 import BeautifulSoup 
  24.  
  25. soup = BeautifulSoup(html, 'lxml') 
  26.  
  27. print(soup.prettify()) 
  28.  
  29. print(soup.title.string) 

运行结果：

  1. <html> 
  2.  
  3.  <head> 
  4.  
  5.   <title> 
  6.  
  7.    The Dormouse's story 
  8.  
  9.   </title> 
  10.  
  11.  </head> 
  12.  
  13.  <body> 
  14.  
  15.   <p class="title" name="dromouse"> 
  16.  
  17.    <b> 
  18.  
  19.     The Dormouse's story 
  20.  
  21.    </b> 
  22.  
  23.   </p> 
  24.  
  25.   <p class="story"> 
  26.  
  27.    Once upon a time there were three little sisters; and their names were 
  28.  
  29.    <a class="sister" href="http://example.com/elsie" id="link1"> 
  30.  
  31.     <!-- Elsie --> 
  32.  
  33.    </a> 
  34.  
  35.    , 
  36.  
  37.    <a class="sister" href="http://example.com/lacie" id="link2"> 
  38.  
  39.     Lacie 
  40.  
  41.    </a> 
  42.  
  43.    and 
  44.  
  45.    <a class="sister" href="http://example.com/tillie" id="link3"> 
  46.  
  47.     Tillie 
  48.  
  49.    </a> 
  50.  
  51.    ; 
  52.  
  53. and they lived at the bottom of a well. 
  54.  
  55.   </p> 
  56.  
  57.   <p class="story"> 
  58.  
  59.    ... 
  60.  
  61.   </p> 
  62.  
  63.  </body> 
  64.  
  65. </html> 
  66.  
  67. The Dormouse's story 

首先我们声明了一个变量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属性就可以得到里面的文本了，所以我们就可以通过简单地调用几个属性就可以完成文本的提取了，是不是非常方便?

标签选择器

刚才我们选择元素的时候直接通过调用标签的名称就可以选择节点元素了，然后再调用string属性就可以得到标签内的文本了，这种选择方式速度非常快，如果单个标签结构话层次非常清晰，可以选用这种方式来解析。

选择元素

下面我们再用一个例子详细说明一下它的选择方法。

  1. html = """ 
  2.  
  3. <html><head><title>The Dormouse's story</title></head> 
  4.  
  5. <body> 
  6.  
  7. <p class="title" name="dromouse"><b>The Dormouse's story</b></p> 
  8.  
  9. <p class="story">Once upon a time there were three little sisters; and their names were 
  10.  
  11. <a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>, 
  12.  
  13. <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and 
  14.  
  15. <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>; 
  16.  
  17. and they lived at the bottom of a well.</p> 
  18.  
  19. <p class="story">...</p> 
  20.  
  21. """ 
  22.  
  23. from bs4 import BeautifulSoup 
  24.  
  25. soup = BeautifulSoup(html, 'lxml') 
  26.  
  27. print(soup.title) 
  28.  
  29. print(type(soup.title)) 
  30.  
  31. print(soup.title.string) 
  32.  
  33. print(soup.head) 
  34.  
  35. print(soup.p) 

运行结果：

  1. <title>The Dormouse's story</title> 
  2.  
  3. <class 'bs4.element.Tag'> 
  4.  
  5. The Dormouse's story 
  6.  
  7. <head><title>The Dormouse's story</title></head> 
  8.  
  9. <p class="title" name="dromouse"><b>The Dormouse's story</b></p> 

在这里我们依然选用了刚才的HTML代码，我们首先打印输出了title标签的选择结果，输出结果正是title标签加里面的文字内容。接下来输出了它的类型，是 bs4.element.Tag 类型，这是BeautifulSoup中的一个重要的数据结构，经过选择器选择之后，选择结果都是这种Tag类型，它具有一些属性比如string属性，调用Tag的string属性，就可以得到节点的文本内容了，所以接下来的输出结果正是节点的文本内容。

接下来我们又尝试选择了head标签，结果也是标签加其内部的所有内容，再接下来选择了p标签，不过这次情况比较特殊，我们发现结果是***个p标签的内容，后面的几个p标签并没有选择到，也就是说，当有多个标签时，这种选择方式只会选择到***个匹配的标签，其他的后面的标签都会忽略。

提取信息

在上面我们演示了调用string属性来获取文本的值，那我们要获取标签属性值怎么办呢?获取标签名怎么办呢?下面我们来统一梳理一下信息的提取方式

获取名称

可以利用name属性来获取标签的名称。还是以上面的文本为例，我们选取title标签，然后调用name属性就可以得到标签名称。

  1. print(soup.title.name) 

运行结果:

  1. title 

获取属性

每个标签可能有多个属性，比如id，class等等，我们选择到这个节点元素之后，可以调用attrs获取所有属性。

  1. print(soup.p.attrs) 
  2.  
  3. print(soup.p.attrs['name']) 

运行结果：

  1. {'class': ['title'], 'name': 'dromouse'} 
  2.  
  3. dromouse 

可以看到attrs的返回结果是字典形式，把选择的标签的所有属性和属性值组合成一个字典，接下来如果要获取name属性，就相当于从字典中获取某个键值，只需要用中括号加属性名称就可以得到结果了，比如获取name属性就可以通过 attrs['name'] 得到相应的属性值。

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

  1. print(soup.p['name']) 
  2.  
  3. print(soup.p['class']) 

运行结果：

  1. dromouse 
  2.  
  3. ['title'] 

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

获取内容

可以利用string属性获取节点元素包含的文本内容，比如上面的文本我们获取***个p标签的文本：

  1. print(soup.p.string) 

运行结果：

  1. The Dormouse's story 

再次注意一下这里选择到的p标签是***个p标签，获取的文本也就是***个p标签里面的文本。

嵌套选择

在上面的例子中我们知道每一个返回结果都是 bs4.element.Tag 类型，它同样可以继续调用标签进行下一步的选择，比如我们获取了head节点元素，我们可以继续调用head来选取其内部的head节点元素。

  1. html = """ 
  2.  
  3. <html><head><title>The Dormouse's story</title></head> 
  4.  
  5. <body> 
  6.  
  7. """ 
  8.  
  9. from bs4 import BeautifulSoup 
  10.  
  11. soup = BeautifulSoup(html, 'lxml') 
  12.  
  13. print(soup.head.title) 
  14.  
  15. print(type(soup.head.title)) 
  16.  
  17. print(soup.head.title.string) 

运行结果：

  1. <title>The Dormouse's story</title> 
  2.  
  3. <class 'bs4.element.Tag'> 
  4.  
  5. The Dormouse's story 

***行结果是我们调用了head之后再次调用了title来选择的title节点元素，然后我们紧接着打印输出了它的类型，可以看到它仍然是 bs4.element.Tag 类型，也就是说我们在Tag类型的基础上再次选择得到的依然还是Tag类型，每次返回的结果都相同，所以这样我们就可以这样做嵌套的选择了。

***输出了一下它的string属性，也就是标签里的文本内容。

关联选择

我们在做选择的时候有时候不能做到一步就可以选择到想要的节点元素，有时候在选择的时候需要先选中某一个节点元素，然后以它为基准再选择它的子节点、父节点、兄弟节点等等。所以在这里我们就介绍下如何来选择这些节点元素。

子节点和子孙节点

选取到了一个节点元素之后，如果想要获取它的直接子节点可以调用contents属性，我们用一个实例来感受一下：

  1. html = """ 
  2.  
  3. <html> 
  4.  
  5.     <head> 
  6.  
  7.         <title>The Dormouse's story</title> 
  8.  
  9.     </head> 
  10.  
  11.     <body> 
  12.  
  13.         <p class="story"> 
  14.  
  15.             Once upon a time there were three little sisters; and their names were 
  16.  
  17.             <a href="http://example.com/elsie" class="sister" id="link1"> 
  18.  
  19.                 <span>Elsie</span> 
  20.  
  21.             </a> 
  22.  
  23.             <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a>  
  24.  
  25.             and 
  26.  
  27.             <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a> 
  28.  
  29.             and they lived at the bottom of a well. 
  30.  
  31.         </p> 
  32.  
  33.         <p class="story">...</p> 
  34.  
  35. """ 

运行结果：

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

返回的结果是列表形式，p标签里面既包含文本，又包含标签，返回的结果会将他们以列表形式都统一返回。

注意得到的列表的每一个元素都是p标签的直接子节点，比如***个a标签里面包含了一层span标签，这个就相当于孙子节点了，但是返回结果中并没有单独把span标签选出来作为结果的一部分，所以说contents属性得到的结果是直接子节点的列表。

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

  1. from bs4 import BeautifulSoup 
  2.  
  3. soup = BeautifulSoup(html, 'lxml') 
  4.  
  5. print(soup.p.children) 
  6.  
  7. for i, child in enumerate(soup.p.children): 
  8.  
  9.     print(i, child) 

运行结果：

  1. <list_iterator object at 0x1064f7dd8> 
  2.  
  3. 0  
  4.  
  5.             Once upon a time there were three little sisters; and their names were 
  6.  
  7.              
  8.  
  9. 1 <a class="sister" href="http://example.com/elsie" id="link1"> 
  10.  
  11. <span>Elsie</span> 
  12.  
  13. </a> 
  14.  
  15. 2  
  16.  
  17.  
  18.  
  19. 3 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a> 
  20.  
  21. 4   
  22.  
  23.             and 
  24.  
  25.              
  26.  
  27. 5 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a> 
  28.  
  29. 6  
  30.  
  31.             and they lived at the bottom of a well. 

还是同样的HTML文本，在这里我们调用了children属性来进行选择，返回结果可以看到是生成器类型，所以接下来我们用for循环输出了一下相应的内容，内容其实是一样的，只不过children返回的是生成器类型，而contents返回的是列表类型。

如果我们要得到所有的子孙节点的话可以调用descendants属性。

  1. from bs4 import BeautifulSoup 
  2.  
  3. soup = BeautifulSoup(html, 'lxml') 
  4.  
  5. print(soup.p.descendants) 
  6.  
  7. for i, child in enumerate(soup.p.descendants): 
  8.  
  9.     print(i, child) 

运行结果：

  1. <generator object descendants at 0x10650e678> 
  2.  
  3. 0  
  4.  
  5.             Once upon a time there were three little sisters; and their names were 
  6.  
  7.              
  8.  
  9. 1 <a class="sister" href="http://example.com/elsie" id="link1"> 
  10.  
  11. <span>Elsie</span> 
  12.  
  13. </a> 
  14.  
  15. 2  
  16.  
  17.  
  18.  
  19. 3 <span>Elsie</span> 
  20.  
  21. 4 Elsie 
  22.  
  23. 5  
  24.  
  25.  
  26.  
  27. 6  
  28.  
  29.  
  30.  
  31. 7 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a> 
  32.  
  33. 8 Lacie 
  34.  
  35. 9   
  36.  
  37.             and 
  38.  
  39.              
  40.  
  41. 10 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a> 
  42.  
  43. 11 Tillie 
  44.  
  45. 12  
  46.  
  47.             and they lived at the bottom of a well. 

返回结果还是生成器，遍历输出一下可以看到这次的输出结果就包含了span标签，descendants会递归地查询所有子节点，得到的是所有的子孙节点。

父节点和祖先节点

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

  1. html = """ 
  2.  
  3. <html> 
  4.  
  5.     <head> 
  6.  
  7.         <title>The Dormouse's story</title> 
  8.  
  9.     </head> 
  10.  
  11.     <body> 
  12.  
  13.         <p class="story"> 
  14.  
  15.             Once upon a time there were three little sisters; and their names were 
  16.  
  17.             <a href="http://example.com/elsie" class="sister" id="link1"> 
  18.  
  19.                 <span>Elsie</span> 
  20.  
  21.             </a> 
  22.  
  23.         </p> 
  24.  
  25.         <p class="story">...</p> 
  26.  
  27. """ 
  28.  
  29. from bs4 import BeautifulSoup 
  30.  
  31. soup = BeautifulSoup(html, 'lxml') 
  32.  
  33. print(soup.a.parent) 

运行结果：

  1. <p class="story"> 
  2.  
  3. Once upon a time there were three little sisters; and their names were 
  4.  
  5. <a class="sister" href="http://example.com/elsie" id="link1"> 
  6.  
  7. <span>Elsie</span> 
  8.  
  9. </a> 
  10.  
  11. </p> 

在这里我们选择的是***个a标签的父节点元素，很明显它的父节点是p标签，输出结果便是p标签及其内部的内容。

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

  1. html = """ 
  2.  
  3. <html> 
  4.  
  5. <body> 
  6.  
  7. <p class="story"> 
  8.  
  9. <a href="http://example.com/elsie" class="sister" id="link1"> 
  10.  
  11. <span>Elsie</span> 
  12.  
  13. </a> 
  14.  
  15. </p> 
  16.  
  17. """ 
  18.  
  19. from bs4 import BeautifulSoup 
  20.  
  21. soup = BeautifulSoup(html, 'lxml') 
  22.  
  23. print(type(soup.a.parents)) 
  24.  
  25. print(list(enumerate(soup.a.parents))) 

运行结果：

  1. <class 'generator'> 
  2.  
  3. [(0, <p class="story"> 
  4.  
  5. <a class="sister" href="http://example.com/elsie" id="link1"> 
  6.  
  7. <span>Elsie</span> 
  8.  
  9. </a> 
  10.  
  11. </p>), (1, <body> 
  12.  
  13. <p class="story"> 
  14.  
  15. <a class="sister" href="http://example.com/elsie" id="link1"> 
  16.  
  17. <span>Elsie</span> 
  18.  
  19. </a> 
  20.  
  21. </p> 
  22.  
  23. </body>), (2, <html> 
  24.  
  25. <body> 
  26.  
  27. <p class="story"> 
  28.  
  29. <a class="sister" href="http://example.com/elsie" id="link1"> 
  30.  
  31. <span>Elsie</span> 
  32.  
  33. </a> 
  34.  
  35. </p> 
  36.  
  37. </body></html>), (3, <html> 
  38.  
  39. <body> 
  40.  
  41. <p class="story"> 
  42.  
  43. <a class="sister" href="http://example.com/elsie" id="link1"> 
  44.  
  45. <span>Elsie</span> 
  46.  
  47. </a> 
  48.  
  49. </p> 
  50.  
  51. </body></html>)] 

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

兄弟节点

上面说明了子节点和父节点的获取方式，如果要获取同级的节点也就是兄弟节点应该怎么办?我们先用一个实例来感受一下：

 

  1. html = """ 
  2.  
  3. <html> 
  4.  
  5. <body> 
  6.  
  7. <p class="story"> 
  8.  
  9. Once upon a time there were three little sisters; and their names were 
  10.  
  11. <a href="http://example.com/elsie" class="sister" id="link1"> 
  12.  
  13. <span>Elsie</span> 
  14.  
  15. </a> 
  16.  
  17. Hello 
  18.  
  19. <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> 
  20.  
  21. and 
  22.  
  23. <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a> 
  24.  
  25. and they lived at the bottom of a well. 
  26.  
  27. </p> 
  28.  
  29. """ 
  30.  
  31. from bs4 import BeautifulSoup 
  32.  
  33. soup = BeautifulSoup(html, 'lxml') 
  34.  
  35. print('Next Sibling', soup.a.next_sibling) 
  36.  
  37. print('Prev Sibling', soup.a.previous_sibling) 
  38.  
  39. print('Next Siblings', list(enumerate(soup.a.next_siblings))) 
  40.  
  41. print('Prev Siblings', list(enumerate(soup.a.previous_siblings))) 

运行结果：

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

可以看到在这里我们调用了四个不同的属性，next_sibling和previous_sibling分别可以获取节点的下一个和上一个兄弟元素，next_siblings和previous_siblings则分别返回所有前面和后面的兄弟节点的生成器。

提取信息

在上面我们讲解了关联元素节点的选择方法，如果我们想要获取它们的一些信息，比如文本、属性等等也是同样的方法。

 

  1. html = """ 
  2.  
  3. <html> 
  4.  
  5. <body> 
  6.  
  7. <p class="story"> 
  8.  
  9. Once upon a time there were three little sisters; and their names were 
  10.  
  11. <a href="http://example.com/elsie" class="sister" id="link1">Bob</a><a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> 
  12.  
  13. </p> 
  14.  
  15. """ 
  16.  
  17. from bs4 import BeautifulSoup 
  18.  
  19. soup = BeautifulSoup(html, 'lxml') 
  20.  
  21. print('Next Sibling:') 
  22.  
  23. print(type(soup.a.next_sibling)) 
  24.  
  25. print(soup.a.next_sibling) 
  26.  
  27. print(soup.a.next_sibling.string) 
  28.  
  29. print('Parent:') 
  30.  
  31. print(type(soup.a.parents)) 
  32.  
  33. print(list(soup.a.parents)[0]) 
  34.  
  35. print(list(soup.a.parents)[0].attrs['class']) 

运行结果：

  1. Next Sibling: 
  2.  
  3. <class 'bs4.element.Tag'> 
  4.  
  5. <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a> 
  6.  
  7. Lacie 
  8.  
  9. Parent: 
  10.  
  11. <class 'generator'> 
  12.  
  13. <p class="story"> 
  14.  
  15. Once upon a time there were three little sisters; and their names were 
  16.  
  17. <a class="sister" href="http://example.com/elsie" id="link1">Bob</a><a class="sister" href="http://example.com/lacie" id="link2">Lacie</a> 
  18.  
  19. </p> 
  20.  
  21. ['story'] 

如果返回结果是单个节点，那么可以直接调用string、attrs等属性来获得其文本和属性，如果返回结果是多个节点的生成器，则可以转为list后取出某个元素，然后再调用string、attrs等属性来获取其对应节点等文本和属性。

方法选择器

前面我们所讲的选择方法都是用 . 这种运算符来选择元素的，这种选择方法非常快，但是如果要进行比较复杂的选择的话则会比较繁琐，不够灵活。所以BeautifulSoup还为我们提供了一些查询的方法，比如find_all()、find()等方法，我们可以调用方法然后传入相应等参数就可以灵活地进行查询了。

最常用的查询方法莫过于find_all()和find()了，下面我们对它们的用法进行详细的介绍。

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

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

name

我们可以根据标签名来查询元素，下面我们用一个实例来感受一下：

  1. html=''' 
  2.  
  3. <div class="panel"> 
  4.  
  5. <div class="panel-heading"> 
  6.  
  7. <h4>Hello</h4> 
  8.  
  9. </div> 
  10.  
  11. <div class="panel-body"> 
  12.  
  13. <ul class="list" id="list-1"> 
  14.  
  15. <li class="element">Foo</li> 
  16.  
  17. <li class="element">Bar</li> 
  18.  
  19. <li class="element">Jay</li> 
  20.  
  21. </ul> 
  22.  
  23. <ul class="list list-small" id="list-2"> 
  24.  
  25. <li class="element">Foo</li> 
  26.  
  27. <li class="element">Bar</li> 
  28.  
  29. </ul> 
  30.  
  31. </div> 
  32.  
  33. </div> 
  34.  
  35. ''' 
  36.  
  37. from bs4 import BeautifulSoup 
  38.  
  39. soup = BeautifulSoup(html, 'lxml') 
  40.  
  41. print(soup.find_all(name='ul')) 
  42.  
  43. print(type(soup.find_all(name='ul')[0])) 

运行结果：

  1. [<ul class="list" id="list-1"> 
  2.  
  3. <li class="element">Foo</li> 
  4.  
  5. <li class="element">Bar</li> 
  6.  
  7. <li class="element">Jay</li> 
  8.  
  9. </ul>, <ul class="list list-small" id="list-2"> 
  10.  
  11. <li class="element">Foo</li> 
  12.  
  13. <li class="element">Bar</li> 
  14.  
  15. </ul>] 
  16.  
  17. <class 'bs4.element.Tag'> 

在这里我们调用了find_all()方法，传入了一个name参数，参数值为ul，也就是说我们想要查询所有ul标签，返回结果是list类型，长度为2，每个元素依然都是 bs4.element.Tag 类型。

因为都是Tag类型，所以我们依然可以进行嵌套查询，还是同样的文本，在这里我们查询出所有ul标签后再继续查询其内部的li标签。

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

运行结果：

  1. [<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>] 
  2.  
  3. [<li class="element">Foo</li>, <li class="element">Bar</li>] 

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

接下来我们就可以遍历每个li获取它的文本了。

  1. for ul in soup.find_all(name='ul'): 
  2.  
  3. print(ul.find_all(name='li')) 
  4.  
  5. for li in ul.find_all(name='li'): 
  6.  
  7. print(li.string) 

运行结果：

  1. [<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>] 
  2.  
  3. Foo 
  4.  
  5. Bar 
  6.  
  7. Jay 
  8.  
  9. [<li class="element">Foo</li>, <li class="element">Bar</li>] 
  10.  
  11. Foo 
  12.  
  13. Bar 

attrs

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

  1. html=''' 
  2.  
  3. <div class="panel"> 
  4.  
  5. <div class="panel-heading"> 
  6.  
  7. <h4>Hello</h4> 
  8.  
  9. </div> 
  10.  
  11. <div class="panel-body"> 
  12.  
  13. <ul class="list" id="list-1" name="elements"> 
  14.  
  15. <li class="element">Foo</li> 
  16.  
  17. <li class="element">Bar</li> 
  18.  
  19. <li class="element">Jay</li> 
  20.  
  21. </ul> 
  22.  
  23. <ul class="list list-small" id="list-2"> 
  24.  
  25. <li class="element">Foo</li> 
  26.  
  27. <li class="element">Bar</li> 
  28.  
  29. </ul> 
  30.  
  31. </div> 
  32.  
  33. </div> 
  34.  
  35. ''' 
  36.  
  37. from bs4 import BeautifulSoup 
  38.  
  39. soup = BeautifulSoup(html, 'lxml') 
  40.  
  41. print(soup.find_all(attrs={'id': 'list-1'})) 
  42.  
  43. print(soup.find_all(attrs={'name': 'elements'})) 

运行结果：

  1. [<ul class="list" id="list-1" name="elements"> 
  2.  
  3. <li class="element">Foo</li> 
  4.  
  5. <li class="element">Bar</li> 
  6.  
  7. <li class="element">Jay</li> 
  8.  
  9. </ul>] 
  10.  
  11. [<ul class="list" id="list-1" name="elements"> 
  12.  
  13. <li class="element">Foo</li> 
  14.  
  15. <li class="element">Bar</li> 
  16.  
  17. <li class="element">Jay</li> 
  18.  
  19. </ul>] 

在这里我们查询的时候传入的是attrs参数，参数的类型是字典类型，比如我们要查询id为list-1的节点，那就可以传入 attrs={'id': 'list-1'} 的查询条件，得到的结果是列表形式，包含的内容就是符合id为list-1的所有节点，上面的例子中符合条件的元素个数是1，所以结果是长度为1的列表。

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

  1. from bs4 import BeautifulSoup 
  2.  
  3. soup = BeautifulSoup(html, 'lxml') 
  4.  
  5. print(soup.find_all(id='list-1')) 
  6.  
  7. print(soup.find_all(class_='element')) 

运行结果：

  1. [<ul class="list" id="list-1"> 
  2.  
  3. <li class="element">Foo</li> 
  4.  
  5. <li class="element">Bar</li> 
  6.  
  7. <li class="element">Jay</li> 
  8.  
  9. </ul>] 
  10.  
  11. [<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参数可以用来匹配节点的文本，传入的形式可以是字符串，可以是正则表达式对象，我们用一个实例来感受一下：

  1. import re 
  2.  
  3. html=''' 
  4.  
  5. <div class="panel"> 
  6.  
  7.     <div class="panel-body"> 
  8.  
  9.         <a>Hello, this is a link</a> 
  10.  
  11.         <a>Hello, this is a link, too</a> 
  12.  
  13.     </div> 
  14.  
  15. </div> 
  16.  
  17. ''' 
  18.  
  19. from bs4 import BeautifulSoup 
  20.  
  21. soup = BeautifulSoup(html, 'lxml') 
  22.  
  23. print(soup.find_all(text=re.compile('link'))) 

运行结果：

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

在这里有两个a节点，其内部包含有文本信息，在这里我们调用find_all()方法传入text参数，参数为正则表达式对象，结果会返回所有匹配正则表达式的节点文本组成的列表。

find(name , attrs , recursive , text , **kwargs)

除了find_all()方法，还有find()方法，只不过find()方法返回的是单个元素，也就是***个匹配的元素，而find_all()返回的是所有匹配的元素组成的列表。

  1. html=''' 
  2.  
  3. <div class="panel"> 
  4.  
  5.     <div class="panel-heading"> 
  6.  
  7.         <h4>Hello</h4> 
  8.  
  9.     </div> 
  10.  
  11.     <div class="panel-body"> 
  12.  
  13.         <ul class="list" id="list-1"> 
  14.  
  15.             <li class="element">Foo</li> 
  16.  
  17.             <li class="element">Bar</li> 
  18.  
  19.             <li class="element">Jay</li> 
  20.  
  21.         </ul> 
  22.  
  23.         <ul class="list list-small" id="list-2"> 
  24.  
  25.             <li class="element">Foo</li> 
  26.  
  27.             <li class="element">Bar</li> 
  28.  
  29.         </ul> 
  30.  
  31.     </div> 
  32.  
  33. </div> 
  34.  
  35. ''' 
  36.  
  37. from bs4 import BeautifulSoup 
  38.  
  39. soup = BeautifulSoup(html, 'lxml') 
  40.  
  41. print(soup.find(name='ul')) 
  42.  
  43. print(type(soup.find(name='ul'))) 
  44.  
  45. print(soup.find(class_='list')) 

运行结果：

  1. <ul class="list" id="list-1"> 
  2.  
  3. <li class="element">Foo</li> 
  4.  
  5. <li class="element">Bar</li> 
  6.  
  7. <li class="element">Jay</li> 
  8.  
  9. </ul> 
  10.  
  11. <class 'bs4.element.Tag'> 
  12.  
  13. <ul class="list" id="list-1"> 
  14.  
  15. <li class="element">Foo</li> 
  16.  
  17. <li class="element">Bar</li> 
  18.  
  19. <li class="element">Jay</li> 
  20.  
  21. </ul> 

返回结果不再是列表形式，而是***个匹配的节点元素，类型依然是Tag类型。

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

find_parents() find_parent()

find_parents()返回所有祖先节点，find_parent()返回直接父节点。

find_next_siblings() find_next_sibling()

find_next_siblings()返回后面所有兄弟节点，find_next_sibling()返回后面***个兄弟节点。

find_previous_siblings() find_previous_sibling()

find_previous_siblings()返回前面所有兄弟节点，find_previous_sibling()返回前面***个兄弟节点。

find_all_next() find_next()

find_all_next()返回节点后所有符合条件的节点, find_next()返回***个符合条件的节点。

find_all_previous() 和 find_previous()

find_all_previous()返回节点后所有符合条件的节点, find_previous()返回***个符合条件的节点

CSS选择器

BeautifulSoup还提供了另外一种选择器，那就是CSS选择器，如果对web开发熟悉对话，CSS选择器肯定也不陌生，如果不熟悉的话，可以看一下 CSS选择器参考手册 。

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

  1. html=''' 
  2.  
  3. <div class="panel"> 
  4.  
  5.     <div class="panel-heading"> 
  6.  
  7.         <h4>Hello</h4> 
  8.  
  9.     </div> 
  10.  
  11.     <div class="panel-body"> 
  12.  
  13.         <ul class="list" id="list-1"> 
  14.  
  15.             <li class="element">Foo</li> 
  16.  
  17.             <li class="element">Bar</li> 
  18.  
  19.             <li class="element">Jay</li> 
  20.  
  21.         </ul> 
  22.  
  23.         <ul class="list list-small" id="list-2"> 
  24.  
  25.             <li class="element">Foo</li> 
  26.  
  27.             <li class="element">Bar</li> 
  28.  
  29.         </ul> 
  30.  
  31.     </div> 
  32.  
  33. </div> 
  34.  
  35. ''' 
  36.  
  37. from bs4 import BeautifulSoup 
  38.  
  39. soup = BeautifulSoup(html, 'lxml') 
  40.  
  41. print(soup.select('.panel .panel-heading')) 
  42.  
  43. print(soup.select('ul li')) 
  44.  
  45. print(soup.select('#list-2 .element')) 
  46.  
  47. print(type(soup.select('ul')[0])) 

运行结果：

  1. [<div class="panel-heading"> 
  2.  
  3. <h4>Hello</h4> 
  4.  
  5. </div>] 
  6.  
  7. [<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>] 
  8.  
  9. [<li class="element">Foo</li>, <li class="element">Bar</li>] 
  10.  
  11. <class 'bs4.element.Tag'> 

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

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

嵌套选择

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

  1. from bs4 import BeautifulSoup 
  2.  
  3. soup = BeautifulSoup(html, 'lxml') 
  4.  
  5. for ul in soup.select('ul'): 
  6.  
  7. print(ul.select('li')) 

运行结果：

  1. [<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>] 
  2.  
  3. [<li class="element">Foo</li>, <li class="element">Bar</li>] 

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

获取属性

我们知道节点类型是Tag类型，所以获取属性还是可以用原来的方法获取，仍然是上面的HTML文本，我们在这里尝试获取每个ul节点的id属性。

  1. from bs4 import BeautifulSoup 
  2.  
  3. soup = BeautifulSoup(html, 'lxml') 
  4.  
  5. for ul in soup.select('ul'): 
  6.  
  7.     print(ul['id']) 
  8.  
  9.     print(ul.attrs['id']) 

运行结果：

  1. list-1 
  2.  
  3. list-1 
  4.  
  5. list-2 
  6.  
  7. list-2 

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

获取文本

那么获取文本当然也可以用前面所讲的string属性，还有一个方法那就是get_text()，同样可以获取文本值。

  1. from bs4 import BeautifulSoup 
  2.  
  3. soup = BeautifulSoup(html, 'lxml') 
  4.  
  5. for li in soup.select('li'): 
  6.  
  7.     print('Get Text:', li.get_text()) 
  8.  
  9.     print('String:', li.string) 

运行结果：

  1. Get Text: Foo 
  2.  
  3. String: Foo 
  4.  
  5. Get Text: Bar 
  6.  
  7. String: Bar 
  8.  
  9. Get Text: Jay 
  10.  
  11. String: Jay 
  12.  
  13. Get Text: Foo 
  14.  
  15. String: Foo 
  16.  
  17. Get Text: Bar 
  18.  
  19. String: Bar 

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

综述

到此BeautifulSoup的使用介绍基本就结束了，***做一下简单的总结：

  • 推荐使用lxml解析库，必要时使用html.parser
  • 标签选择筛选功能弱但是速度快
  • 建议使用find()、find_all() 查询匹配单个结果或者多个结果
  • 如果对CSS选择器熟悉的话可以使用select()选择法
责任编辑：武晓燕 来源： 36大数据
PythonBeautifulSoup解析器
相关推荐
Python编程在Nginx中的使用方法
Python编程有不少的知识需要我们学习，下面我们就详细的告诉大家在实际操作中如何进行相关问题解答。希望对大家有所帮助。

2010-03-10 11:11:16

Python编程
解析AdobeFlexBuilder3的使用方法
本文向大家介绍一下AdobeFlexBuilder的使用，Adobe在发布Flex的同时就发布了一个高效的IDE——FlexBuilder，对Flex的开发提供了强大的支持。

2010-08-09 10:16:01

FlexBuilder
Python script代码在C++中的使用方法
Pythonscript代码经常在很多环境中使用，其中在C++中的使用时最频繁的。下面我们就来看看如何才能在C++中应用这个语言。

2010-03-10 19:18:10

Python scri
Python爬虫神器PyQuery的使用方法
前端大大们的福音来了，PyQuery来了，乍听名字，你一定联想到了jQuery，如果你对jQuery熟悉，那么PyQuery来解析文档就是不二之选!包括我在内!PyQuery是Python仿照jQuery的严格实现。语法与jQuery几乎完全相同，所以不用再去费心去记一些奇怪的方法了。

2017-05-27 20:00:30

Python爬虫神器PyQuery
解析Javascript中Split使用方法
这里和大家分享一下vascript中的Split使用方法与技巧，split方法可以将一个字符串分割为子字符串，然后将结果作为字符串数组返回。

2010-10-08 14:27:25

JavascriptSplit
解析Qt中QThread使用方法
本文介绍了Qt中QThread使用方法，在本片文章中反复提到了线程的使用，详细内容请参考本文，QThread的使用方法：include继承了Qt。

2011-06-14 10:18:58

QThread Qt 线程
详解JS中event使用方法
这里和大家学习一下JSevent使用方法，event代表事件的状态，例如触发event对象的元素、鼠标的位置及状态、按下的键等等，并且event对象只在事件发生的过程中才有效。

2010-10-09 10:30:03

JS event
Linux中如何掌握NFS的使用方法
NFS是我们经常要用到的服务，在Linux中当我们进行文件共享的时候NFS就成为了我们得心应手的工具。下面就来讲解下NFS的配置要点。

2010-07-05 09:38:47

LinuxNFS
了解iPhone应用中UIScrollView的使用方法
本文主要是让我们了解iPhone应用中UIScrollView的使用方法，本文通过一个实例来学习UIScrollView的使用方法，来看内容。

2011-08-03 17:27:40

iPhone UIScrollVi
盘点JavaScript中Eval函数的使用方法
本文基于JavaScript基础，介绍了Eval函数的使用。调用eval(code)会运行代码字符串，并返回最后一条语句的结果。

2024-07-11 14:05:28

JavaScript函数
WMI中的Windows PowerShell脚本使用方法
虽然自90年代初期WindowsManagementInstrumentation（WMI）就已经存在，但是由于WMI的复杂性，其推广速度非常缓慢。WindowsPowerShell打破了这个障碍，它让WMI的使用更容易，这也改变了IT行业的面貌。在本文中将向你阐述WMI中的WindowsPowerShell脚本使用方法。

2011-02-14 10:21:04

Windows PowWMI
JSF中f:loadBundle标签的使用方法
本文向您介绍JSF中支持JSP本地化的操作标签，JSFf:loadBundle标签，并对该标签的用法做简单的介绍。

2009-06-12 18:35:33

JSF f:loadB
盘点JavaScript中Eval函数的使用方法
今天我们一起来盘点一下JavaScript中Eval函数的使用方法都有哪些吧。

2024-09-03 13:32:11

JavaScriptEval函数
Python yield具体使用方法探讨
可能对于大多数刚刚接触Python的朋友来说，看到Pythonyield时，肯定会非常困惑，它的主要作用到底是什么呢？在这里将会做一个详细介绍。

2010-03-04 13:37:20

Python yiel
Vue.js 中的片段使用方法
在本文中，你学习了如何在Vue中使用片段，并了解了为什么在写代码时要考虑可访问性是非常重要的。

2021-05-08 06:14:28

Vue.js片段开发
iOS中堆和栈的使用方法
堆和栈都是一种数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。堆，队列优先,先进先出(FIFO—firstinfirstout);栈，先进后出(FILO—FirstInLastOut)。一般情况下，如果有人把堆栈合起来说，那它的意思是栈，而不是堆。

2018-06-20 10:34:56

堆栈iOSswift
Android中XML解析模块的使用方法
客户端发送一个request请求，服务端就会以xml的数据格式返回一个response响应。但是在客户端界面展示xml数据并不是那么人性化与现实，所以在此之前，会对xml进行数据解析。纵观软终端的大部分项目中，在客户端进行数据解析采用的是SAX(SimpleAPIforXML),这是有道理的。

2013-06-08 17:09:35

Android开发移动开发XML解析
Hibernate中安装Myeclipse插件的使用方法
本文主要介绍HibernateMyeclipse插件的安装和使用方法。等待安装成功，安装过程因要下载不少Jar包，视你的网络速度不同，需要的时间不同，安装完毕Eclipse将提示你重新启动，重启Eclipse安装完成。

2009-09-23 13:23:12

Hibernate M
盘点JavaScript中Eval函数的使用方法
本文基于JavaScript基础，介绍了Eval函数的使用。调用eval(code)会运行代码字符串，并返回最后一条语句的结果。要在全局作用域中eval代码，可以使用window.eval(code)进行替代。

2021-07-16 07:57:35

JavaScriptEval函数
jQuery使用方法
jQuery是目前使用最广泛的javascript函数库。据统计，全世界排名前100万的网站，有46%使用jQuery，远远超过其他库。微软公司甚至把jQuery作为他们的官方库。对于网页开发者来说，学会jQuery是必要的。因为它让你了解业界最通用的技术，为将来学习更高级的库打下基础，并且确实可以很轻松地做出许多复杂的效果。

2012-01-13 09:55:54

jQuery
点赞
收藏

51CTO技术栈公众号

业务
速览
在线客服