Python爬虫之Beautiful Soup的使用

### 简介
Beautiful Soup 是一个可以从 HTML 或 XML 文件中提取数据的 Python 库。它能够通过你喜欢的转换器实现惯用的文档导航、查找、修改文档的方式。有了它，我们不用再去写一些复杂的正则表达式，只需要简单的几条语句，就可以完成网页中某个元素的提取。

### 解析器
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, "xml") | 速度快、唯一支持XML的解析器 | 需要安装C语言库 |
| html5lib | BeautifulSoup(markup, "html5lib") | 最好的容错性、以浏览器的方式解析文档、生成HTML5格式的文档 | 速度慢、不依赖外部扩展 |

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

### 基本用法
　　将一段文档传入 BeautifulSoup 的构造方法，就能得到一个文档的对象, 可以传入一段字符串或一个文件句柄。
```python
from bs4 import BeautifulSoup
soup = BeautifulSoup(open("index.html"))
soup = BeautifulSoup("<html>data</html>")
```

首先，文档被转换成Unicode，并且 HTML 的实例都被转换成 Unicode 编码。
```python
BeautifulSoup("Sacré bleu!")
<html><head></head><body>Sacré bleu!</body></html>
```

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

### 快速开始
面的一段 HTML 代码将作为例子被多次用到。这是《爱丽丝梦游仙境的》的一段内容（以后内容中简称为《爱丽丝》的文档）：
```python
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
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.

...
"""
```

使用 BeautifulSoup 解析这段代码，能够得到一个 BeautifulSoup 的对象，并能按照标准的缩进格式的结构输出：
```python
rom bs4 import BeautifulSoup
soup = BeautifulSoup(html_doc)

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

几个简单的浏览结构化数据的方法：
```python
soup.title
# <title>The Dormouse's story</title>

soup.title.name
# u'title'

soup.title.string
# u'The Dormouse's story'

soup.title.parent.name
# u'head'

soup.p
# The Dormouse's story

soup.p['class']
# u'title'

soup.a
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>

soup.find_all('a')
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

soup.find(id="link3")
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
```

从文档中找到所有`<a>`标签的链接：
```python
for link in soup.find_all('a'):
 print(link.get('href'))
 # http://example.com/elsie
 # http://example.com/lacie
 # http://example.com/tillie
```

从文档中获取所有文字内容：
```python
print(soup.get_text())
# The Dormouse's story
#
# The Dormouse's story
#
# Once upon a time there were three little sisters; and their names were
# Elsie,
# Lacie and
# Tillie;
# and they lived at the bottom of a well.
#
# ...
```

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

##### Tag
Tag 对象与 XML 或 HTML 原生文档中的 tag 相同：
```python
soup = BeautifulSoup('Extremely bold')
tag = soup.b
type(tag)
# <class 'bs4.element.Tag'>
```

##### Name
每个 tag 都有自己的名字，通过 `.name` 来获取：
```python
tag.name
# u'b'
```

如果改变了 tag 的 name，那将影响所有通过当前 Beautiful Soup 对象生成的 HTML 文档：
```python
tag.name = "blockquote"
tag
# <blockquote class="boldest">Extremely bold</blockquote>
```

##### Attributes
一个 tag 可能有很多个属性。tag `` 有一个 “class” 的属性，值为 “boldest”。tag 的属性的操作方法与字典相同：
```python
tag['class']
# u'boldest'
```

也可以直接“点”取属性, 比如：`.attrs`：
```python
tag.attrs
# {u'class': u'boldest'}
```

tag 的属性可以被添加，删除或修改。再说一次，tag 的属性操作方法与字典一样
```python
tag['class'] = 'verybold'
tag['id'] = 1
tag
# <blockquote class="verybold" id="1">Extremely bold</blockquote>

del tag['class']
del tag['id']
tag
# <blockquote>Extremely bold</blockquote>

tag['class']
# KeyError: 'class'
print(tag.get('class'))
# None
```

#### 多值属性
HTML4 定义了一系列可以包含多个值的属性。在 HTML5 中移除了一些，却增加更多。最常见的多值的属性是 class（一个 tag 可以有多个 CSS 的 class）。还有一些属性：`rel`、`rev`、`accept-charset`、`headers`、`accesskey` 在 Beautiful Soup 中多值属性的返回类型是 list：
```python
css_soup = BeautifulSoup('')
css_soup.p['class']
# ["body", "strikeout"]

css_soup = BeautifulSoup('')
css_soup.p['class']
# ["body"]
```

如果某个属性看起来好像有多个值，但在任何版本的 HTML 定义中都没有被定义为多值属性，那么 Beautiful Soup 会将这个属性作为字符串返回。
```python
id_soup = BeautifulSoup('')
id_soup.p['id']
# 'my id'
```

将 tag 转换成字符串时，多值属性会合并为一个值。
```python
rel_soup = BeautifulSoup('Back to the <a rel="index">homepage</a>')
rel_soup.a['rel']
# ['index']
rel_soup.a['rel'] = ['index', 'contents']
print(rel_soup.p)
# Back to the <a rel="index contents">homepage</a>
```

如果转换的文档是 XML 格式，那么 tag 中不包含多值属性。
```python
xml_soup = BeautifulSoup('', 'xml')
xml_soup.p['class']
# u'body strikeout'
```

### 可以遍历的字符串
字符串常被包含在 tag 内。Beautiful Soup 用 NavigableString 类来包装 tag 中的字符串：
```python
tag.string
# u'Extremely bold'
type(tag.string)
# <class 'bs4.element.NavigableString'>
```

一个 NavigableString 字符串与 Python 中的 Unicode 字符串相同，并且还支持包含在 遍历文档树 和 搜索文档树 中的一些特性。通过 `unicode()` 方法可以直接将 NavigableString 对象转换成 Unicode 字符串:
```python
unicode_string = unicode(tag.string)
unicode_string
# u'Extremely bold'
type(unicode_string)
# <type 'unicode'>
```

tag 中包含的字符串不能编辑，但是可以被替换成其它的字符串，用 `replace_with()` 方法：
```python
tag.string.replace_with("No longer bold")
tag
# <blockquote>No longer bold</blockquote>
```

NavigableString 对象支持 遍历文档树 和 搜索文档树 中定义的大部分属性，并非全部。尤其是一个字符串不能包含其它内容（tag 能够包含字符串或是其它 tag），字符串不支持 `.contents` 或 `.string` 属性或 `find()` 方法.

如果想在 Beautiful Soup 之外使用 NavigableString 对象，需要调用 unicode() 方法,将该对象转换成普通的 Unicode 字符串，否则就算 Beautiful Soup已方法已经执行结束，该对象的输出也会带有对象的引用地址。这样会浪费内存。

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

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

### 注释及特殊字符串
Tag、NavigableString、BeautifulSoup 几乎覆盖了 html 和 xml 中的所有内容，但是还有一些特殊对象。容易让人担心的内容是文档的注释部分：
```python
markup = ""
soup = BeautifulSoup(markup)
comment = soup.b.string
type(comment)
# <class 'bs4.element.Comment'>
```

Comment 对象是一个特殊类型的 NavigableString 对象：
```python
comment
# u'Hey, buddy. Want to buy a used parser'
```

但是当它出现在 HTML 文档中时，Comment 对象会使用特殊的格式输出：
```python
print(soup.b.prettify())
# 
# 
# 
```

Beautiful Soup 中定义的其它类型都可能会出现在 XML 的文档中：CData、ProcessingInstruction、Declaration、Doctype 与 Comment 对象类似，这些类都是 NavigableString 的子类，只是添加了一些额外的方法的字符串独享。下面是用 CDATA 来替代注释的例子：
```python
from bs4 import CData
cdata = CData("A CDATA block")
comment.replace_with(cdata)

print(soup.b.prettify())
# 
# <![CDATA[A CDATA block]]>
# 
```

### 遍历文档树
用一下代码举例：
```python
html_doc = """
<html><head><title>The Dormouse's story</title></head>

The Dormouse's story

...
"""

from bs4 import BeautifulSoup
soup = BeautifulSoup(html_doc)
```

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

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

#### tag的名字
操作文档树最简单的方法就是告诉它你想获取的 tag 的 name。如果想获取 `<head>` 标签，只要用 `soup.head`：
```python
soup.head
# <head><title>The Dormouse's story</title></head>

soup.title
# <title>The Dormouse's story</title>
```

这是个获取 tag 的小窍门，可以在文档树的 tag 中多次调用这个方法。下面的代码可以获取 `<body>` 标签中的第一个 `` 标签：
```python
soup.body.b
# The Dormouse's story
```

通过点取属性的方式只能获得当前名字的第一个 tag：
```python
soup.a
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>
```

如果想要得到所有的 `<a>` 标签，或是通过名字得到比一个 tag 更多的内容的时候，就需要用到 Searching the tree 中描述的方法，比如：`find_all()`：
```python
soup.find_all('a')
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
```

#### .contents 和 .children
tag 的 `.contents` 属性可以将 tag 的子节点以列表的方式输出：
```python
head_tag = soup.head
head_tag
# <head><title>The Dormouse's story</title></head>

head_tag.contents
[<title>The Dormouse's story</title>]

title_tag = head_tag.contents[0]
title_tag
# <title>The Dormouse's story</title>
title_tag.contents
# [u'The Dormouse's story']
```

BeautifulSoup 对象本身一定会包含子节点，也就是说 `<html>` 标签也是 BeautifulSoup 对象的子节点：
```python
len(soup.contents)
# 1
soup.contents[0].name
# u'html'
```

字符串没有 `.contents` 属性，因为字符串没有子节点：
```python
text = title_tag.contents[0]
text.contents
# AttributeError: 'NavigableString' object has no attribute 'contents'
```

通过tag的 `.children` 生成器，可以对 tag 的子节点进行循环：
```python
for child in title_tag.children:
    print(child)
    # The Dormouse's story
```

#### .descendants
`.contents` 和 `.children` 属性仅包含 tag 的直接子节点。例如：`<head>` 标签只有一个直接子节点 `<title>`：
```python
head_tag.contents
# [<title>The Dormouse's story</title>]
```

但是 `<title>` 标签也包含一个子节点：字符串 “The Dormouse’s story” ，这种情况下字符串 “The Dormouse’s story” 也属于 `<head>` 标签的子孙节点。`.descendants` 属性可以对所有 tag 的子孙节点进行递归循环：
```python
for child in head_tag.descendants:
 print(child)
 # <title>The Dormouse's story</title>
 # The Dormouse's story
```

上面的例子中，`<head>` 标签只有一个子节点，但是有2个子孙节点：`<head>` 节点和 `<head>` 的子节点，BeautifulSoup 有一个直接子节点（`<html>` 节点），却有很多子孙节点：
```python
len(list(soup.children))
# 1
len(list(soup.descendants))
# 25
```

#### .string
如果 tag 只有一个 NavigableString 类型子节点，那么这个 tag 可以使用 `.string` 得到子节点：
```python
title_tag.string
# u'The Dormouse's story'
```

如果一个 tag 仅有一个子节点，那么这个 tag 也可以使用 `.string` 方法，输出结果与当前唯一子节点的 `.string` 结果相同：
```python
head_tag.contents
# [<title>The Dormouse's story</title>]

head_tag.string
# u'The Dormouse's story'
```

如果 tag 包含了多个子节点，tag 就无法确定 `.string` 方法应该调用哪个子节点的内容，`.string` 的输出结果是 None：
```python
print(soup.html.string)
# None
```

#### .strings 和 stripped_strings
如果 tag 中包含多个字符串，可以使用 `.strings` 来循环获取：
```python
for string in soup.strings:
    print(repr(string))
    # u"The Dormouse's story"
    # u'\n\n'
    # u"The Dormouse's story"
    # u'\n\n'
    # u'Once upon a time there were three little sisters; and their names were\n'
    # u'Elsie'
    # u',\n'
    # u'Lacie'
    # u' and\n'
    # u'Tillie'
    # u';\nand they lived at the bottom of a well.'
    # u'\n\n'
    # u'...'
    # u'\n'
```

输出的字符串中可能包含了很多空格或空行，使用 `.stripped_strings` 可以去除多余空白内容：
```python
for string in soup.stripped_strings:
    print(repr(string))
    # u"The Dormouse's story"
    # u"The Dormouse's story"
    # u'Once upon a time there were three little sisters; and their names were'
    # u'Elsie'
    # u','
    # u'Lacie'
    # u'and'
    # u'Tillie'
    # u';\nand they lived at the bottom of a well.'
    # u'...'
```

全部是空格的行会被忽略掉，段首和段末的空白会被删除。

### 父节点
继续分析文档树，每个 tag 或字符串都有父节点：被包含在某个 tag 中。

#### .parent
通过 `.parent` 属性来获取某个元素的父节点。`<head>` 标签是 `<title>` 标签的父节点：
```python
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>` 标签：
```python
title_tag.string.parent
# <title>The Dormouse's story</title>
```

文档的顶层节点比如 `<html>` 的父节点是 BeautifulSoup 对象：
```python
html_tag = soup.html
type(html_tag.parent)
# <class 'bs4.BeautifulSoup'>
```

BeautifulSoup 对象的 `.parent` 是 None：
```python
print(soup.parent)
# None
```

#### .parents
通过元素的 `.parents` 属性可以递归得到元素的所有父辈节点，下面的例子使用了 `.parents` 方法遍历了 `<a>` 标签到根节点的所有节点：
```python
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
```

#### 兄弟节点
看一段简单的例子：
```python
sibling_soup = BeautifulSoup("<a>text1text2</a>")
print(sibling_soup.prettify())
# <html>
# <body>
# <a>
# 
# text1
# 
# 
# text2
# 
# </a>
# </body>
# </html>
```

因为 `` 标签和 `` 标签是同一层：他们是同一个元素的子节点，所以 `` 和 `` 可以被称为兄弟节点。一段文档以标准格式输出时，兄弟节点有相同的缩进级别。在代码中也可以使用这种关系。

#### .next_sibling 和 .previous_sibling
在文档树中，使用 `.next_sibling` 和 `.previous_sibling` 属性来查询兄弟节点：
```python
sibling_soup.b.next_sibling
# text2

sibling_soup.span.previous_sibling
# text1
```

`` 标签有 `.next_sibling` 属性，但是没有 `.previous_sibling` 属性，因为 `` 标签在同级节点中是第一个。同理，`` 标签有 `.previous_sibling` 属性,却没有 `.next_sibling` 属性:
```python
print(sibling_soup.b.previous_sibling)
# None
print(sibling_soup.span.next_sibling)
# None
```

例子中的字符串 “text1” 和 “text2” 不是兄弟节点，因为它们的父节点不同：
```python
sibling_soup.b.string
# u'text1'

print(sibling_soup.b.string.next_sibling)
# None
```

实际文档中的 tag 的 `.next_sibling` 和 `.previous_sibling` 属性通常是字符串或空白：
```python
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a>
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>
```

如果以为第一个 `<a>` 标签的 `.next_sibling` 结果是第二个 `<a>` 标签，那就错了，真实结果是第一个 `<a>` 标签和第二个 `<a>` 标签之间的顿号和换行符：
```python
link = soup.a
link
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>

link.next_sibling
# u',\n'
```

第二个 `<a>` 标签是顿号的 `.next_sibling` 属性：
```python
link.next_sibling.next_sibling
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
```

#### .next_siblings 和 .previous_siblings
通过 `.next_siblings` 和 `.previous_siblings` 属性可以对当前节点的兄弟节点迭代输出：
```python
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 解析器把这段字符串转换成一连串的事件： “打开 `<html>` 标签”，”打开一个 `<head>` 标签”，”打开一个 `<title>` 标签”，”添加一段字符串”，”关闭 `<title>` 标签”，”打开 `` 标签”，等等。Beautiful Soup 提供了重现解析器初始化过程的方法。

#### .next_element 和 .previous_element
next_element 属性指向解析过程中下一个被解析的对象（字符串或 tag ），结果可能与 `.next_sibling` 相同，但通常是不一样的。

这是《爱丽丝》文档中最后一个 `<a>` 标签，它的 `.next_sibling` 结果是一个字符串，因为当前的解析过程遇到了 `<a>` 标签而中断了：
```python
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.'
```

但这个 `<a>` 标签的 `.next_element` 属性结果是在 `<a>` 标签被解析之后的解析内，不是 `<a>` 标签后的句子部分，应该是字符串 “Tillie”：
```python
last_a_tag.next_element
# u'Tillie'
```

这是因为在原始文档中，字符串 “Tillie” 在分号前出现，解析器先进入 `<a>` 标签，然后是字符串 “Tillie” ，然后关闭 `</a>` 标签，然后是分号和剩余部分。分号与 `<a>` 标签在同一层级，但是字符串 “Tillie” 会被先解析。

`.previous_element` 属性刚好与 `.next_element` 相反，它指向当前被解析的对象的前一个解析对象：
```python
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` 的迭代器就可以向前或向后访问文档的解析内容，就好像文档正在被解析一样：
```python
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
```

### 搜索文档树
Beautiful Soup 定义了很多搜索方法，这里着重介绍2个：`find()` 和 `find_all()`。其它方法的参数和用法类似。
使用 `find_all()` 类似的方法可以查找到想要查找的文档内容。

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

#### 字符串
最简单的过滤器是字符串。在搜索方法中传入一个字符串参数，Beautiful Soup 会查找与字符串完整匹配的内容，下面的例子用于查找文档中所有的 `` 标签：
```python
soup.find_all('b')
# [The Dormouse's story]
```

如果传入字节码参数，Beautiful Soup 会当作 UTF-8 编码，可以传入一段 Unicode 编码来避免 Beautiful Soup 解析编码出错。

#### 正则表达式
如果传入正则表达式作为参数，Beautiful Soup 会通过正则表达式的 `match()` 来匹配内容。下面例子中找出所有以 b 开头的标签，这表示 `<body>` 和 `` 标签都应该被找到：
```python
import re
for tag in soup.find_all(re.compile("^b")):
 print(tag.name)
# body
# b
```

下面代码找出所有名字中包含 “t” 的标签：
```python
for tag in soup.find_all(re.compile("t")):
    print(tag.name)
# html
# title
```

#### 列表
如果传入列表参数，Beautiful Soup 会将与列表中任一元素匹配的内容返回。下面代码找到文档中所有 `<a>` 标签和 `` 标签：
```python
soup.find_all(["a", "b"])
# [The Dormouse's story,
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
```

#### True
True 可以匹配任何值，下面代码查找到所有的 tag，但是不会返回字符串节点：
```python
for tag in soup.find_all(True):
    print(tag.name)
# html
# head
# title
# body
# p
# b
# p
# a
# a
# a
# p
```

#### 方法
如果没有合适过滤器，那么还可以定义一个方法，方法只接受一个元素参数，如果这个方法返回 True 表示当前元素匹配并且被找到，如果不是则反回 False。

下面方法校验了当前元素，如果包含 class 属性却不包含 id 属性，那么将返回 True：
```python
def has_class_but_no_id(tag):
    return tag.has_attr('class') and not tag.has_attr('id')
```

将这个方法作为参数传入 `find_all()` 方法，将得到所有 `` 标签：
```python
soup.find_all(has_class_but_no_id)
# [The Dormouse's story,
# Once upon a time there were...,
# ...]
```

返回结果中只有 `` 标签没有 `<a>` 标签，因为 `<a>` 标签还定义了 “id” ，没有返回 `<html>` 和 `<head>`，因为 `<html>` 和 `<head>` 中没有定义 “class” 属性。

下面代码找到所有被文字包含的节点内容：
```python
from bs4 import NavigableString
def surrounded_by_strings(tag):
    return (isinstance(tag.next_element, NavigableString)
            and isinstance(tag.previous_element, NavigableString))

for tag in soup.find_all(surrounded_by_strings):
    print tag.name
# p
# a
# a
# a
# p
```

现在来了解一下搜索方法的细节。

#### find_all()
`find_all( name , attrs , recursive , text , **kwargs )`

`find_all()` 方法搜索当前 tag 的所有 tag 子节点，并判断是否符合过滤器的条件。这里有几个例子：
```python
soup.find_all("title")
# [<title>The Dormouse's story</title>]

soup.find_all("p", "title")
# [The Dormouse's story]

soup.find_all("a")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

soup.find_all(id="link2")
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

import re
soup.find(text=re.compile("sisters"))
# u'Once upon a time there were three little sisters; and their names were\n'
```

有几个方法很相似，还有几个方法是新的，参数中的 text 和 id 是什么含义？为什么 `find_all("p", "title")` 返回的是 CSS Class 为 “title” 的 `` 标签？我们来仔细看一下 `find_all()` 的参数：

#### name 参数
name 参数可以查找所有名字为 name 的 tag ，字符串对象会被自动忽略掉。

简单的用法如下：
```python
soup.find_all("title")
# [<title>The Dormouse's story</title>]
```

注意：搜索 name 参数的值可以使任一类型的过滤器：字符串、正则表达式、列表、方法或是 True。

#### keyword 参数
如果一个指定名字的参数不是搜索内置的参数名，搜索时会把该参数当作指定名字 tag 的属性来搜索，如果包含一个名字为 id 的参数，Beautiful Soup 会搜索每个 tag 的 “id” 属性：
```python
soup.find_all(id='link2')
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]
```

如果传入 href 参数，Beautiful Soup 会搜索每个 tag 的 “href” 属性：
```python
soup.find_all(href=re.compile("elsie"))
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]
```

搜索指定名字的属性时可以使用的参数值包括：字符串、正则表达式、列表、True。

下面的例子在文档树中查找所有包含 id 属性的 tag，无论 id 的值是什么：
```python
soup.find_all(id=True)
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
```

使用多个指定名字的参数可以同时过滤 tag 的多个属性：
```python
soup.find_all(href=re.compile("elsie"), id='link1')
# [<a class="sister" href="http://example.com/elsie" id="link1">three</a>]
```

有些 tag 属性在搜索不能使用，比如 HTML5 中的 `data-*` 属性：
```python
data_soup = BeautifulSoup('<div data-foo="value">foo!</div>')
data_soup.find_all(data-foo="value")
# SyntaxError: keyword can't be an expression
```

但是可以通过 `find_all()` 方法的 attrs 参数定义一个字典参数来搜索包含特殊属性的tag：
```python
data_soup.find_all(attrs={"data-foo": "value"})
# [<div data-foo="value">foo!</div>]
```

### 按CSS搜索
按照 CSS 类名搜索 tag 的功能非常实用，但标识 CSS 类名的关键字 `class` 在 Python 中是保留字，使用 class 做参数会导致语法错误。从 Beautiful Soup 的4.1.1版本开始，可以通过 `class_` 参数搜索有指定 CSS 类名的 tag ：
```python
soup.find_all("a", class_="sister")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
```

class_ 参数同样接受不同类型的过滤器：字符串、正则表达式、方法或 True：
```python
soup.find_all(class_=re.compile("itl"))
# [The Dormouse's story]

def has_six_characters(css_class):
    return css_class is not None and len(css_class) == 6

soup.find_all(class_=has_six_characters)
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
```

tag 的 class 属性是多值属性。按照 CSS 类名搜索 tag 时，可以分别搜索 tag 中的每个 CSS 类名：
```python
css_soup = BeautifulSoup('')
css_soup.find_all("p", class_="strikeout")
# []

css_soup.find_all("p", class_="body")
# []
```

搜索 class 属性时也可以通过 CSS 值完全匹配：
```python
css_soup.find_all("p", class_="body strikeout")
# []
```

完全匹配 class 的值时，如果 CSS 类名的顺序与实际不符，将搜索不到结果：
```python
soup.find_all("a", attrs={"class": "sister"})
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
```

#### text 参数
通过 text 参数可以搜搜文档中的字符串内容。与 name 参数的可选值一样，text 参数接受：字符串、正则表达式、列表、True。看例子：
```python
soup.find_all(text="Elsie")
# [u'Elsie']

soup.find_all(text=["Tillie", "Elsie", "Lacie"])
# [u'Elsie', u'Lacie', u'Tillie']

soup.find_all(text=re.compile("Dormouse"))
[u"The Dormouse's story", u"The Dormouse's story"]

def is_the_only_string_within_a_tag(s):
    ""Return True if this string is the only child of its parent tag.""
    return (s == s.parent.string)

soup.find_all(text=is_the_only_string_within_a_tag)
# [u"The Dormouse's story", u"The Dormouse's story", u'Elsie', u'Lacie', u'Tillie', u'...']
```

虽然 text 参数用于搜索字符串，还可以与其它参数混合使用来过滤 tag 。Beautiful Soup 会找到 `.string` 方法与 text 参数值相符的 tag。下面代码用来搜索内容里面包含 “Elsie” 的 `<a>` 标签：
```python
soup.find_all("a", text="Elsie")
# [<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>]
```

#### limit 参数
`find_all()` 方法返回全部的搜索结构，如果文档树很大那么搜索会很慢。如果我们不需要全部结果，可以使用 limit 参数限制返回结果的数量。效果与 SQL 中的 limit 关键字类似，当搜索到的结果数量达到 limit 的限制时，就停止搜索返回结果。

文档树中有3个 tag 符合搜索条件，但结果只返回了2个，因为我们限制了返回数量：
```python
soup.find_all("a", limit=2)
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]
```

#### recursive 参数
调用 tag 的 `find_all()` 方法时，Beautiful Soup 会检索当前 tag 的所有子孙节点，如果只想搜索 tag 的直接子节点，可以使用参数 `recursive=False`。

一段简单的文档：
```html
<html>
 <head>
 <title>
 The Dormouse's story
 </title>
 </head>
 ...
```

是否使用 recursive 参数的搜索结果：
```python
soup.html.find_all("title")
# [<title>The Dormouse's story</title>]

soup.html.find_all("title", recursive=False)
# []
```

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

这两行代码也是等价的：
```python
soup.title.find_all(text=True)
soup.title(text=True)
```

#### find()
`find( name , attrs , recursive , text , **kwargs )`

`find_all()` 方法将返回文档中符合条件的所有 tag，尽管有时候我们只想得到一个结果。比如文档中只有一个 `<body>` 标签，那么使用 `find_all()` 方法来查找 `<body>` 标签就不太合适，使用 `find_all()` 方法并设置 limit=1 参数不如直接使用 `find()` 方法。下面两行代码是等价的：
```python
soup.find_all('title', limit=1)
# [<title>The Dormouse's story</title>]

soup.find('title')
# <title>The Dormouse's story</title>
```

唯一的区别是 `find_all()` 方法的返回结果是值包含一个元素的列表，而 `find()` 方法直接返回结果。

`find_all()` 方法没有找到目标是返回空列表，`find()` 方法找不到目标时，返回 None：
```python
print(soup.find("nosuchtag"))
# None
```

`soup.head.title` 是 tag 的名字 方法的简写。这个简写的原理就是多次调用当前 tag 的 `find()` 方法：
```python
soup.head.title
# <title>The Dormouse's story</title>

soup.find("head").find("title")
# <title>The Dormouse's story</title>
```

#### find_parents() 和 find_parent()
`find_parents( name , attrs , recursive , text , **kwargs )`

`find_parent( name , attrs , recursive , text , **kwargs )`

我们已经用了很大篇幅来介绍 `find_all()` 和 `find()` 方法，Beautiful Soup 中还有10个用于搜索的 API。它们中的五个用的是与 `find_all()` 相同的搜索参数，另外5个与 `find()` 方法的搜索参数类似。区别仅是它们搜索文档的不同部分。

记住：`find_all()` 和 `find()` 只搜索当前节点的所有子节点，孙子节点等。`find_parents()` 和 `find_parent()` 用来搜索当前节点的父辈节点，搜索方法与普通 tag 的搜索方法相同，搜索文档搜索文档包含的内容。我们从一个文档中的一个叶子节点开始：
```python
a_string = soup.find(text="Lacie")
a_string
# u'Lacie'

a_string.find_parents("a")
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

a_string.find_parent("p")
# Once upon a time there were three little sisters; and their names were
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a> and
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>;
# and they lived at the bottom of a well.

a_string.find_parents("p", class="title")
# []
```

文档中的一个 `<a>` 标签是是当前叶子节点的直接父节点，所以可以被找到。还有一个 `` 标签，是目标叶子节点的间接父辈节点，所以也可以被找到。包含class值为 “title” 的 `` 标签不是不是目标叶子节点的父辈节点，所以通过 `find_parents()` 方法搜索不到。

`find_parent()` 和 `find_parents()` 方法会让人联想到 `.parent` 和 `.parents` 属性。它们之间的联系非常紧密。搜索父辈节点的方法实际上就是对 `.parents` 属性的迭代搜索。

#### ind_next_siblings() 合 find_next_sibling()
`find_next_siblings( name , attrs , recursive , text , **kwargs )`

`find_next_sibling( name , attrs , recursive , text , **kwargs )`

这2个方法通过 `.next_siblings` 属性对当 tag 的所有后面解析的兄弟 tag 节点进行迭代，`find_next_siblings()` 方法返回所有符合条件的后面的兄弟节点，`find_next_sibling()` 只返回符合条件的后面的第一个 tag 节点。
```python
first_link = soup.a
first_link
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>

first_link.find_next_siblings("a")
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

first_story_paragraph = soup.find("p", "story")
first_story_paragraph.find_next_sibling("p")
# ...
```

#### find_previous_siblings() 和 find_previous_sibling()
`find_previous_siblings( name , attrs , recursive , text , **kwargs )`

`find_previous_sibling( name , attrs , recursive , text , **kwargs )`

这2个方法通过 `.previous_siblings` 属性对当前 tag 的前面解析的兄弟 tag 节点进行迭代， `find_previous_siblings()` 方法返回所有符合条件的前面的兄弟节点，`find_previous_sibling()` 方法返回第一个符合条件的前面的兄弟节点：
```python
last_link = soup.find("a", id="link3")
last_link
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>

last_link.find_previous_siblings("a")
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]

first_story_paragraph = soup.find("p", "story")
first_story_paragraph.find_previous_sibling("p")
# The Dormouse's story
```

#### find_all_next() 和 find_next()
`find_all_next( name , attrs , recursive , text , **kwargs )`

`find_next( name , attrs , recursive , text , **kwargs )`

这2个方法通过 `.next_elements` 属性对当前 tag 的之后的 tag 和字符串进行迭代，`find_all_next()` 方法返回所有符合条件的节点，`find_next()` 方法返回第一个符合条件的节点：
```python
first_link = soup.a
first_link
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>

first_link.find_all_next(text=True)
# [u'Elsie', u',\n', u'Lacie', u' and\n', u'Tillie',
#  u';\nand they lived at the bottom of a well.', u'\n\n', u'...', u'\n']

first_link.find_next("p")
# ...
```

第一个例子中，字符串 “Elsie” 也被显示出来，尽管它被包含在我们开始查找的 `<a>` 标签的里面。第二个例子中，最后一个 `` 标签也被显示出来，尽管它与我们开始查找位置的 `<a>` 标签不属于同一部分。例子中，搜索的重点是要匹配过滤器的条件，并且在文档中出现的顺序而不是开始查找的元素的位置。

#### find_all_previous() 和 find_previous()
`find_all_previous( name , attrs , recursive , text , **kwargs )`

`find_previous( name , attrs , recursive , text , **kwargs )`

这2个方法通过 `.previous_elements` 属性对当前节点前面的 tag 和字符串进行迭代，`find_all_previous()` 方法返回所有符合条件的节点，`find_previous()` 方法返回第一个符合条件的节点。
```python
first_link = soup.a
first_link
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>

first_link.find_all_previous("p")
# [Once upon a time there were three little sisters; ...,
# The Dormouse's story]

first_link.find_previous("title")
# <title>The Dormouse's story</title>
```

### CSS选择器
Beautiful Soup 支持大部分的CSS选择器，在 Tag 或 BeautifulSoup 对象的 `.select()` 方法中传入字符串参数，即可使用 CSS 选择器的语法找到 tag：
```python
soup.select("title")
# [<title>The Dormouse's story</title>]

soup.select("p nth-of-type(3)")
# [...]
```

通过 tag 标签逐层查找：
```python
soup.select("body a")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

soup.select("html head title")
# [<title>The Dormouse's story</title>]
```

找到某个 tag 标签下的直接子标签：
```python
soup.select("head > title")
# [<title>The Dormouse's story</title>]

soup.select("p > a")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

soup.select("p > a:nth-of-type(2)")
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

soup.select("p > #link1")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]

soup.select("body > a")
# []
```

找到兄弟节点标签：
```python
soup.select("#link1 ~ .sister")
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

soup.select("#link1 + .sister")
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]
```

通过CSS的类名查找：
```python
soup.select(".sister")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

soup.select("[class~=sister]")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
```

通过tag的id查找：
```python
soup.select("#link1")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]

soup.select("a#link2")
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]
```

通过是否存在某个属性来查找：
```python
soup.select('a[href]')
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
```

通过属性的值来查找：
```python
soup.select('a[href="http://example.com/elsie"]')
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]

soup.select('a[href^="http://example.com/"]')
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

soup.select('a[href$="tillie"]')
# [<a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

soup.select('a[href*=".com/el"]')
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]
```

通过语言设置来查找：
```python
multilingual_markup = """
 Hello
 Howdy, y'all
 Pip-pip, old fruit
 Bonjour mes amis
"""
multilingual_soup = BeautifulSoup(multilingual_markup)
multilingual_soup.select('p[lang|=en]')
# [Hello,
# Howdy, y'all,
# Pip-pip, old fruit]
```
对于熟悉 CSS 选择器语法的人来说这是个非常方便的方法。Beautiful Soup 也支持 CSS 选择器 API，如果你仅仅需要 CSS 选择器的功能，那么直接使用 lxml 也可以，而且速度更快，支持更多的 CSS 选择器语法，但 Beautiful Soup 整合了 CSS 选择器的语法和自身方便使用 API。

### 修改文档树
Beautiful Soup 的强项是文档树的搜索，但同时也可以方便的修改文档树。

#### 修改tag的名称和属性
在 Attributes 的章节中已经介绍过这个功能，但是再看一遍也无妨。重命名一个 tag，改变属性的值，添加或删除属性：
```python
soup = BeautifulSoup('Extremely bold')
tag = soup.b

tag.name = "blockquote"
tag['class'] = 'verybold'
tag['id'] = 1
tag
# <blockquote class="verybold" id="1">Extremely bold</blockquote>

del tag['class']
del tag['id']
tag
# <blockquote>Extremely bold</blockquote>
```

#### 修改 .string
给 tag 的 `.string` 属性赋值，就相当于用当前的内容替代了原来的内容：
```python
markup = '<a href="http://example.com/">I linked to example.com</a>'
soup = BeautifulSoup(markup)

tag = soup.a
tag.string = "New link text."
tag
# <a href="http://example.com/">New link text.</a>
```

注意：如果当前的 tag 包含了其它 tag，那么给它的 `.string` 属性赋值会覆盖掉原有的所有内容包括子 tag 。

#### append()
`Tag.append()` 方法想 tag 中添加内容，就好像 Python 的列表的 `.append()` 方法：
```python
soup = BeautifulSoup("<a>Foo</a>")
soup.a.append("Bar")

soup
# <html><head></head><body><a>FooBar</a></body></html>
soup.a.contents
# [u'Foo', u'Bar']
```

#### BeautifulSoup.new_string() 和 .new_tag()
如果想添加一段文本内容到文档中也没问题，可以调用 Python 的 `append()` 方法或调用工厂方法 `BeautifulSoup.new_string()`：
```python
soup = BeautifulSoup("")
tag = soup.b
tag.append("Hello")
new_string = soup.new_string(" there")
tag.append(new_string)
tag
# Hello there.
tag.contents
# [u'Hello', u' there']
```

如果想要创建一段注释，或 NavigableString 的任何子类，将子类作为 `new_string()` 方法的第二个参数传入：
```python
from bs4 import Comment
new_comment = soup.new_string("Nice to see you.", Comment)
tag.append(new_comment)
tag
# Hello there
tag.contents
# [u'Hello', u' there', u'Nice to see you.']
```

创建一个 tag 最好的方法是调用工厂方法 `BeautifulSoup.new_tag()`：
```python
soup = BeautifulSoup("")
original_tag = soup.b

new_tag = soup.new_tag("a", href="http://www.example.com")
original_tag.append(new_tag)
original_tag
# <a href="http://www.example.com"></a>

new_tag.string = "Link text."
original_tag
# <a href="http://www.example.com">Link text.</a>
```

第一个参数作为 tag 的 name，是必填，其它参数选填。

#### insert()
`Tag.insert()` 方法与 `Tag.append()` 方法类似，区别是不会把新元素添加到父节点 `.contents` 属性的最后，而是把元素插入到指定的位置。与 Python 列表总的 `.insert()` 方法的用法下同：
```python
markup = '<a href="http://example.com/">I linked to example.com</a>'
soup = BeautifulSoup(markup)
tag = soup.a

tag.insert(1, "but did not endorse ")
tag
# <a href="http://example.com/">I linked to but did not endorse example.com</a>
tag.contents
# [u'I linked to ', u'but did not endorse', example.com]
```

#### insert_before() 和 insert_after()
`insert_before()` 方法在当前 tag 或文本节点前插入内容：
```python
soup = BeautifulSoup("stop")
tag = soup.new_tag("i")
tag.string = "Don't"
soup.b.string.insert_before(tag)
soup.b
# Don'tstop
```

`insert_after()` 方法在当前tag或文本节点后插入内容：
```python
soup.b.i.insert_after(soup.new_string(" ever "))
soup.b
# Don't ever stop
soup.b.contents
# [Don't, u' ever ', u'stop']
```

#### clear()
`Tag.clear()` 方法移除当前 tag 的内容：
```python
markup = '<a href="http://example.com/">I linked to example.com</a>'
soup = BeautifulSoup(markup)
tag = soup.a

tag.clear()
tag
# <a href="http://example.com/"></a>
```

#### extract()
`PageElement.extract()` 方法将当前 tag 移除文档树，并作为方法结果返回：
```python
markup = '<a href="http://example.com/">I linked to example.com</a>'
soup = BeautifulSoup(markup)
a_tag = soup.a

i_tag = soup.i.extract()

a_tag
# <a href="http://example.com/">I linked to</a>

i_tag
# example.com

print(i_tag.parent)
None
```

这个方法实际上产生了2个文档树：一个是用来解析原始文档的 BeautifulSoup 对象，另一个是被移除并且返回的 tag。被移除并返回的 tag 可以继续调用 extract 方法：
```python
my_string = i_tag.string.extract()
my_string
# u'example.com'

print(my_string.parent)
# None
i_tag
# 
```

#### decompose()
`Tag.decompose()` 方法将当前节点移除文档树并完全销毁：
```python
markup = '<a href="http://example.com/">I linked to example.com</a>'
soup = BeautifulSoup(markup)
a_tag = soup.a

soup.i.decompose()

a_tag
# <a href="http://example.com/">I linked to</a>
```

#### replace_with()
`PageElement.replace_with()` 方法移除文档树中的某段内容，并用新 tag 或文本节点替代它：
```python
markup = '<a href="http://example.com/">I linked to example.com</a>'
soup = BeautifulSoup(markup)
a_tag = soup.a

new_tag = soup.new_tag("b")
new_tag.string = "example.net"
a_tag.i.replace_with(new_tag)

a_tag
# <a href="http://example.com/">I linked to example.net</a>
```

`replace_with()` 方法返回被替代的 tag 或文本节点，可以用来浏览或添加到文档树其它地方。

#### wrap()
`PageElement.wrap()` 方法可以对指定的 tag 元素进行包装，并返回包装后的结果：
```python
soup = BeautifulSoup("I wish I was bold.")
soup.p.string.wrap(soup.new_tag("b"))
# I wish I was bold.

soup.p.wrap(soup.new_tag("div"))
# <div>I wish I was bold.</div>
```

#### unwrap()
`Tag.unwrap()` 方法与 `wrap()` 方法相反。将移除 tag 内的所有 tag 标签，该方法常被用来进行标记的解包：
```python
markup = '<a href="http://example.com/">I linked to example.com</a>'
soup = BeautifulSoup(markup)
a_tag = soup.a

a_tag.i.unwrap()
a_tag
# <a href="http://example.com/">I linked to example.com</a>
```

与 `replace_with()` 方法相同，`unwrap()` 方法返回被移除的 tag。

Python爬虫之Beautiful Soup的使用

相关文章

热门标签

热门文章