• Python bs4 BeautifulSoup库使用记录

    目录

    介绍

    安装

    初始化

    解析器 使用方法 优势

    Python标准库

    lxml HTML

    lxml XML

    html5lib

    格式化输出

    对象

    tag

    Name

    多值属性

    其他方法

    NavigableString

    BeautifulSoup

    Comment

    遍历

    子节点

    父节点

    兄弟节点

    回退和前进

    搜索

    过滤器

    字符串

    正则表达式

    列表

    方法

    find 和 find_all

    像调用find_all()一样调用tag

    其他搜索方法

    CSS选择器

    介绍

    bs4 全名 BeautifulSoup，是编写 python 爬虫常用库之一，主要用来解析 html 标签。

    安装

    pip install bs4

    初始化

    1. from bs4 import BeautifulSoup
    2.  
    3. soup = BeautifulSoup("A Html Text", "html.parser")

    两个参数：第一个参数是要解析的html文本，第二个参数是使用那种解析器，对于HTML来讲就是html.parser，这个是bs4自带的解析器。

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

    解析器 使用方法 优势

    Python标准库

    1. BeautifulSoup(html, "html.parser")
    2.  
    3. 1、Python的内置标准库
    4.  
    5. 2、执行速度适中
    6.  
    7. 3、文档容错能力强

    lxml HTML

    1. BeautifulSoup(html, "lxml")
    2.  
    3. 1、速度快
    4.  
    5. 2、文档容错能力强

    lxml XML

    1. BeautifulSoup(html, ["lxml", "xml"])
    2.  
    3. BeautifulSoup(html, "xml")
    4.  
    5. 1、速度快
    6.  
    7. 2、唯一支持XML的解析器

    html5lib

    1. BeautifulSoup(html, "html5lib")
    2.  
    3. 1、最好的容错性
    4.  
    5. 2、以浏览器的方式解析文档
    6.  
    7. 3、生成HTML5格式的文档

    格式化输出

    soup.prettify()  # prettify 有括号和没括号都可以

    对象

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

    tag

    Tag对象与 xml 或 html 原生文档中的 tag 相同。

    1. soup = BeautifulSoup('Extremely bold')
    2.  
    3. tag = soup.b
    4.  
    5. type(tag)
    6.  
    7. #

    如果不存在，则返回 None，如果存在多个，则返回第一个。

    Name

    每个 tag 都有自己的名字

    1. tag.name
    2. # 'b'
    3. Attributes
    4.  
    5. 　　tag 的属性是一个字典
    6.  
    7.  
    8. tag['class']
    9. # 'boldest'
    10.  
    11. tag.attrs
    12. # {'class': 'boldest'}
    13.  
    14. type(tag.attrs)
    15. #

    多值属性

    最常见的多值属性是class，多值属性的返回 list。

    1. soup = BeautifulSoup('
      '      )
    2.  
    3. print(soup.p['class'])  # ['body', 'strikeout']
    4.  
    5. print(soup.p.attrs)     # {'class': ['body', 'strikeout']}

    如果某个属性看起来好像有多个值,但在任何版本的HTML定义中都没有被定义为多值属性，那么Beautiful Soup会将这个属性作为字符串返回。

    1. soup = BeautifulSoup('
      '      , 'html.parser')
    2. print(soup.p['id'])    # 'my id'
    3. Text

    text 属性返回 tag 的所有字符串连成的字符串。

    其他方法

    　　tag.has_attr('id') # 返回 tag 是否包含 id 属性

    当然，以上代码还可以写成 ‘id’ in tag.attrs，之前说过，tag 的属性是一个字典。顺便提一下，has_key是老旧遗留的api，为了支持2.2之前的代码留下的。Python3已经删除了该函数。

    字符串常被包含在 tag 内，Beautiful Soup 用 NavigableString 类来包装 tag 中的字符串。但是字符串中不能包含其他 tag。

    soup = BeautifulSoup(‘Extremely bold’)

    1. s = soup.b.string
    2.  
    3. print(s)        # Extremely bold
    4.  
    5. print(type(s))  #

    BeautifulSoup

    BeautifulSoup 对象表示的是一个文档的全部内容。大部分时候，可以把它当作 Tag 对象。但是 BeautifulSoup 对象并不是真正的 HTM L或 XML 的 tag，它没有attribute属性，name 属性是一个值为“[document]”的特殊属性。

    Comment

    Comment 一般表示文档的注释部分。

    1. soup = BeautifulSoup("")
    2.  
    3. comment = soup.b.string
    4.  
    5. print(comment)          # This is a comment
    6.  
    7. print(type(comment))    #

    遍历

    子节点

    contents 属性

    contents 属性返回所有子节点的列表，包括 NavigableString 类型节点。如果节点当中有换行符，会被当做是 NavigableString 类型节点而作为一个子节点。

    NavigableString 类型节点没有 contents 属性，因为没有子节点。

    1. soup = BeautifulSoup("""
    2. test
  • """)
  • element = soup.div.contents
  • print(element) # ['\n', test, '\n']

    • children 属性

    children 属性跟 contents 属性基本一样，只不过返回的不是子节点列表，而是子节点的可迭代对象。

    descendants 属性

    descendants 属性返回 tag 的所有子孙节点。

    string 属性

    如果 tag 只有一个 NavigableString 类型子节点，那么这个 tag 可以使用 .string 得到子节点。

    如果一个 tag 仅有一个子节点，那么这个 tag 也可以使用 .string 方法，输出结果与当前唯一子节点的 .string 结果相同。

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

    1. soup = BeautifulSoup("""
    2.     
      test
  • """)
  • element = soup.p.string
  • print(element) # test
  • print(type(element)) #

    • 特别注意，为了清楚显示，一般我们会将 html 节点换行缩进显示，而在BeautifulSoup 中会被认为是一个 NavigableString 类型子节点，导致出错。上例中，如果改成 element = soup.div.string 就会出错。

    strings 和 stripped_strings 属性

    如果 tag 中包含多个字符串，可以用 strings 属性来获取。如果返回结果中要去除空行，则可以用 stripped_strings 属性。

    1. soup = BeautifulSoup("""
    2.     
            
    3.     
      test 1
    4.     
      test 2
  • """, 'html.parser')
  • element = soup.div.stripped_strings
  • print(list(element)) # ['test 1', 'test 2']

    • 父节点

    parent 属性

    parent 属性返回某个元素（tag、NavigableString）的父节点，文档的顶层节点的父节点是 BeautifulSoup 对象，BeautifulSoup 对象的父节点是 None。

    parent 属性递归得到元素的所有父辈节点，包括 BeautifulSoup 对象。

    兄弟节点

    next_sibling 和 previous_sibling

    next_sibling 返回后一个兄弟节点，previous_sibling 返回前一个兄弟节点。直接看个例子，注意别被换行缩进搅了局。

    1. soup = BeautifulSoup("""
    2.     
      test 1
      test 2test 3
  • """, 'html.parser')
  • print(soup.b.next_sibling) # test 3
  • print(soup.b.previous_sibling) #

    test 1

  • print(soup.h.next_sibling) # None
  • next_siblings 和 previous_siblings
  • 　　next_siblings 返回后面的兄弟节点
  • 　　previous_siblings　　返回前面的兄弟节点

    • 回退和前进

    把html解析看成依次解析标签的一连串事件，BeautifulSoup 提供了重现解析器初始化过程的方法。

    next_element 属性指向解析过程中下一个被解析的对象（tag 或 NavigableString）。

    previous_element 属性指向解析过程中前一个被解析的对象。

    另外还有next_elements 和 previous_elements 属性，不赘述了。

    搜索

    过滤器

    介绍 find_all() 方法前，先介绍一下过滤器的类型，这些过滤器贯穿整个搜索的API。过滤器可以被用在tag的name中，节点的属性中，字符串中或他们的混合中。

    示例使用的 html 文档如下：

    1. html = """
    3.     
      ">The Dormouse's story
    4.     
      ">Once upon a time there were three little sisters; and their names were
    5.     //example.com/elsie" class="sister" id="link1">Elsie,
    6.     //example.com/lacie" class="sister" id="link2">Lacie and
    7.     //example.com/tillie" class="sister" id="link3">Tillie
    9. """
    10.  
    11. soup = BeautifulSoup(html, 'html.parser')

    字符串

    查找所有的标签

    soup.find_all(‘b’) # [The Dormouse’s story]

    正则表达式

    传入正则表达式作为参数，返回满足正则表达式的标签。下面例子中找出所有以b开头的标签。

    1. soup.find_all(re.compile("^b"))  # [<b>The Dormouse's story]

    列表

    传入列表参数，将返回与列表中任一元素匹配的内容。下面例子中找出所有标签和标签。

    1. soup.find_all(["a", "b"])
    2. True

    True可以匹配任何值，下面的代码查找到所有的tag，但是不会返回字符串节点。

    soup.find_all(True)

    方法

    如果没有合适过滤器，那么还可以自定义一个方法，方法只接受一个元素参数，如果这个方法返回True表示当前元素匹配被找到。下面示例返回所有包含 class 属性但不包含 id 属性的标签。

    1. def has_class_but_no_id(tag):
    2.     return tag.has_attr('class') and not tag.has_attr('id')
    3.  
    4.  
    5. print(soup.find_all(has_class_but_no_id))

    返回结果：

    1. [<p class="title"><b>The Dormouse's storyb>p>, <p class="story">Once upon a time there were three little sisters; and their names were
    2.     <a class="sister" href="http://example.com/elsie" id="link1">Elsiea>,
    3.     <a class="sister" href="http://example.com/lacie" id="link2">Laciea> and
    4.     <a class="sister" href="http://example.com/tillie" id="link3">Tilliea>p>]

    这个结果乍一看不对，标签含有 id 属性，其实返回的 list 中只有2个元素，都是

    标签，标签是

    标签的子节点。

    find 和 find_all

    搜索当前 tag 的所有 tag 子节点，并判断是否符合过滤器的条件

    语法：

    1. 　　find(name=None, attrs={}, recursive=True, text=None, **kwargs)
    2.  
    3. 　　find_all(name=None, attrs={}, recursive=True, text=None, limit=None, **kwargs)

    参数：

    1. 　　name：查找所有名字为 name 的 tag，字符串对象会被自动忽略掉。上面过滤器示例中的参数都是 name 参数。当然，其他参数中也可以使用过滤器。
    2.  
    3. 　　attrs：按属性名和值查找。传入字典，key 为属性名，value 为属性值。
    4.  
    5. 　　recursive：是否递归遍历所有子孙节点，默认 True。
    6.  
    7. 　　text：用于搜索字符串，会找到 .string 方法与 text 参数值相符的tag，通常配合正则表达式使用。也就是说，虽然参数名是 text，但实际上搜索的是 string 属性。
    8.  
    9. 　　limit：限定返回列表的最大个数。
    10.  
    11. 　　kwargs：如果一个指定名字的参数不是搜索内置的参数名，搜索时会把该参数当作 tag 的属性来搜索。这里注意，如果要按 class 属性搜索，因为 class 是 python 的保留字，需要写作 class_。

    Tag 的有些属性在搜索中不能作为 kwargs 参数使用，比如 html5 中的 data-* 属性。

    1. data_soup = BeautifulSoup('
      foo!
      '      )
    2.  
    3. print(data_soup.find_all(data-foo="value"))
    4.  
    5. # SyntaxError: keyword can't be an expression

    但是可以通过 attrs 参数传递：

    1. data_soup = BeautifulSoup('
      foo!
      '      )
    2.  
    3. print(data_soup.find_all(attrs={"data-foo": "value"}))
    4.  
    5. # [
      foo!
      ]

    而按 class_ 查找时，只要一个CSS类名满足即可，如果写了多个CSS名称，那么顺序必须一致，而且不能跳跃。以下示例中，前三个可以查找到元素，后两个不可以。

    1. css_soup = BeautifulSoup('
      '      )
    2.  
    3. print(css_soup.find_all("p", class_="strikeout"))
    4.  
    5. print(css_soup.find_all("p", class_="body"))
    6.  
    7. print(css_soup.find_all("p", class_="body bold strikeout"))
    8.  
    9. # [
      ]
    10.  
    11. print(css_soup.find_all("p", class_="body strikeout"))
    12.  
    13. print(css_soup.find_all("p", class_="strikeout body"))
    14.  
    15. # []

    像调用find_all()一样调用tag

    find_all() 几乎是 BeautifulSoup 中最常用的搜索方法，所以我们定义了它的简写方法。BeautifulSoup 对象和 tag 对象可以被当作一个方法来使用，这个方法的执行结果与调用这个对象的 find_all() 方法相同，下面两行代码是等价的:

    1. soup.find_all('b')
    2.  
    3. soup('b')

    其他搜索方法

    1. find_parents()　　　　　 返回所有祖先节点
    2.  
    3. find_parent()　　　　　　返回直接父节点
    4.  
    5. find_next_siblings()　　 返回后面所有的兄弟节点
    6.  
    7. find_next_sibling()　　 返回后面的第一个兄弟节点
    8.  
    9. find_previous_siblings() 返回前面所有的兄弟节点
    10.  
    11. find_previous_sibling()　返回前面第一个兄弟节点
    12.  
    13. find_all_next()　　　　 返回节点后所有符合条件的节点
    14.  
    15. find_next()　　　　　　 返回节点后第一个符合条件的节点
    16.  
    17. find_all_previous()　　 返回节点前所有符合条件的节点
    18.  
    19. find_previous()　　　　 返回节点前所有符合条件的节点

    CSS选择器

    BeautifulSoup支持大部分的CSS选择器，这里直接用代码来演示。

    1. from bs4 import BeautifulSoup
    2.  
    3.  
    4. html = """
    6. 标题
    8.  
      标题
    9.  
    10.   
    11.    链接1
    12.    链接2
    13.    链接3
    14.   
    15.  
    16.  
    17.  
    20. """
    21.  
    22. soup = BeautifulSoup(html, 'lxml')
    23.  
    24. # 通过tag查找
    25. print(soup.select('title'))             # [标题]
    26.  
    27. # 通过tag逐层查找
    28. print(soup.select("html head title"))   # [标题]
    29.  
    30. # 通过class查找
    31. print(soup.select('.sister'))
    32. # [链接1,
    33. # 链接2,
    34. # 链接3]
    35.  
    36.  
    37. # 通过id查找
    38. print(soup.select('#link1, #link2'))
    39. # [链接1,
    40. # 链接2]
    41.  
    42.  
    43. # 组合查找
    44. print(soup.select('p #link1'))　　　　# [链接1]
    45.  
    46.  
    47. # 查找直接子标签
    48. print(soup.select("head > title"))　 # [标题]
    49.  
    50. print(soup.select("p > #link1"))　　 # [链接1]
    51.  
    52. print(soup.select("p > a:nth-of-type(2)"))　　# [链接2]
    53. # nth-of-type 是CSS选择器
    54.  
    55.  
    56.  
    57. # 查找兄弟节点（向后查找）
    58. print(soup.select("#link1 ~ .sister"))
    59. # [链接2,
    60. # 链接3]
    61.  
    62. print(soup.select("#link1 + .sister"))
    63. # [链接2]
    64.  
    65.  
    66.  
    67. # 通过属性查找
    68. print(soup.select('a[href="http://example.com/1"]'))
    69.  
    70. # ^ 以XX开头
    71. print(soup.select('a[href^="http://example.com/"]'))
    72.  
    73. # * 包含
    74. print(soup.select('a[href*=".com/"]'))
    75.  
    76. # 查找包含指定属性的标签
    77. print(soup.select('[name]'))
    78.  
    79.  
    80.  
    81. # 查找第一个元素
    82. print(soup.select_one(".sister"))
  • 相关阅读:
    Leetcode2246. 相邻字符不同的最长路径
    Linux性能优化--性能工具：系统内存
    关于pbr中镜面IBL低差异序列中的 Van Der Corput 序列
    ES6模块导入与导出的方式
    【pnpm】安装依赖基础
    轮播图动态渲染
    python爬虫快速学-4张思维图高清下载
    【JavaSE】Java数组
    JavaScript中this关键字
    Android：kotlin中Gson与JSON的泛型映射解析
  • 原文地址：https://blog.csdn.net/u012206617/article/details/132875817