Tag 对象都有如下含有所有的成员的列表(尽管，某些实际的成员值可能为None). NavigableString对象也有下面这些成员，除了contents和 string成员。
parent上面那个 例子中,
<HEAD> Tag的parent是<HTML> Tag. <HTML> Tag 的parent是BeautifulSoup 剖析对象自己。 剖析对象的parent是None.
利用parent，你可以向前遍历剖析树。
soup.head.parent.name # u'html' soup.head.parent.parent.__class__.__name__ # 'BeautifulSoup' soup.parent == None # True
contents使用parent向前遍历树。使用contents向后遍历树。 contents是Tag的有序列表， NavigableString 对象包含在一个页面元素内。只有最高层的剖析对象和 Tag 对象有contents。 NavigableString 只有strings，不能包含子元素，因此他们也没有contents.
在上面的例子中， contents 的第一个<P> Tag是个列表，包含一个 NavigableString ("This is paragraph "), 一个<B> Tag, 和其它的 NavigableString (".")。而contents 的<B> Tag:
包含一个NavigableString ("one")的列表。
pTag = soup.p pTag.contents # [u'This is paragraph ', <b>one</b>, u'.'] pTag.contents[1].contents # [u'one'] pTag.contents[0].contents # AttributeError: 'NavigableString' object has no attribute 'contents'
string为了方便，如果一个标签只有一个子节点且是字符串类型，这个自己可以这样访问 tag.string，等同于tag.contents[0]的形式。
在上面的例子中， soup.b.string是个NavigableString对象，它的值是Unicode字符串"one".
这是剖析树中<B>Tag 的第一个string。
soup.b.string # u'one' soup.b.contents[0] # u'one'
但是soup.p.string是None, 剖析中的第一个<P> Tag 拥有多个子元素。soup.head.string也为None,
虽然<HEAD> Tag只有一个子节点，但是这个子节点是Tag类型 (<TITLE> Tag)，
不是NavigableString。
soup.p.string == None # True soup.head.string == None # True
nextSibling和previousSibling使用它们你可以跳往在剖析树中同等层次的下一个元素。
在上面的文档中，
<HEAD> Tag的nextSibling 是<BODY> Tag，
因为<BODY> Tag是在<html> Tag的下一层。
<BODY>标签的nextSibling为None,
因为<HTML>下一层没有标签是直接的在它之后。
soup.head.nextSibling.name # u'body' soup.html.nextSibling == None # True
相应的<BODY> Tag的previousSibling是<HEAD>标签，
<HEAD> Tag的previousSibling为None：
soup.body.previousSibling.name # u'head' soup.head.previousSibling == None # True
更多例子：<P> Tag的第一个nextSibling是第二个
<P> Tag。
第二个<P>Tag里的<B>Tag的previousSibling是 NavigableString"This is paragraph"。
这个NavigableString的previousSibling是None,
不会是第一个<P> Tag里面的任何元素。
soup.p.nextSibling
# <p id="secondpara" align="blah">This is paragraph <b>two</b>.</p>
secondBTag = soup.findAlll('b')[1]
secondBTag.previousSibling
# u'This is paragraph'
secondBTag.previousSibling.previousSibling == None
# True
next和previous使用它们可以按照soup处理文档的次序遍历整个文档，而不是它们在剖析树中看到那种次序。
例如<HEAD> Tag的next是<TITLE>Tag,
而不是<BODY> Tag。
这是因为在原始文档中，<TITLE>
tag 直接在<HEAD>标签之后。
soup.head.next # u'title' soup.head.nextSibling.name # u'body' soup.head.previous.name # u'html'
Where next and previous are concerned, a Tag's contents come
before its nextSibling.
通常不会用到这些成员，但有时使用它们能够非常方便地从剖析树获得不易找到的信息。
你可以像遍历list一样遍历一个标签(Tag)的contents 。
这非常有用。类似的，一个Tag的有多少child可以直接使用len(tag)而不必使用len(tag.contents)来获得。
以上面那个文档中的为例：
for i in soup.body:
print i
# <p id="firstpara" align="center">This is paragraph <b>one</b>.</p>
# <p id="secondpara" align="blah">This is paragraph <b>two</b>.</p>
len(soup.body)
# 2
len(soup.body.contents)
# 2
像剖析对象或Tag对象的成员一样使用Tag名可以很方便的操作剖析树。
前面一些例子我们已经用到了这种方式。以上述文档为例， soup.head获得文档第一个<HEAD>标签：
soup.head # <head><title>Page title</title></head>
通常，调用mytag.foo获得的是mytag的第一个child，同时必须是一个<FOO> 标签。
如果在mytag中没有<FOO> 标签，mytag.foo返回一个None。
你可以使用这中方法快速的读取剖析树：
soup.head.title # <title>Page title</title> soup.body.p.b.string # u'one'
你也可以使用这种方法快速的跳到剖析树的某个特定位置。例如，如果你担心<TITLE> tags会离奇的在<HEAD> tag之外，
你可以使用soup.title去获得一个HTML文档的标题(title)，而不必使用soup.head.title:
soup.title.string # u'Page title'
soup.p跳到文档中的第一个 <P> tag，不论它在哪里。 soup.table.tr.td 跳到文档总第一个table的第一列第一行。
这些成员实际上是下面first 方法的别名，这里更多介绍。
这里提到是因为别名使得一个定位(zoom)一个结构良好剖析树变得异常容易。
获得第一个<FOO> 标签另一种方式是使用.fooTag 而不是 .foo。
例如，soup.table.tr.td可以表示为soup.tableTag.trTag.tdTag，甚至为soup.tableTag.tr.tdTag。
如果你喜欢更明确的知道表示的意义，或者你在剖析一个标签与Beautiful Soup的方法或成员有冲突的XML文档是，使用这种方式非常有用。
from BeautifulSoup import BeautifulStoneSoup xml = '<person name="Bob"><parent rel="mother" name="Alice">' xmlSoup = BeautifulStoneSoup(xml) xmlSoup.person.parent # A Beautiful Soup member # <person name="Bob"><parent rel="mother" name="Alice"></parent></person> xmlSoup.person.parentTag # A tag name # <parent rel="mother" name="Alice"></parent>
如果你要找的标签名不是有效的Python标识符，(例如hyphenated-name)，你就需要使用first方法了。