使用BeautifulSoup4解析XML

柔情只为你懂 2022-04-15 05:35 366阅读 0赞

Beautiful Soup 是一个用来从HTML或XML文件中提取数据的Python库，它利用大家所喜欢的解析器提供了许多惯用方法用来对文档树进行导航、查找和修改。

帮助文档英文版：https://www.crummy.com/software/BeautifulSoup/bs4/doc/

帮助文档中文版：https://www.crummy.com/software/BeautifulSoup/bs4/doc.zh/

入门示例

以下是电影《爱丽丝梦游仙境》中的一段HTML内容：

20181122100852783.png

我们以此为例，对如何使用BeautifulSoup解析HTML页面内容进行简单入门示例：

  1. from bs4 import BeautifulSoup
  3. # 《爱丽丝梦游仙境》故事片段
  4. html_doc = """
  5. <html>
  6. <head><title>The Dormouse's story</title></head>
  7. <body>
  8. <p class="title"><b>The Dormouse's story</b></p>
  9. <p class="story">Once upon a time there were three little sisters; and their names were
  10. <a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
  11. <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
  12. <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
  13. and they lived at the bottom of a well.</p>
  14. <p class="story">...</p>
  15. </body>
  16. </html>
  17. """
  19. # 构造解析树
  20. soup = BeautifulSoup(html_doc, "html.parser")
  22. # 美化输出
  23. #soup.prettify())
  25. # 获取第一个 title 标签
  26. soup.title
  27. # <title>The Dormouse's story</title>
  29. # 获取第一个 title 标签的名称
  30. soup.title.name
  31. # title
  33. # 获取第一个 title 标签的文本内容
  34. soup.title.string
  35. # The Dormouse's story
  37. # 获取第一个 title 标签的父标签的名称
  38. soup.title.parent.name
  39. # head
  41. # 获取第一个 p 标签
  42. soup.p
  43. # <p class="title"><b>The Dormouse's story</b></p>
  45. # 获取第一个 p 标签的 class 属性
  46. soup.p['class']
  47. # ['title']
  49. # 获取第一个 a 标签
  50. soup.a
  51. # <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>
  53. # 查找所有的 a 标签
  54. soup.find_all('a')
  55. # [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
  56. #  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
  57. #  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
  59. # 获取所有的 a 标签的 href 属性
  60. for link in soup.find_all('a'):
  61.     print(link.get('href'))
  62. # http://example.com/elsie
  63. # http://example.com/lacie
  64. # http://example.com/tillie
  66. # 查找 id = link3 的 a 标签
  67. soup.find(id="link3")
  68. # <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
  70. # 获取解析树的文本内容
  71. print(soup.get_text())
  72. # The Dormouse's story
  73. # 
  74. # The Dormouse's story
  75. # Once upon a time there were three little sisters; and their names were
  76. # Elsie,
  77. # Lacie and
  78. # Tillie;
  79. # and they lived at the bottom of a well.
  80. # ...

解析器

Beautiful Soup除了支持Python标准库中的HTML解析器外，还支持一些第三方的解析器，其中一个就是 lxml 。

下表列出了主要的解析器，以及它们的优缺点：


































解析器

使用方法

优势

劣势

Python标准库

BeautifulSoup(markup, “html.parser”)

Python的内置标准库

执行速度适中

文档容错能力强

Python 2.7.3 or 3.2.2)前 的版本中文档容错能力差

lxml HTML 解析器

BeautifulSoup(markup, “lxml”)

速度快

文档容错能力强

需要安装C语言库

lxml XML 解析器

BeautifulSoup(markup, [“lxml”, “xml”])

BeautifulSoup(markup, “xml”)

速度快

唯一支持XML的解析器

需要安装C语言库

html5lib

BeautifulSoup(markup, “html5lib”)

最好的容错性

以浏览器的方式解析文档

生成HTML5格式的文档

速度慢

不依赖外部扩展

推荐使用lxml作为解析器，因为效率更高。 在Python2.7.3之前的版本和Python3中3.2.2之前的版本，必须安装lxml或html5lib， 因为那些Python版本的标准库中内置的HTML解析方法不够稳定。

注意：如果一段HTML或XML文档格式不正确的话，那么在不同的解析器中返回的结果可能是不一样的。

解析器之间的区别

Beautiful Soup为不同的解析器提供了相同的接口，但解析器本身是有区别的，同一篇文档被不同的解析器解析后可能会生成不同结构的树型文档，区别最大的是HTML解析器和XML解析器，看下面片段被解析成HTML结构：

  1. html_soup = BeautifulSoup("<a><b/></a>", "lxml")
  2. print(html_soup)
  3. # <html><body><a><b></b></a></body></html>

因为空标签不符合HTML标准，所以解析器把它解析成。

同样的文档使用XML解析如下(解析XML需要安装lxml库)。注意，空标签依然被保留，并且文档前添加了XML头，而不是被包含在标签内：

  1. xml_soup = BeautifulSoup("<a><b/></a>", "xml")
  2. print(xml_soup)
  3. # <?xml version="1.0" encoding="utf-8"?>
  4. # <a><b/></a>

HTML解析器之间也有区别，如果被解析的HTML文档是标准格式，那么解析器之间没有任何差别，只是解析速度不同，结果都会返回正确的文档树。

但是如果被解析文档不是标准格式，那么不同的解析器返回结果可能不同。下面例子中，使用lxml解析错误格式的文档，结果

标签被直接忽略掉了：

  1. soup = BeautifulSoup("<a></p>", "lxml")
  2. print(soup)
  3. # <html><body><a></a></body></html>

使用html5lib库解析相同文档会得到不同的结果：

  1. soup = BeautifulSoup("<a></p>", "html5lib")
  2. print(soup)
  3. # <html><head></head><body><a><p></p></a></body></html>

html5lib库没有忽略掉

标签，而是自动补全了标签，还给文档树添加了标签。

使用pyhton内置库解析结果如下:

  1. soup = BeautifulSoup("<a></p>", "html.parser")
  2. print(soup)
  3. # <a></a>

与lxml 库类似的，Python内置库忽略掉了

标签，与html5lib库不同的是标准库没有尝试创建符合标准的文档格式或将文档片段包含在标签内，与lxml不同的是标准库甚至连标签都没有尝试去添加。

因为文档片段“

”是错误格式，所以以上解析方式都能算作”正确”，html5lib库使用的是HTML5的部分标准，所以最接近”正确”，不过所有解析器的结构都能够被认为是”正常”的。

不同的解析器可能影响代码执行结果，如果在分发给别人的代码中使用了 BeautifulSoup ，那么最好注明使用了哪种解析器，以减少不必要的麻烦。

创建文档对象

将一段文档传入BeautifulSoup 的构造方法，就能得到一个文档的对象， 可以传入一段字符串或一个文件句柄。

  1. from bs4 import BeautifulSoup
  3. soup = BeautifulSoup(open("index.html"))
  4. soup = BeautifulSoup("<html>data</html>")

首先，文档被转换成Unicode，并且HTML的实例都被转换成Unicode编码。

  1. soup = BeautifulSoup("Sacré bleu!")
  2. print(soup)
  3. # <html><body><p>Sacré bleu!</p></body></html>

然后，Beautiful Soup选择最合适的解析器来解析这段文档，如果手动指定解析器那么Beautiful Soup会选择指定的解析器来解析文档。

对象的种类

Beautiful Soup将复杂HTML文档转换成一个复杂的树形结构，每个节点都是Python对象，所有对象可以归纳为4种：Tag 、NavigableString、 BeautifulSoup、Comment 。

Tag

Tag 对象与XML或HTML原生文档中的tag相同：

  1. from bs4 import BeautifulSoup
  3. soup = BeautifulSoup('<b class="boldest">Extremely bold</b>',"html.parser")
  5. # 获取第一个 b 标签
  6. tag = soup.b
  8. # 获取对象类型
  9. type(tag)
  10. # <class 'bs4.element.Tag'>
  12. # 获取标签的名称
  13. tag.name
  14. # b
  16. # 修改标签的名称
  17. tag.name = "blockquote"
  18. tag
  19. # <blockquote class="boldest">Extremely bold</blockquote>
  21. # 查看标签的 class 属性
  22. tag['class']
  23. # ['boldest']
  25. # 修改标签的 class 属性
  26. tag['class'] = 'verybold'
  28. # 查看标签的 class 属性内容
  29. tag.get('class')
  30. # verybold
  32. # 为标签新增 id 属性
  33. tag['id'] = 'title'
  34. tag
  35. # <blockquote class="verybold" id="title">Extremely bold</blockquote>
  37. # 查看标签的所有属性
  38. tag.attrs
  39. # {'class': ['verybold'], 'id': 'title'}
  41. # 删除标签的 id 属性
  42. del tag['id']
  43. tag
  44. # <blockquote class="verybold">Extremely bold</blockquote>

可遍历字符串

字符串常被包含在tag内，Beautiful Soup用 NavigableString 类来包装tag中的字符串：

  1. from bs4 import BeautifulSoup
  3. soup = BeautifulSoup('<b class="boldest">Extremely bold</b>', "html.parser")
  5. # 获取第一个 b 标签
  6. tag = soup.b
  8. # 获取标签的文本内容
  9. tag.string
  10. # Extremely bold
  12. # 获取标签的文本内容的类型
  13. type(tag.string)
  14. # <class 'bs4.element.NavigableString'>

BeautifulSoup

BeautifulSoup 对象表示的是一个文档的全部内容，大部分时候，可以把它当作 Tag 对象，它支持 遍历文档树 和 搜索文档树 中描述的大部分的方法。

因为 BeautifulSoup 对象并不是真正的HTML或XML的tag，所以它没有name和attribute属性。但有时查看它的 .name 属性是很方便的，所以 BeautifulSoup 对象包含了一个值为 “[document]” 的特殊属性 .name 。

  1. soup = BeautifulSoup('<b class="boldest">Extremely bold</b>',"html.parser")
  2. soup.name
  3. # [document]

注释及特殊字符串

Tag、NavigableString、BeautifulSoup 几乎覆盖了html和xml中的所有内容，但是还有一些特殊对象，容易让人担心的内容是文档的注释部分：

  1. markup = "<b><!--Hey, buddy. Want to buy a used parser?--></b>"
  2. soup = BeautifulSoup(markup)
  3. comment = soup.b.string
  4. type(comment)
  5. # <class 'bs4.element.Comment'>

Comment 对象是一个特殊类型的 NavigableString 对象：

  1. comment
  2. # Hey, buddy. Want to buy a used parser?

但是当它出现在HTML文档中时， Comment 对象会使用特殊的格式输出：

  1. soup.b.prettify()
  2. # <b>
  3. # <!--Hey, buddy. Want to buy a used parser?-->
  4. # </b>

Beautiful Soup中定义的其它类型都可能会出现在XML的文档中： CData，ProcessingInstruction， Declaration，Doctype。与 Comment 对象类似。这些类都是 NavigableString 的子类，只是添加了一些额外的方法的字符串独享。下面是用CDATA来替代注释的例子：

  1. from bs4 import CData
  3. cdata = CData("A CDATA block")
  4. comment.replace_with(cdata)
  6. print(soup.b.prettify())
  7. # <b>
  8. # <![CDATA[A CDATA block]]>
  9. # </b>

子节点

一个Tag可能包含多个字符串或其它的Tag，这些都是这个Tag的子节点。Beautiful Soup提供了许多操作和遍历子节点的属性。

注意： Beautiful Soup中字符串节点不支持这些属性,因为字符串没有子节点。

继续拿上面的《爱丽丝梦游仙境》的文档来做示例：

  1. from bs4 import BeautifulSoup
  3. # 《爱丽丝梦游仙境》故事片段
  4. html_doc = """
  5. <html>
  6. <head><title>The Dormouse's story</title></head>
  7. <body>
  8. <p class="title"><b>The Dormouse's story</b></p>
  9. <p class="story">Once upon a time there were three little sisters; and their names were
  10. <a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
  11. <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
  12. <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
  13. and they lived at the bottom of a well.</p>
  14. <p class="story">...</p>
  15. </body>
  16. </html>
  17. """
  19. # 构造解析树
  20. soup = BeautifulSoup(html_doc, "html.parser")
  22. # 通过点取属性的方式获得当前名字的第一个tag
  23. soup.body.p.b
  24. # <b>The Dormouse's story</b>
  26. # 查找所有的 a 标签
  27. soup.find_all('a')
  28. # [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
  29. #  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
  30. #  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
  32. # 通过 .contents 属性获取tag 的子节点列表
  33. soup.head.contents
  34. # [<title>The Dormouse's story</title>]
  36. # 通过 .children 生成器对tag的子节点进行遍历
  37. for child in soup.head.children:
  38.     print(child)
  39. # <title>The Dormouse's story</title>
  41. # 通过 .descendants 生成器对tag的后代节点进行遍历
  42. for descendant in soup.head.descendants:
  43.     print(descendant)
  44. # <title>The Dormouse's story</title>
  45. # The Dormouse's story
  47. # 通过 .string 属性获取唯一  NavigableString 类型子节点
  48. soup.head.title.string
  49. # The Dormouse's story
  51. # 通过 .string 属性获取唯一子节点的NavigableString 类型子节点
  52. soup.head.string
  53. # The Dormouse's story
  55. # 通过 .strings 属性获取 tag 中的多个字符串
  56. for string in soup.strings:
  57.     print(repr(string))
  59. # 通过 .stripped_strings 属性获取 tag 中去除多余空白内容的多个字符串
  60. for string in soup.stripped_strings:
  61.     print(repr(string))

注意：如果tag包含了多个子节点，tag就无法确定 .string 方法应该调用哪个子节点的内容， .string 的输出结果是 None 。

父节点

每个tag或字符串都有父节点，还是以上面的《爱丽丝梦游仙境》的文档来举例：

  1. from bs4 import BeautifulSoup
  3. # 《爱丽丝梦游仙境》故事片段
  4. html_doc = """
  5. <html>
  6. <head><title>The Dormouse's story</title></head>
  7. <body>
  8. <p class="title"><b>The Dormouse's story</b></p>
  9. <p class="story">Once upon a time there were three little sisters; and their names were
  10. <a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
  11. <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
  12. <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
  13. and they lived at the bottom of a well.</p>
  14. <p class="story">...</p>
  15. </body>
  16. </html>
  17. """
  19. # 构造解析树
  20. soup = BeautifulSoup(html_doc, "html.parser")
  22. # 通过 .parent 属性来获取 title 标签的父节点
  23. soup.title.parent
  24. # <head><title>The Dormouse's story</title></head>
  26. # 通过 .parent 属性来获取 title 标签的内字符串的父节点
  27. soup.title.string.parent
  28. # <title>The Dormouse's story</title>
  30. # 文档的顶层节点 <html> 的父节点是 BeautifulSoup 对象
  31. type(soup.html.parent)
  32. # <class 'bs4.BeautifulSoup'>
  34. # BeautifulSoup 对象的 .parent 是None
  35. soup.parent
  37. for parent in soup.a.parents:
  38.     print(parent.name)
  39. # p
  40. # body
  41. # html
  42. # [document]

兄弟节点

为了示例如何使用BeautifulSoup来查找兄弟节点，需要对上例中的《爱丽丝梦游仙境》文档进行修改，删掉一些换行符、字符串和标签。具体示例代码如下：

  1. from bs4 import BeautifulSoup
  3. # 《爱丽丝梦游仙境》故事片段
  4. html_doc = """
  5. <html>
  6. <body>
  7. <p class="title"><b>Schindler's List</b></p>
  8. <p class="names"><a href="http://example.com/Oskar" id="name1">Oskar Schindler</a><a href="http://example.com/Itzhak" id="name2">Itzhak Stern</a><a href="http://example.com/Helen" id="name3">Helen Hirsch</a></p>
  9. </body>
  10. </html>
  11. """
  13. # 构造解析树
  14. soup = BeautifulSoup(html_doc, "html.parser")
  16. # 获取 ID = name2 的 a 标签
  17. name2 = soup.find("a", {"id":{"name2"}})
  18. # <a href="http://example.com/Itzhak" id="name2">Itzhak Stern</a>
  20. # 获取前一个兄弟节点
  21. name1 = name2.previous_sibling
  22. # <a href="http://example.com/Oskar" id="name1">Oskar Schindler</a>
  24. # 获取前一个兄弟节点
  25. name3 = name2.next_sibling
  26. # <a href="http://example.com/Helen" id="name3">Helen Hirsch</a>
  28. name1.previous_sibling
  29. # None
  31. name3.next_sibling
  32. # None
  34. # 通过 .next_siblings 属性对当前节点的兄弟节点进行遍历
  35. for sibling in soup.find("a", {"id":{"name1"}}).next_siblings:
  36.     print(repr(sibling))
  37. # <a href="http://example.com/Itzhak" id="name2">Itzhak Stern</a>
  38. # <a href="http://example.com/Helen" id="name3">Helen Hirsch</a>
  40. # 通过  .previous_siblings 属性对当前节点的兄弟节点进行遍历
  41. for sibling in soup.find("a", {"id":{"name3"}}).previous_siblings:
  42.     print(repr(sibling))
  43. # <a href="http://example.com/Itzhak" id="name2">Itzhak Stern</a>
  44. # <a href="http://example.com/Oskar" id="name1">Oskar Schindler</a>

注意：标签之间包含的字符串、字符或者换行符等内容均会被看作节点。

回退和前进

继续用上一章节《兄弟节点》中的HTML文档进行回退和前进示例：

  1. from bs4 import BeautifulSoup
  3. # 《爱丽丝梦游仙境》故事片段
  4. html_doc = """
  5. <html>
  6. <body>
  7. <p class="title"><b>Schindler's List</b></p>
  8. <p class="names"><a href="http://example.com/Oskar" id="name1">Oskar Schindler</a><a href="http://example.com/Itzhak" id="name2">Itzhak Stern</a><a href="http://example.com/Helen" id="name3">Helen Hirsch</a></p>
  9. </body>
  10. </html>
  11. """
  13. # 构造解析树
  14. soup = BeautifulSoup(html_doc, "html.parser")
  16. # 获取 ID = name2 的 a 标签
  17. name2 = soup.find("a", {"id":{"name2"}})
  18. # <a href="http://example.com/Itzhak" id="name2">Itzhak Stern</a>
  20. # 获取前一个节点
  21. name2.previous_element
  22. # Oskar Schindler
  24. # 获取前一个节点的前一个节点
  25. name2.previous_element.previous_element
  26. # <a href="http://example.com/Oskar" id="name1">Oskar Schindler</a>
  28. # 获取后一个节点
  29. name2.next_element
  30. # Itzhak Stern
  33. # 获取后一个节点的后一个节点
  34. name2.next_element.next_element
  35. # <a href="http://example.com/Helen" id="name3">Helen Hirsch</a>
  37. # 通过 .next_elements 属性对当前节点的后面节点进行遍历
  38. for element in soup.find("a", {"id":{"name1"}}).next_elements:
  39.    print(repr(element))
  40. # 'Oskar Schindler'
  41. # <a href="http://example.com/Itzhak" id="name2">Itzhak Stern</a>
  42. # 'Itzhak Stern'
  43. # <a href="http://example.com/Helen" id="name3">Helen Hirsch</a>
  44. # 'Helen Hirsch'
  45. # '\n'
  46. # '\n'
  47. # '\n'
  49. # 通过 .previous_elements 属性对当前节点的前面节点进行遍历
  50. for element in soup.find("a", {"id":{"name1"}}).previous_elements:
  51.    print(repr(element))
  52. # <p class="names"><a href="http://example.com/Oskar" id="name1">Oskar Schindler</a><a href="http://example.com/Itzhak" id="name2">Itzhak Stern</a><a href="http://example.com/Helen" id="name3">Helen Hirsch</a></p>
  53. # '\n'
  54. # "Schindler's List"
  55. # <b>Schindler's List</b>
  56. # <p class="title"><b>Schindler's List</b></p>
  57. # '\n'
  58. # <body>
  59. # <p class="title"><b>Schindler's List</b></p>
  60. # <p class="names"><a href="http://example.com/Oskar" id="name1">Oskar Schindler</a><a href="http://example.com/Itzhak" id="name2">Itzhak Stern</a><a href="http://example.com/Helen" id="name3">Helen Hirsch</a></p>
  61. # </body>
  62. # '\n'
  63. # <html>
  64. # <body>
  65. # <p class="title"><b>Schindler's List</b></p>
  66. # <p class="names"><a href="http://example.com/Oskar" id="name1">Oskar Schindler</a><a href="http://example.com/Itzhak" id="name2">Itzhak Stern</a><a href="http://example.com/Helen" id="name3">Helen Hirsch</a></p>
  67. # </body>
  68. # </html>
  69. # '\n'

搜索文档树

  1. find_all( name , attrs , recursive , text , **kwargs )
  2. find( name , attrs , recursive , text , **kwargs )
  3. find_parents( name , attrs , recursive , text , **kwargs )
  4. find_parent( name , attrs , recursive , text , **kwargs )
  5. find_next_siblings( name , attrs , recursive , text , **kwargs )
  6. find_next_sibling( name , attrs , recursive , text , **kwargs )
  7. find_previous_siblings( name , attrs , recursive , text , **kwargs )
  8. find_previous_sibling( name , attrs , recursive , text , **kwargs )
  9. find_all_next( name , attrs , recursive , text , **kwargs )
  10. find_next( name , attrs , recursive , text , **kwargs )
  11. find_all_previous( name , attrs , recursive , text , **kwargs )
  12. find_previous( name , attrs , recursive , text , **kwargs )

Beautiful Soup定义了很多搜索方法，这里着重对 find_all() 的用法进行举例。

  1. from bs4 import BeautifulSoup
  2. from bs4 import NavigableString
  3. import re
  5. # 《爱丽丝梦游仙境》故事片段
  6. html_doc = """
  7. <html>
  8. <head><title>The Dormouse's story</title></head>
  9. <body>
  10. <p class="title"><b>The Dormouse's story</b></p>
  11. <p class="story">Once upon a time there were three little sisters; and their names were
  12. <a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
  13. <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
  14. <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
  15. and they lived at the bottom of a well.</p>
  16. <p class="story">...</p>
  17. </body>
  18. </html>
  19. """
  21. # 构造解析树
  22. soup = BeautifulSoup(html_doc, "html.parser")
  24. # 传入字符串，根据标签名称查找(b)标签
  25. soup.find_all('b')
  26. # [<b>The Dormouse's story</b>]
  28. # 传入两个字符串参数，返回 class = title 的 p 标签
  29. soup.find_all("p", "title")
  30. # [<p class="title"><b>The Dormouse's story</b></p>]
  32. # 返回 id = link2 的标签
  33. soup.find_all(id='link2')
  34. # [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]
  36. # href 匹配 elsie 并且 id = link1 的标签
  37. soup.find_all(href=re.compile("elsie"), id='link1')
  38. # [<a class="sister" href="http://example.com/elsie" id="link1">three</a>]
  40. # 返回 id = link1 的标签
  41. print(soup.find_all(attrs={"id": "link1"}))
  42. # [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]
  44. # 返回 class = sister 的 a 标签
  45. soup.find_all("a", class_="sister")
  46. # [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
  47. # <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
  48. # <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
  50. def has_six_characters(css_class):
  51.     return css_class is not None and len(css_class) == 6
  53. # 返回 class 属性为6个字符的 标签
  54. soup.find_all(class_=has_six_characters)
  55. # [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
  56. #  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
  57. #  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
  59. # 返回字符串
  60. soup.find_all(text=["Tillie", "Elsie", "Lacie"])
  62. # 返回前两个 a 标签
  63. soup.find_all("a", limit=2)
  65. # 返回 title 标签,不级联查询
  66. soup.html.find_all("title", recursive=False)
  68. # 使用 CSS 选择器进行过滤
  69. soup.select("head > title")
  71. # 传入正则表达式，根据标签名称查找匹配(以字母 b 开头)标签
  72. for tag in soup.find_all(re.compile("^b")):
  73.     print(tag.name)
  74. # body
  75. # b
  77. # 传入正则表达式，根据标签名称查找匹配(包含字母 t)标签
  78. for tag in soup.find_all(re.compile("t")):
  79.     print(tag.name)
  80. # html
  81. # title
  83. # 传入列表，根据标签名称查找(a和b)标签
  84. soup.find_all(["a", "b"])
  85. # [<b>The Dormouse's story</b>, 
  86. # <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>, 
  87. # <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, 
  88. # <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
  90. # 传入True，返回除字符串节点外的所有标签
  91. for tag in soup.find_all(True):
  92.     print(tag.name)
  94. def has_class_but_no_id(tag):
  95.     return tag.has_attr('class') and not tag.has_attr('id')
  97. # 传入自定义方法，返回仅包含 class 属性但不包含 id 属性的所有标签
  98. soup.find_all(has_class_but_no_id)

发表评论

表情：
评论列表 （有 0 条评论，366人围观）

还没有评论，来说两句吧...

相关阅读

    相关 使用DOM4j解析XML

             Dom4j是一个简单、灵活的开放源代码的库。Dom4j是由早期开发JDOM的人分离出来而后独立开发的。与JDOM不同的是，dom4j使用接口和抽象基类，虽然D

    喜欢ヅ旅行喜欢ヅ旅行/ 0 赞/ 353 阅读