Python3中BeautifulSoup的使用方法

2021-07-30 23:49:21

Python3中BeautifulSoup的使用方法

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. 

  2.  
    3. 

  3. soup = BeautifulSoup('<p>Hello</p>', 'html.parser') 
    4. 

  4.  
    5. 

  5. print(soup.p.string) 
    6. 



运行结果




  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. 

  2.  
    3. 

  3. soup = BeautifulSoup('<p>Hello</p>', 'lxml') 
    4. 

  4.  
    5. 

  5. print(soup.p.string) 
    6. 



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


基本使用


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




    

  1. html = """ 
    2. 

  2.  
    3. 

  3. <html><head><title>The Dormouse's story</title></head> 
    4. 

  4.  
    5. 

  5. <body> 
    6. 

  6.  
    7. 

  7. <p class="title" name="dromouse"><b>The Dormouse's story</b></p> 
    8. 

  8.  
    9. 

  9. <p class="story">Once upon a time there were three little sisters; and their names were 
    10. 

  10.  
    11. 

  11. <a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>, 
    12. 

  12.  
    13. 

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

  14.  
    15. 

  15. <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>; 
    16. 

  16.  
    17. 

  17. and they lived at the bottom of a well.</p> 
    18. 

  18.  
    19. 

  19. <p class="story">...</p> 
    20. 

  20.  
    21. 

  21. """ 
    22. 

  22.  
    23. 

  23. from bs4 import BeautifulSoup 
    24. 

  24.  
    25. 

  25. soup = BeautifulSoup(html, 'lxml') 
    26. 

  26.  
    27. 

  27. print(soup.prettify()) 
    28. 

  28.  
    29. 

  29. print(soup.title.string) 
    30. 



运行结果：




    

  1. <html> 
    2. 

  2.  
    3. 

  3.  <head> 
    4. 

  4.  
    5. 

  5.   <title> 
    6. 

  6.  
    7. 

  7.    The Dormouse's story 
    8. 

  8.  
    9. 

  9.   </title> 
    10. 

  10.  
    11. 

  11.  </head> 
    12. 

  12.  
    13. 

  13.  <body> 
    14. 

  14.  
    15. 

  15.   <p class="title" name="dromouse"> 
    16. 

  16.  
    17. 

  17.    <b> 
    18. 

  18.  
    19. 

  19.     The Dormouse's story 
    20. 

  20.  
    21. 

  21.    </b> 
    22. 

  22.  
    23. 

  23.   </p> 
    24. 

  24.  
    25. 

  25.   <p class="story"> 
    26. 

  26.  
    27. 

  27.    Once upon a time there were three little sisters; and their names were 
    28. 

  28.  
    29. 

  29.    <a class="sister" href="http://example.com/elsie" id="link1"> 
    30. 

  30.  
    31. 

  31.     <!-- Elsie --> 
    32. 

  32.  
    33. 

  33.    </a> 
    34. 

  34.  
    35. 

  35.    , 
    36. 

  36.  
    37. 

  37.    <a class="sister" href="http://example.com/lacie" id="link2"> 
    38. 

  38.  
    39. 

  39.     Lacie 
    40. 

  40.  
    41. 

  41.    </a> 
    42. 

  42.  
    43. 

  43.    and 
    44. 

  44.  
    45. 

  45.    <a class="sister" href="http://example.com/tillie" id="link3"> 
    46. 

  46.  
    47. 

  47.     Tillie 
    48. 

  48.  
    49. 

  49.    </a> 
    50. 

  50.  
    51. 

  51.    ; 
    52. 

  52.  
    53. 

  53. and they lived at the bottom of a well. 
    54. 

  54.  
    55. 

  55.   </p> 
    56. 

  56.  
    57. 

  57.   <p class="story"> 
    58. 

  58.  
    59. 

  59.    ... 
    60. 

  60.  
    61. 

  61.   </p> 
    62. 

  62.  
    63. 

  63.  </body> 
    64. 

  64.  
    65. 

  65. </html> 
    66. 

  66.  
    67. 

  67. The Dormouse's story 
    68. 



首先我们声明了一个变量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. 

  2.  
    3. 

  3. <html><head><title>The Dormouse's story</title></head> 
    4. 

  4.  
    5. 

  5. <body> 
    6. 

  6.  
    7. 

  7. <p class="title" name="dromouse"><b>The Dormouse's story</b></p> 
    8. 

  8.  
    9. 

  9. <p class="story">Once upon a time there were three little sisters; and their names were 
    10. 

  10.  
    11. 

  11. <a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>, 
    12. 

  12.  
    13. 

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

  14.  
    15. 

  15. <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>; 
    16. 

  16.  
    17. 

  17. and they lived at the bottom of a well.</p> 
    18. 

  18.  
    19. 

  19. <p class="story">...</p> 
    20. 

  20.  
    21. 

  21. """ 
    22. 

  22.  
    23. 

  23. from bs4 import BeautifulSoup 
    24. 

  24.  
    25. 

  25. soup = BeautifulSoup(html, 'lxml') 
    26. 

  26.  
    27. 

  27. print(soup.title) 
    28. 

  28.  
    29. 

  29. print(type(soup.title)) 
    30. 

  30.  
    31. 

  31. print(soup.title.string) 
    32. 

  32.  
    33. 

  33. print(soup.head) 
    34. 

  34.  
    35. 

  35. print(soup.p) 
    36. 



运行结果：




    

  1. <title>The Dormouse's story</title> 
    2. 

  2.  
    3. 

  3. <class 'bs4.element.Tag'> 
    4. 

  4.  
    5. 

  5. The Dormouse's story 
    6. 

  6.  
    7. 

  7. <head><title>The Dormouse's story</title></head> 
    8. 

  8.  
    9. 

  9. <p class="title" name="dromouse"><b>The Dormouse's story</b></p> 
    10. 



在这里我们依然选用了刚才的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. 

  2.  
    3. 

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



运行结果：




    

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

  2.  
    3. 

  3. dromouse 
    4. 



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


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




    

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

  2.  
    3. 

  3. print(soup.p['class']) 
    4. 



运行结果：




    

  1. dromouse 
    2. 

  2.  
    3. 

  3. ['title'] 
    4. 



在这里注意到有的返回结果是字符串，有的返回结果是字符串组成的列表。比如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. 

  2.  
    3. 

  3. <html><head><title>The Dormouse's story</title></head> 
    4. 

  4.  
    5. 

  5. <body> 
    6. 

  6.  
    7. 

  7. """ 
    8. 

  8.  
    9. 

  9. from bs4 import BeautifulSoup 
    10. 

  10.  
    11. 

  11. soup = BeautifulSoup(html, 'lxml') 
    12. 

  12.  
    13. 

  13. print(soup.head.title) 
    14. 

  14.  
    15. 

  15. print(type(soup.head.title)) 
    16. 

  16.  
    17. 

  17. print(soup.head.title.string) 
    18. 



运行结果：




    

  1. <title>The Dormouse's story</title> 
    2. 

  2.  
    3. 

  3. <class 'bs4.element.Tag'> 
    4. 

  4.  
    5. 

  5. The Dormouse's story 
    6. 



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


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


关联选择


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


子节点和子孙节点


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




    

  1. html = """ 
    2. 

  2.  
    3. 

  3. <html> 
    4. 

  4.  
    5. 

  5.     <head> 
    6. 

  6.  
    7. 

  7.         <title>The Dormouse's story</title> 
    8. 

  8.  
    9. 

  9.     </head> 
    10. 

  10.  
    11. 

  11.     <body> 
    12. 

  12.  
    13. 

  13.         <p class="story"> 
    14. 

  14.  
    15. 

  15.             Once upon a time there were three little sisters; and their names were 
    16. 

  16.  
    17. 

  17.             <a href="http://example.com/elsie" class="sister" id="link1"> 
    18. 

  18.  
    19. 

  19.                 <span>Elsie</span> 
    20. 

  20.  
    21. 

  21.             </a> 
    22. 

  22.  
    23. 

  23.             <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a>  
    24. 

  24.  
    25. 

  25.             and 
    26. 

  26.  
    27. 

  27.             <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a> 
    28. 

  28.  
    29. 

  29.             and they lived at the bottom of a well. 
    30. 

  30.  
    31. 

  31.         </p> 
    32. 

  32.  
    33. 

  33.         <p class="story">...</p> 
    34. 

  34.  
    35. 

  35. """ 
    36. 



运行结果：




    

  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. 

  2.  
    3. 

  3. <span>Elsie</span> 
    4. 

  4.  
    5. 

  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        '] 
    6. 



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


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


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




    

  1. from bs4 import BeautifulSoup 
    2. 

  2.  
    3. 

  3. soup = BeautifulSoup(html, 'lxml') 
    4. 

  4.  
    5. 

  5. print(soup.p.children) 
    6. 

  6.  
    7. 

  7. for i, child in enumerate(soup.p.children): 
    8. 

  8.  
    9. 

  9.     print(i, child) 
    10. 



运行结果：




    

  1. <list_iterator object at 0x1064f7dd8> 
    2. 

  2.  
    3. 

  3. 0  
    4. 

  4.  
    5. 

  5.             Once upon a time there were three little sisters; and their names were 
    6. 

  6.  
    7. 

  7.              
    8. 

  8.  
    9. 

  9. 1 <a class="sister" href="http://example.com/elsie" id="link1"> 
    10. 

  10.  
    11. 

  11. <span>Elsie</span> 
    12. 

  12.  
    13. 

  13. </a> 
    14. 

  14.  
    15. 

  15. 2  
    16. 

  16.  
    17. 

  17.  
    18. 

  18.  
    19. 

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

  20.  
    21. 

  21. 4   
    22. 

  22.  
    23. 

  23.             and 
    24. 

  24.  
    25. 

  25.              
    26. 

  26.  
    27. 

  27. 5 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a> 
    28. 

  28.  
    29. 

  29. 6  
    30. 

  30.  
    31. 

  31.             and they lived at the bottom of a well. 
    32. 



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


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




    

  1. from bs4 import BeautifulSoup 
    2. 

  2.  
    3. 

  3. soup = BeautifulSoup(html, 'lxml') 
    4. 

  4.  
    5. 

  5. print(soup.p.descendants) 
    6. 

  6.  
    7. 

  7. for i, child in enumerate(soup.p.descendants): 
    8. 

  8.  
    9. 

  9.     print(i, child) 
    10. 



运行结果：




    

  1. <generator object descendants at 0x10650e678> 
    2. 

  2.  
    3. 

  3. 0  
    4. 

  4.  
    5. 

  5.             Once upon a time there were three little sisters; and their names were 
    6. 

  6.  
    7. 

  7.              
    8. 

  8.  
    9. 

  9. 1 <a class="sister" href="http://example.com/elsie" id="link1"> 
    10. 

  10.  
    11. 

  11. <span>Elsie</span> 
    12. 

  12.  
    13. 

  13. </a> 
    14. 

  14.  
    15. 

  15. 2  
    16. 

  16.  
    17. 

  17.  
    18. 

  18.  
    19. 

  19. 3 <span>Elsie</span> 
    20. 

  20.  
    21. 

  21. 4 Elsie 
    22. 

  22.  
    23. 

  23. 5  
    24. 

  24.  
    25. 

  25.  
    26. 

  26.  
    27. 

  27. 6  
    28. 

  28.  
    29. 

  29.  
    30. 

  30.  
    31. 

  31. 7 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a> 
    32. 

  32.  
    33. 

  33. 8 Lacie 
    34. 

  34.  
    35. 

  35. 9   
    36. 

  36.  
    37. 

  37.             and 
    38. 

  38.  
    39. 

  39.              
    40. 

  40.  
    41. 

  41. 10 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a> 
    42. 

  42.  
    43. 

  43. 11 Tillie 
    44. 

  44.  
    45. 

  45. 12  
    46. 

  46.  
    47. 

  47.             and they lived at the bottom of a well. 
    48. 



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


父节点和祖先节点


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




    

  1. html = """ 
    2. 

  2.  
    3. 

  3. <html> 
    4. 

  4.  
    5. 

  5.     <head> 
    6. 

  6.  
    7. 

  7.         <title>The Dormouse's story</title> 
    8. 

  8.  
    9. 

  9.     </head> 
    10. 

  10.  
    11. 

  11.     <body> 
    12. 

  12.  
    13. 

  13.         <p class="story"> 
    14. 

  14.  
    15. 

  15.             Once upon a time there were three little sisters; and their names were 
    16. 

  16.  
    17. 

  17.             <a href="http://example.com/elsie" class="sister" id="link1"> 
    18. 

  18.  
    19. 

  19.                 <span>Elsie</span> 
    20. 

  20.  
    21. 

  21.             </a> 
    22. 

  22.  
    23. 

  23.         </p> 
    24. 

  24.  
    25. 

  25.         <p class="story">...</p> 
    26. 

  26.  
    27. 

  27. """ 
    28. 

  28.  
    29. 

  29. from bs4 import BeautifulSoup 
    30. 

  30.  
    31. 

  31. soup = BeautifulSoup(html, 'lxml') 
    32. 

  32.  
    33. 

  33. print(soup.a.parent) 
    34. 



运行结果：




    

  1. <p class="story"> 
    2. 

  2.  
    3. 

  3. Once upon a time there were three little sisters; and their names were 
    4. 

  4.  
    5. 

  5. <a class="sister" href="http://example.com/elsie" id="link1"> 
    6. 

  6.  
    7. 

  7. <span>Elsie</span> 
    8. 

  8.  
    9. 

  9. </a> 
    10. 

  10.  
    11. 

  11. </p> 
    12. 



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


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




    

  1. html = """ 
    2. 

  2.  
    3. 

  3. <html> 
    4. 

  4.  
    5. 

  5. <body> 
    6. 

  6.  
    7. 

  7. <p class="story"> 
    8. 

  8.  
    9. 

  9. <a href="http://example.com/elsie" class="sister" id="link1"> 
    10. 

  10.  
    11. 

  11. <span>Elsie</span> 
    12. 

  12.  
    13. 

  13. </a> 
    14. 

  14.  
    15. 

  15. </p> 
    16. 

  16.  
    17. 

  17. """ 
    18. 

  18.  
    19. 

  19. from bs4 import BeautifulSoup 
    20. 

  20.  
    21. 

  21. soup = BeautifulSoup(html, 'lxml') 
    22. 

  22.  
    23. 

  23. print(type(soup.a.parents)) 
    24. 

  24.  
    25. 

  25. print(list(enumerate(soup.a.parents))) 
    26. 



运行结果：




    

  1. <class 'generator'> 
    2. 

  2.  
    3. 

  3. [(0, <p class="story"> 
    4. 

  4.  
    5. 

  5. <a class="sister" href="http://example.com/elsie" id="link1"> 
    6. 

  6.  
    7. 

  7. <span>Elsie</span> 
    8. 

  8.  
    9. 

  9. </a> 
    10. 

  10.  
    11. 

  11. </p>), (1, <body> 
    12. 

  12.  
    13. 

  13. <p class="story"> 
    14. 

  14.  
    15. 

  15. <a class="sister" href="http://example.com/elsie" id="link1"> 
    16. 

  16.  
    17. 

  17. <span>Elsie</span> 
    18. 

  18.  
    19. 

  19. </a> 
    20. 

  20.  
    21. 

  21. </p> 
    22. 

  22.  
    23. 

  23. </body>), (2, <html> 
    24. 

  24.  
    25. 

  25. <body> 
    26. 

  26.  
    27. 

  27. <p class="story"> 
    28. 

  28.  
    29. 

  29. <a class="sister" href="http://example.com/elsie" id="link1"> 
    30. 

  30.  
    31. 

  31. <span>Elsie</span> 
    32. 

  32.  
    33. 

  33. </a> 
    34. 

  34.  
    35. 

  35. </p> 
    36. 

  36.  
    37. 

  37. </body></html>), (3, <html> 
    38. 

  38.  
    39. 

  39. <body> 
    40. 

  40.  
    41. 

  41. <p class="story"> 
    42. 

  42.  
    43. 

  43. <a class="sister" href="http://example.com/elsie" id="link1"> 
    44. 

  44.  
    45. 

  45. <span>Elsie</span> 
    46. 

  46.  
    47. 

  47. </a> 
    48. 

  48.  
    49. 

  49. </p> 
    50. 

  50.  
    51. 

  51. </body></html>)] 
    52. 



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


兄弟节点


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




    

  1. html = """ 
    2. 

  2.  
    3. 

  3. <html> 
    4. 

  4.  
    5. 

  5. <body> 
    6. 

  6.  
    7. 

  7. <p class="story"> 
    8. 

  8.  
    9. 

  9. Once upon a time there were three little sisters; and their names were 
    10. 

  10.  
    11. 

  11. <a href="http://example.com/elsie" class="sister" id="link1"> 
    12. 

  12.  
    13. 

  13. <span>Elsie</span> 
    14. 

  14.  
    15. 

  15. </a> 
    16. 

  16.  
    17. 

  17. Hello 
    18. 

  18.  
    19. 

  19. <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> 
    20. 

  20.  
    21. 

  21. and 
    22. 

  22.  
    23. 

  23. <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a> 
    24. 

  24.  
    25. 

  25. and they lived at the bottom of a well. 
    26. 

  26.  
    27. 

  27. </p> 
    28. 

  28.  
    29. 

  29. """ 
    30. 

  30.  
    31. 

  31. from bs4 import BeautifulSoup 
    32. 

  32.  
    33. 

  33. soup = BeautifulSoup(html, 'lxml') 
    34. 

  34.  
    35. 

  35. print('Next Sibling', soup.a.next_sibling) 
    36. 

  36.  
    37. 

  37. print('Prev Sibling', soup.a.previous_sibling) 
    38. 

  38.  
    39. 

  39. print('Next Siblings', list(enumerate(soup.a.next_siblings))) 
    40. 

  40.  
    41. 

  41. print('Prev Siblings', list(enumerate(soup.a.previous_siblings))) 
    42. 



运行结果：




    

  1. Next Sibling 
    2. 

  2.  
    3. 

  3. Hello 
    4. 

  4.  
    5. 

  5. Prev Sibling 
    6. 

  6.  
    7. 

  7. Once upon a time there were three little sisters; and their names were 
    8. 

  8.  
    9. 

  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. 

  10.  
    11. 

  11. Prev Siblings [(0, '\n Once upon a time there were three little sisters; and their names were\n ')] 
    12. 



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


提取信息


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




    

  1. html = """ 
    2. 

  2.  
    3. 

  3. <html> 
    4. 

  4.  
    5. 

  5. <body> 
    6. 

  6.  
    7. 

  7. <p class="story"> 
    8. 

  8.  
    9. 

  9. Once upon a time there were three little sisters; and their names were 
    10. 

  10.  
    11. 

  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. 

  12.  
    13. 

  13. </p> 
    14. 

  14.  
    15. 

  15. """ 
    16. 

  16.  
    17. 

  17. from bs4 import BeautifulSoup 
    18. 

  18.  
    19. 

  19. soup = BeautifulSoup(html, 'lxml') 
    20. 

  20.  
    21. 

  21. print('Next Sibling:') 
    22. 

  22.  
    23. 

  23. print(type(soup.a.next_sibling)) 
    24. 

  24.  
    25. 

  25. print(soup.a.next_sibling) 
    26. 

  26.  
    27. 

  27. print(soup.a.next_sibling.string) 
    28. 

  28.  
    29. 

  29. print('Parent:') 
    30. 

  30.  
    31. 

  31. print(type(soup.a.parents)) 
    32. 

  32.  
    33. 

  33. print(list(soup.a.parents)[0]) 
    34. 

  34.  
    35. 

  35. print(list(soup.a.parents)[0].attrs['class']) 
    36. 



运行结果：




    

  1. Next Sibling: 
    2. 

  2.  
    3. 

  3. <class 'bs4.element.Tag'> 
    4. 

  4.  
    5. 

  5. <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a> 
    6. 

  6.  
    7. 

  7. Lacie 
    8. 

  8.  
    9. 

  9. Parent: 
    10. 

  10.  
    11. 

  11. <class 'generator'> 
    12. 

  12.  
    13. 

  13. <p class="story"> 
    14. 

  14.  
    15. 

  15. Once upon a time there were three little sisters; and their names were 
    16. 

  16.  
    17. 

  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. 

  18.  
    19. 

  19. </p> 
    20. 

  20.  
    21. 

  21. ['story'] 
    22. 



如果返回结果是单个节点，那么可以直接调用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. 

  2.  
    3. 

  3. <div class="panel"> 
    4. 

  4.  
    5. 

  5. <div class="panel-heading"> 
    6. 

  6.  
    7. 

  7. <h4>Hello</h4> 
    8. 

  8.  
    9. 

  9. </div> 
    10. 

  10.  
    11. 

  11. <div class="panel-body"> 
    12. 

  12.  
    13. 

  13. <ul class="list" id="list-1"> 
    14. 

  14.  
    15. 

  15. <li class="element">Foo</li> 
    16. 

  16.  
    17. 

  17. <li class="element">Bar</li> 
    18. 

  18.  
    19. 

  19. <li class="element">Jay</li> 
    20. 

  20.  
    21. 

  21. </ul> 
    22. 

  22.  
    23. 

  23. <ul class="list list-small" id="list-2"> 
    24. 

  24.  
    25. 

  25. <li class="element">Foo</li> 
    26. 

  26.  
    27. 

  27. <li class="element">Bar</li> 
    28. 

  28.  
    29. 

  29. </ul> 
    30. 

  30.  
    31. 

  31. </div> 
    32. 

  32.  
    33. 

  33. </div> 
    34. 

  34.  
    35. 

  35. ''' 
    36. 

  36.  
    37. 

  37. from bs4 import BeautifulSoup 
    38. 

  38.  
    39. 

  39. soup = BeautifulSoup(html, 'lxml') 
    40. 

  40.  
    41. 

  41. print(soup.find_all(name='ul')) 
    42. 

  42.  
    43. 

  43. print(type(soup.find_all(name='ul')[0])) 
    44. 



运行结果：




    

  1. [<ul class="list" id="list-1"> 
    2. 

  2.  
    3. 

  3. <li class="element">Foo</li> 
    4. 

  4.  
    5. 

  5. <li class="element">Bar</li> 
    6. 

  6.  
    7. 

  7. <li class="element">Jay</li> 
    8. 

  8.  
    9. 

  9. </ul>, <ul class="list list-small" id="list-2"> 
    10. 

  10.  
    11. 

  11. <li class="element">Foo</li> 
    12. 

  12.  
    13. 

  13. <li class="element">Bar</li> 
    14. 

  14.  
    15. 

  15. </ul>] 
    16. 

  16.  
    17. 

  17. <class 'bs4.element.Tag'> 
    18. 



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


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




    

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

  2.  
    3. 

  3. print(ul.find_all(name='li')) 
    4. 



运行结果：




    

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

  2.  
    3. 

  3. [<li class="element">Foo</li>, <li class="element">Bar</li>] 
    4. 



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


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




    

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

  2.  
    3. 

  3. print(ul.find_all(name='li')) 
    4. 

  4.  
    5. 

  5. for li in ul.find_all(name='li'): 
    6. 

  6.  
    7. 

  7. print(li.string) 
    8. 



运行结果：




    

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

  2.  
    3. 

  3. Foo 
    4. 

  4.  
    5. 

  5. Bar 
    6. 

  6.  
    7. 

  7. Jay 
    8. 

  8.  
    9. 

  9. [<li class="element">Foo</li>, <li class="element">Bar</li>] 
    10. 

  10.  
    11. 

  11. Foo 
    12. 

  12.  
    13. 

  13. Bar 
    14. 



attrs


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




    

  1. html=''' 
    2. 

  2.  
    3. 

  3. <div class="panel"> 
    4. 

  4.  
    5. 

  5. <div class="panel-heading"> 
    6. 

  6.  
    7. 

  7. <h4>Hello</h4> 
    8. 

  8.  
    9. 

  9. </div> 
    10. 

  10.  
    11. 

  11. <div class="panel-body"> 
    12. 

  12.  
    13. 

  13. <ul class="list" id="list-1" name="elements"> 
    14. 

  14.  
    15. 

  15. <li class="element">Foo</li> 
    16. 

  16.  
    17. 

  17. <li class="element">Bar</li> 
    18. 

  18.  
    19. 

  19. <li class="element">Jay</li> 
    20. 

  20.  
    21. 

  21. </ul> 
    22. 

  22.  
    23. 

  23. <ul class="list list-small" id="list-2"> 
    24. 

  24.  
    25. 

  25. <li class="element">Foo</li> 
    26. 

  26.  
    27. 

  27. <li class="element">Bar</li> 
    28. 

  28.  
    29. 

  29. </ul> 
    30. 

  30.  
    31. 

  31. </div> 
    32. 

  32.  
    33. 

  33. </div> 
    34. 

  34.  
    35. 

  35. ''' 
    36. 

  36.  
    37. 

  37. from bs4 import BeautifulSoup 
    38. 

  38.  
    39. 

  39. soup = BeautifulSoup(html, 'lxml') 
    40. 

  40.  
    41. 

  41. print(soup.find_all(attrs={'id': 'list-1'})) 
    42. 

  42.  
    43. 

  43. print(soup.find_all(attrs={'name': 'elements'})) 
    44. 



运行结果：




    

  1. [<ul class="list" id="list-1" name="elements"> 
    2. 

  2.  
    3. 

  3. <li class="element">Foo</li> 
    4. 

  4.  
    5. 

  5. <li class="element">Bar</li> 
    6. 

  6.  
    7. 

  7. <li class="element">Jay</li> 
    8. 

  8.  
    9. 

  9. </ul>] 
    10. 

  10.  
    11. 

  11. [<ul class="list" id="list-1" name="elements"> 
    12. 

  12.  
    13. 

  13. <li class="element">Foo</li> 
    14. 

  14.  
    15. 

  15. <li class="element">Bar</li> 
    16. 

  16.  
    17. 

  17. <li class="element">Jay</li> 
    18. 

  18.  
    19. 

  19. </ul>] 
    20. 



在这里我们查询的时候传入的是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. 

  2.  
    3. 

  3. soup = BeautifulSoup(html, 'lxml') 
    4. 

  4.  
    5. 

  5. print(soup.find_all(id='list-1')) 
    6. 

  6.  
    7. 

  7. print(soup.find_all(class_='element')) 
    8. 



运行结果：




    

  1. [<ul class="list" id="list-1"> 
    2. 

  2.  
    3. 

  3. <li class="element">Foo</li> 
    4. 

  4.  
    5. 

  5. <li class="element">Bar</li> 
    6. 

  6.  
    7. 

  7. <li class="element">Jay</li> 
    8. 

  8.  
    9. 

  9. </ul>] 
    10. 

  10.  
    11. 

  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>] 
    12. 



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


text


text参数可以用来匹配节点的文本，传入的形式可以是字符串，可以是正则表达式对象，我们用一个实例来感受一下：




    

  1. import re 
    2. 

  2.  
    3. 

  3. html=''' 
    4. 

  4.  
    5. 

  5. <div class="panel"> 
    6. 

  6.  
    7. 

  7.     <div class="panel-body"> 
    8. 

  8.  
    9. 

  9.         <a>Hello, this is a link</a> 
    10. 

  10.  
    11. 

  11.         <a>Hello, this is a link, too</a> 
    12. 

  12.  
    13. 

  13.     </div> 
    14. 

  14.  
    15. 

  15. </div> 
    16. 

  16.  
    17. 

  17. ''' 
    18. 

  18.  
    19. 

  19. from bs4 import BeautifulSoup 
    20. 

  20.  
    21. 

  21. soup = BeautifulSoup(html, 'lxml') 
    22. 

  22.  
    23. 

  23. print(soup.find_all(text=re.compile('link'))) 
    24. 



运行结果：




  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. 

  2.  
    3. 

  3. <div class="panel"> 
    4. 

  4.  
    5. 

  5.     <div class="panel-heading"> 
    6. 

  6.  
    7. 

  7.         <h4>Hello</h4> 
    8. 

  8.  
    9. 

  9.     </div> 
    10. 

  10.  
    11. 

  11.     <div class="panel-body"> 
    12. 

  12.  
    13. 

  13.         <ul class="list" id="list-1"> 
    14. 

  14.  
    15. 

  15.             <li class="element">Foo</li> 
    16. 

  16.  
    17. 

  17.             <li class="element">Bar</li> 
    18. 

  18.  
    19. 

  19.             <li class="element">Jay</li> 
    20. 

  20.  
    21. 

  21.         </ul> 
    22. 

  22.  
    23. 

  23.         <ul class="list list-small" id="list-2"> 
    24. 

  24.  
    25. 

  25.             <li class="element">Foo</li> 
    26. 

  26.  
    27. 

  27.             <li class="element">Bar</li> 
    28. 

  28.  
    29. 

  29.         </ul> 
    30. 

  30.  
    31. 

  31.     </div> 
    32. 

  32.  
    33. 

  33. </div> 
    34. 

  34.  
    35. 

  35. ''' 
    36. 

  36.  
    37. 

  37. from bs4 import BeautifulSoup 
    38. 

  38.  
    39. 

  39. soup = BeautifulSoup(html, 'lxml') 
    40. 

  40.  
    41. 

  41. print(soup.find(name='ul')) 
    42. 

  42.  
    43. 

  43. print(type(soup.find(name='ul'))) 
    44. 

  44.  
    45. 

  45. print(soup.find(class_='list')) 
    46. 



运行结果：




    

  1. <ul class="list" id="list-1"> 
    2. 

  2.  
    3. 

  3. <li class="element">Foo</li> 
    4. 

  4.  
    5. 

  5. <li class="element">Bar</li> 
    6. 

  6.  
    7. 

  7. <li class="element">Jay</li> 
    8. 

  8.  
    9. 

  9. </ul> 
    10. 

  10.  
    11. 

  11. <class 'bs4.element.Tag'> 
    12. 

  12.  
    13. 

  13. <ul class="list" id="list-1"> 
    14. 

  14.  
    15. 

  15. <li class="element">Foo</li> 
    16. 

  16.  
    17. 

  17. <li class="element">Bar</li> 
    18. 

  18.  
    19. 

  19. <li class="element">Jay</li> 
    20. 

  20.  
    21. 

  21. </ul> 
    22. 



返回结果不再是列表形式，而是第一个匹配的节点元素，类型依然是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. 

  2.  
    3. 

  3. <div class="panel"> 
    4. 

  4.  
    5. 

  5.     <div class="panel-heading"> 
    6. 

  6.  
    7. 

  7.         <h4>Hello</h4> 
    8. 

  8.  
    9. 

  9.     </div> 
    10. 

  10.  
    11. 

  11.     <div class="panel-body"> 
    12. 

  12.  
    13. 

  13.         <ul class="list" id="list-1"> 
    14. 

  14.  
    15. 

  15.             <li class="element">Foo</li> 
    16. 

  16.  
    17. 

  17.             <li class="element">Bar</li> 
    18. 

  18.  
    19. 

  19.             <li class="element">Jay</li> 
    20. 

  20.  
    21. 

  21.         </ul> 
    22. 

  22.  
    23. 

  23.         <ul class="list list-small" id="list-2"> 
    24. 

  24.  
    25. 

  25.             <li class="element">Foo</li> 
    26. 

  26.  
    27. 

  27.             <li class="element">Bar</li> 
    28. 

  28.  
    29. 

  29.         </ul> 
    30. 

  30.  
    31. 

  31.     </div> 
    32. 

  32.  
    33. 

  33. </div> 
    34. 

  34.  
    35. 

  35. ''' 
    36. 

  36.  
    37. 

  37. from bs4 import BeautifulSoup 
    38. 

  38.  
    39. 

  39. soup = BeautifulSoup(html, 'lxml') 
    40. 

  40.  
    41. 

  41. print(soup.select('.panel .panel-heading')) 
    42. 

  42.  
    43. 

  43. print(soup.select('ul li')) 
    44. 

  44.  
    45. 

  45. print(soup.select('#list-2 .element')) 
    46. 

  46.  
    47. 

  47. print(type(soup.select('ul')[0])) 
    48. 



运行结果：




    

  1. [<div class="panel-heading"> 
    2. 

  2.  
    3. 

  3. <h4>Hello</h4> 
    4. 

  4.  
    5. 

  5. </div>] 
    6. 

  6.  
    7. 

  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. 

  8.  
    9. 

  9. [<li class="element">Foo</li>, <li class="element">Bar</li>] 
    10. 

  10.  
    11. 

  11. <class 'bs4.element.Tag'> 
    12. 



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


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


嵌套选择


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




    

  1. from bs4 import BeautifulSoup 
    2. 

  2.  
    3. 

  3. soup = BeautifulSoup(html, 'lxml') 
    4. 

  4.  
    5. 

  5. for ul in soup.select('ul'): 
    6. 

  6.  
    7. 

  7. print(ul.select('li')) 
    8. 



运行结果：




    

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

  2.  
    3. 

  3. [<li class="element">Foo</li>, <li class="element">Bar</li>] 
    4. 



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


获取属性


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




    

  1. from bs4 import BeautifulSoup 
    2. 

  2.  
    3. 

  3. soup = BeautifulSoup(html, 'lxml') 
    4. 

  4.  
    5. 

  5. for ul in soup.select('ul'): 
    6. 

  6.  
    7. 

  7.     print(ul['id']) 
    8. 

  8.  
    9. 

  9.     print(ul.attrs['id']) 
    10. 



运行结果：




    

  1. list-1 
    2. 

  2.  
    3. 

  3. list-1 
    4. 

  4.  
    5. 

  5. list-2 
    6. 

  6.  
    7. 

  7. list-2 
    8. 



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


获取文本


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




    

  1. from bs4 import BeautifulSoup 
    2. 

  2.  
    3. 

  3. soup = BeautifulSoup(html, 'lxml') 
    4. 

  4.  
    5. 

  5. for li in soup.select('li'): 
    6. 

  6.  
    7. 

  7.     print('Get Text:', li.get_text()) 
    8. 

  8.  
    9. 

  9.     print('String:', li.string) 
    10. 



运行结果：




    

  1. Get Text: Foo 
    2. 

  2.  
    3. 

  3. String: Foo 
    4. 

  4.  
    5. 

  5. Get Text: Bar 
    6. 

  6.  
    7. 

  7. String: Bar 
    8. 

  8.  
    9. 

  9. Get Text: Jay 
    10. 

  10.  
    11. 

  11. String: Jay 
    12. 

  12.  
    13. 

  13. Get Text: Foo 
    14. 

  14.  
    15. 

  15. String: Foo 
    16. 

  16.  
    17. 

  17. Get Text: Bar 
    18. 

  18.  
    19. 

  19. String: Bar 
    20. 



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


综述


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


    

  • 推荐使用lxml解析库，必要时使用html.parser
    • 

  • 标签选择筛选功能弱但是速度快
    • 

  • 建议使用find()、find_all() 查询匹配单个结果或者多个结果
    • 

  • 如果对CSS选择器熟悉的话可以使用select()选择法
    • 






本文作者：崔庆才


来源：51CTO
上一篇：Python 模块调用和global的用法

下一篇：如何在win7、win10家庭版系统中开启组策略（靠谱）