BeautifulSoup的高级应用之.parent .parents .next_sibling.previous_sibling.next_siblings.previous_siblings

曾经终败给现在 2022-08-04 08:40 104阅读 0赞

[继上一篇BeautifulSoup的高级应用，主要讲解的是contents children descendants string strings stripped\_strings][BeautifulSoup_contents children descendants string strings stripped_strings]，本篇主要讲解**.parent** .**parents** .**next\_sibling** .**previous\_sibling** .**next\_siblings** .**previous\_siblings**

本篇博客继续使用上篇的html页面内容：

html_doc = """ 
 <html>
 <head><title>The Dormouse's story</title></head> 
 The Dormouse's story 
 Once upon a time there were three little sisters; and their names were 
 <a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>, 
 <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
 <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>; and they lived at the bottom of a well. 
 ... 
 </html>"""

继续分析文档树 ,每个 tag或字符串都有父节点 :被包含在某个 tag中  
**.parent**:  
通过 .parent 属性来获取某个元素的父节点.在例子html文档中,标签是标签的父节点:

title_tag = soup.title 
 title_tag
 # <title>The Dormouse's story</title> 
 title_tag.parent 
 # <head><title>The Dormouse's story</title></head>

文档title的字符串也有父节点:标签

title_tag.string.parent 
 # <title>The Dormouse's story</title>

文档的顶层节点比如的父节点是 BeautifulSoup 对象:

html_tag = soup.html 
 type(html_tag.parent) 
 # <class 'bs4.BeautifulSoup'>

BeautifulSoup 对象的 .parent 是None。

**.parents**：  
通过元素的.parents属性可以递归得到元素的所有父辈节点 , 下面的例子使用了 .parents方 法遍历了 标签到根节点 的所有节点：

link = soup.a 
 link 
 # <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a> 
 for parent in link.parents: 
 if parent is None: 
 print(parent) 
 else: 
 print(parent.name) 
 # p 
 # body 
 # html 
 # [document] 
 # None

**兄弟节点**：  
举例说明：

这里的b和c节点为兄弟节点  
.**next\_sibling** 和 .**previous\_sibling** .：  
在文档树中 ,使用 .next\_sibling 和 .previous\_sibling 属性来查询兄弟节点：

sibling_soup = BeautifulSoup("<a>text1<c>text2</c></a>")
 sibling_soup.b.next_sibling 
 # <c>text2</c> 
 sibling_soup.c.previous_sibling 
 # text1

b 标签有.next\_sibling 属性 ,但是没有 .previous\_sibling 属性 ,因为 b标签在同级节点中是第一个 .同理 ,c标签有 .previous\_sibling 属性 ,却没有 .next\_sibling 属性 。

link = soup.a link 
 # <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a> 
 link.next_sibling 
 # u',\n'

**注意**：第一个a标签的next\_sibling 属性值为 ，\\n

link.next_sibling.next_sibling 
 # <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>

第一个a标签的next\_sibling的next\_sibling 属性值为[Lacie][]

.**next\_siblings** 和 **.previous\_siblings.**：  
通过 .next\_siblings 和 .previous\_siblings 属性对当前节点的兄弟节点迭代输出：

for sibling in soup.a.next_siblings: 
 print(repr(sibling)) # u',\n' 
 # <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a> 
 # u' and\n' 
 # <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a> 
 # u'; and they lived at the bottom of a well.' 
 # None 
 for sibling in soup.find(id="link3").previous_siblings: print(repr(sibling)) 
 # ' and\n' 
 # <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a> 
 # u',\n'
 # <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a> 
 # u'Once upon a time there were three little sisters; and their names were\n' 
 # None

**回退和前进：**  
举例html如下：

<html><head><title>The Dormouse's story</title></head> The Dormouse's story

HTML 解析器把这段字符串转换成一连的事件 : “ 打开标签 ”添加一段字符串 ”,关闭 标签 ”,”打开

标签 ”, 等.Beautiful Soup提供了重现解析器初始化过程的方法

.**next\_element** 和 .**previous\_element** .  
.next\_element 属性指向解析过程中下一个被的对象 (字符串或 tag),结果可能 与 .next\_sibling 相同 ,但通常是不一样的 .

last_a_tag = soup.find("a", id="link3") 
 last_a_tag 
 # <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a> 
 last_a_tag.next_sibling 
 # '; and they lived at the bottom of a well.'

但这个 标签的 .next\_element 属性结果是在标签被解析之后的内容 ,不是 标 签后的句子部分 ,应该是字符串 ”Tillie”:

last_a_tag.next_element 
    # u'Tillie'

.previous\_element 属性刚好与.next\_element 相反 ,它指向当前被解 析的对象的前一个解析对象 :

last_a_tag.previous_element 
 # u' and\n' 
 last_a_tag.previous_element.next_element
 # <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>

.**next\_elements** 和 .**previous\_elements**：  
通过 .next\_elements 和 .previous\_elements 的迭代器就可以向前或后访问文档解析内容 ,就好像文档正在被解析一样 :

for element in last_a_tag.next_elements: print(repr(element)) 
 # u'Tillie' 
 # u';\nand they lived at the bottom of a well.' 
 # u'\n\n' 
 # ... 
 # u'...' 
 # u'\n' 
 # None

下一篇 将讲解一下BeautifulSoup的搜索文档树的高级方法。

[BeautifulSoup_contents children descendants string strings stripped_strings]: http://blog.csdn.net/winterto1990/article/details/47779337
[Lacie]: http://example.com/lacie