Python爬虫利器：Beautiful Soup的使用（二）

时间 2019-12-07

标签 python 爬虫利器 beautiful soup 使用栏目 Python 繁體版

原文原文链接

上一篇文章介绍了 BeautifulSoup 的安装以及基本对象类型。html

本次介绍使用 bs4 对 HTML 文档树的遍历。spa

先把本文用到的例子贴上：code

str = """
<!DOCTYPE html>
<html>
<head><title>bs4 test</title></head>
<body>
    <h1>bs4 test</h1>
    <div>
        <ul>
            <li><a>PHP</a></li>
            <li><a>Python</a></li>
            <li><a>Golang</a></li>
        </ul>
    </div>
    <p><span>a</span><i>b</i><em></em></p>
</body>
</html>
"""

文档树的遍历：xml

文档树的遍历包括如下四部分：htm

子节点
父节点
兄弟节点
回退和前进

1、子节点对象

一个标签可能包含多个字符串或者其余标签，这些标签都属于子节点。要获取子节点,首先须要获得一个 Tag 对象:递归

获取一个 Tag 对象最简单的方式是用 bs4 对象点上要获取的标签的名字,同时支持链式调用。事件

bs4 = BeautifulSoup(str, "lxml")
div_tag = bs4.div
ul_tag = bs4.div.ul

.contents ：ip

tag 对象的 .contents 属性能够将 tag 的子节点以列表的方式输出,不包含孙节点:element

ul_tag.contents
# ['\n', <li><a>PHP</a></li>, '\n', <li><a>Python</a></li>, '\n', <li><a>Golang</a></li>, '\n']

字符串没有 .contents 属性,由于字符串没有子节点。

.children：

.children 生成器，能够对 tag 的直接子节点进行循环:

for child in ul_tag.children:
    print(child)
# <li><a>PHP</a></li> <li><a>Python</a></li> <li><a>Golang</a></li>

.descendants：

.descendants 属性能够对全部 tag 的子孙节点进行递归循环:

for child in ul_tag.descendants:
    print(child)

.string：

若是 tag 只有一个 NavigableString 类型子节点,那么这个 tag 可使用 .string 获得子节点。

title_tag = bs4.title 
print(title_tag.string)  # bs4 test

若是一个 tag 仅有一个子节点,那么这个 tag 也可使用 .string 方法,输出结果与当前惟一子节点（也就是 title 节点）的 .string 结果相同。

head_tag = bs4.head
print(head_tag.string)  # bs4 test

若是 tag 包含了多个子节点,tag 就没法肯定 .string 方法应该调用哪一个子节点的内容,因此输出结果是 None：

print(div_tag.string) # None

.strings 和 stripped_strings：

对于上边 tag 包含了多个子节点的问题，可使用 .strings 来循环获取：

for str in div_tag.strings:
    print(str)
# PHP   Python   Golang

.stripped_strings 能够去除多余空白内容。

2、父节点

.parent：

.parent 属性来获取某个标签或字符串的父节点，好比：

print(title_tag.parent) # <head><title>bs4 test</title></head>
h1_tag = bs4.h1
print(h1_tag.string.parent) # <h1>bs4 test</h1>

.parents：

.parents 属性能够递归获得元素的全部父辈节点。

for p in h1_tag.parents:
    print(p.name)
# body   html   [document]

3、兄弟节点

首先先看一下例子中的这一行：

#<p><span>a</span><i>b</i><em>c</em></p>

p_tag = bs4.p
print(p_tag.prettify())
#<p>
# <span>
#  a
# </span>
# <i>
#  b
# </i>
# <em>
#  c
# </em>
#</p>


<span><i><em>都是<p>的子节点，因此这三个能够被称为兄弟节点。

.next_sibling 和 .previous_sibling：

经过以上两个属性能够查询兄弟节点。

print(p_tag.i.next_sibling) # <em>c</em>
print(p_tag.i.previous_sibling) # <span>a</span>

要注意的点：

在这里<span>没有 previous_sibling 属性，由于它是同级节点中的第一个。相反，<em>没有 next_sibling 属性。

字符串“a,b,c”不是兄弟节点,由于它们的父节点不一样。

因为咱们上边的例子是写的一行，在实际中 .next_sibling 和 .previous_sibling 属性一般是字符串或空白。

若是示例是以下方式则 .next_sibling 和 .previous_sibling 获取到的是空白。

<p>
    <span>a</span>
    <i>b</i>
    <em>c</em>
</p>

.next_siblings 和 .previous_siblings：

.next_siblings 和 .previous_siblings 属性能够对当前节点的兄弟节点迭代输出。

for sibling in p_tag.span.next_siblings:
    print(repr(sibling))
#'\n'
#<i>b</i>
#'\n'
#<em>c</em>
#'\n'

for prev in p_tag.em.previous_siblings:
    print(repr(prev))
#'\n'
#<i>b</i>
#'\n'
#<span>a</span>
#'\n'

4、回退和前进

HTML解析器把文档字符串转换成一连串的事件:
打开<html>标签 -> 打开<head>标签 -> 打开<title>标签 -> 添加一段字符串 -> 关闭<title>标签 ...
Beautiful Soup提供了重现解析器初始化过程的方法。

.next_element 和 .previous_element：

.next_element 属性指向解析过程当中下一个被解析的对象(字符串或tag)。

print(h1_tag.next_element) # bs4 test
由于这个结果是在<h1>标签被解析以后的解析内容，因此输出字符串。

print(h1_tag.next_element.previous_element) # <h1>bs4 test</h1>

h1_tag.next_element 输出的是“bs4 test”字符串，由于 .previous_element 指向当前被解析的对象的前一个解析对象，因此这里输出<h1>bs4 test</h1>。

.next_elements 和 .previous_elements：

经过 .next_elements 和 .previous_elements 的迭代器能够向前或向后访问文档的解析内容。

str2 = "<p><span>a</span><i>b</i><em>c</em></p>"
bs42 = BeautifulSoup(str2, "lxml")
for element in bs42.p.next_elements:
    print(element)
# <span>a</span>
# a
# <i>b</i>
# b
# <em>c</em>
# c

以上就是本文总结的使用 Beautiful Soup 对文档遍历的相关内容。

有问题欢迎指出。关注我解锁更多 Python 干货哦！