这是我见过最牛逼，最全面的Beautiful Soup 4.2 教程！没有之一

概述<pstyle=\"color:rgb(34,34,34);font-family:\'PingFangSC\',\'HiraginoSansGB\',\'MicrosoftYaHei\',\'WenQuanYiMicroHei\',\'HelveticaNeue\',Arial,sans-serif;background-color:rgb(255,255,255);\"

<p ><span >进群：125240963    即可获取数十套pdf！

<p >Beautiful Soup 是一个可以从HTML或XML文件中提取数据的Python库.它能够通过你喜欢的转换器实现惯用的文档导航,查找,修改文档的方式.Beautiful Soup会帮你节省数小时甚至数天的工作时间.

<p >这篇文档介绍了BeautifulSoup4中所有主要特性,并且有小例子.让我来向你展示它适合做什么,如何工作,怎样使用,如何达到你想要的效果,和处理异常情况.

<p >文档中出现的例子在Python2.7和python3.2中的执行结果相同

<p >你可能在寻找 Beautiful Soup3 的文档,Beautiful Soup 3 目前已经停止开发,我们推荐在现在的项目中使用Beautiful Soup 4,移植到BS4

<p >寻求帮助

<p >如果你有关于BeautifulSoup的问题,可以发送邮件到 讨论组 .如果你的问题包含了一段需要转换的HTML代码,那么确保你提的问题描述中附带这段HTML文档的 代码诊断 [1]

<h1 >快速开始<p >下面的一段HTML代码将作为例子被多次用到.这是 爱丽丝梦游仙境的 的一段内容(以后内容中简称为 爱丽丝 的文档):

<p >HTML_doc = """

<p >

<p >

<p ><p >The Dormouse's story

<p ><p >Once upon a time there were three little sisters; and their names were

<p ><a href="http://example.com/elsie" id="link1">Elsie,

<p ><a href="http://example.com/lacie" id="link2">Lacie and

<p ><a href="http://example.com/tillie" id="link3">Tillie;

<p >and they lived at the bottom of a well.

<p ><p >...

<p >"""

<p >使用BeautifulSoup解析这段代码,能够得到一个 BeautifulSoup 的对象,并能按照标准的缩进格式的结构输出:

<p ><span >from <span >bs4 <span >import BeautifulSoup

<p >soup = BeautifulSoup(html_doc)

<p ><span >print(soup.prettify())

<p >#

<p >#

<p >#

<p >#

<p >#

<p ># <p >

<p >#

<p >#

<p >#

<p ># <p >

<p ># Once upon a time there were three little sisters; and their names were

<p ># <a href="http://example.com/elsie" id="link1">

<p ># Elsie

<p >#

<p >#,255);"># <a href="http://example.com/lacie" id="link2">

<p ># Lacie

<p ># and

<p ># <a href="http://example.com/tillie" id="link2">

<p ># Tillie

<p ># ; and they lived at the bottom of a well.

<p ># ...

<p >#

<p >#

<p >几个简单的浏览结构化数据的方法:

<p >soup.title

<p >#

<p >soup.title.name

<p ># u'title'

<p >soup.title.string

<p ># u'The Dormouse's story'

<p >soup.title.parent.name

<p ># u'head'

<p >soup.p

<p ># <p >The Dormouse's story

<p >soup.p['class']

<p >soup.a

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

<p >soup.find_all('a')

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

<p >soup.find(id="link3")

<p ># <a href="http://example.com/tillie" id="link3">Tillie

<p >从文档中找到所有标签的链接:

<p ><span >for link <span >in soup.find_all('a'):

<p ><span >print(link.get('href'))

<p ># http://example.com/elsie

<p ># http://example.com/lacie

<p ># http://example.com/tillie

<p >从文档中获取所有文字内容:

<p ><span >print(soup.get_text())

<p >#

<p ># Elsie,255);"># Lacie and

<p ># Tillie;

<p ># and they lived at the bottom of a well.

<p >这是你想要的吗?别着急,还有更好用的

<h1 >安装 Beautiful Soup<p >如果你用的是新版的Debain或ubuntu,那么可以通过系统的软件包管理来安装:

<p >$ apt-get install Python-bs4

<p >Beautiful Soup 4 通过PyPi发布,所以如果你无法使用系统包管理安装,那么也可以通过 easy_install 或 pip 来安装.包的名字是 beautifulsoup4,这个包兼容Python2和Python3.

<p >$ easy_install beautifulsoup4

<p >$ pip install beautifulsoup4

<p >(在PyPi中还有一个名字是 BeautifulSoup 的包,但那可能不是你想要的,那是 Beautiful Soup3 的发布版本,因为很多项目还在使用BS3,所以 BeautifulSoup 包依然有效.但是如果你在编写新项目,那么你应该安装的beautifulsoup4 )

<p >如果你没有安装 easy_install 或 pip,那你也可以 下载BS4的源码,然后通过setup.py来安装.

<p >$ Python setup.py install

<p >如果上述安装方法都行不通,Beautiful Soup的发布协议允许你将BS4的代码打包在你的项目中,这样无须安装即可使用.

<p >作者在Python2.7和Python3.2的版本下开发Beautiful Soup,理论上Beautiful Soup应该在所有当前的Python版本中正常工作

<p >安装完成后的问题

<p >Beautiful Soup发布时打包成Python2版本的代码,在Python3环境下安装时,会自动转换成Python3的代码,如果没有一个安装的过程,那么代码就不会被转换.

<p >如果代码抛出了 ImportError 的异常: “No module named HTMLParser”,这是因为你在Python3版本中执行Python2版本的代码.

<p >如果代码抛出了 ImportError 的异常: “No module named html.parser”,这是因为你在Python2版本中执行Python3版本的代码.

<p >如果遇到上述2种情况,最好的解决方法是重新安装BeautifulSoup4.

<p >如果在ROOT_TAG_NAME = u’[document]’代码处遇到 SyntaxError “Invalid syntax”错误,需要将把BS4的Python代码版本从Python2转换到Python3. 可以重新安装BS4:

<p >$ Python3 setup.py install

<p >或在bs4的目录中执行Python代码版本转换脚本

<p >$ 2to3-3.2 -w bs4

<p >安装解析器

<p >Beautiful Soup支持Python标准库中的HTML解析器,还支持一些第三方的解析器,其中一个是 lxml .根据 *** 作系统不同,可以选择下列方法来安装lxml:

<p >$ apt-get install Python-lxml

<p >$ easy_install lxml

<p >$ pip install lxml

<p >另一个可供选择的解析器是纯Python实现的 html5lib,html5lib的解析方式与浏览器相同,可以选择下列方法来安装html5lib:

<p >$ apt-get install Python-html5lib

<p >$ easy_install html5lib

<p >$ pip install html5lib

<p >下表列出了主要的解析器,以及它们的优缺点:

<ul ><li >解析器使用方法优势劣势Python标准库BeautifulSoup(markup,"html.parser")Python的内置标准库<li >执行速度适中<li >文档容错能力强<li >Python 2.7.3 or 3.2.2)前 的版本中文档容错能力差<li >lxml HTML 解析器BeautifulSoup(markup,"lxml")速度快<li >文档容错能力强<li >需要安装C语言库<p >lxml XML 解析器BeautifulSoup(markup,["lxml","xml"])

<p >BeautifulSoup(markup,"xml")

<ul ><li >速度快<li >唯一支持XML的解析器<li >需要安装C语言库<li >html5libBeautifulSoup(markup,"html5lib")最好的容错性<li >以浏览器的方式解析文档<li >生成HTML5格式的文档<li >速度慢<li >不依赖外部扩展<p >推荐使用lxml作为解析器,因为效率更高. 在Python2.7.3之前的版本和Python3中3.2.2之前的版本,必须安装lxml或html5lib,因为那些Python版本的标准库中内置的HTML解析方法不够稳定.

<p >提示: 如果一段HTML或XML文档格式不正确的话,那么在不同的解析器中返回的结果可能是不一样的,查看 解析器之间的区别 了解更多细节

<h1 >如何使用<p >将一段文档传入BeautifulSoup 的构造方法,就能得到一个文档的对象,可以传入一段字符串或一个文件句柄.

<p >soup = BeautifulSoup(open("index.html"))

<p >soup = BeautifulSoup("data")

<p >首先,文档被转换成Unicode,并且HTML的实例都被转换成Unicode编码

<p >BeautifulSoup("Sacré bleu!")

<p >Sacré bleu!

<p >然后,Beautiful Soup选择最合适的解析器来解析这段文档,如果手动指定解析器那么Beautiful Soup会选择指定的解析器来解析文档.(参考 解析成XML ).

<h1 >对象的种类<p >Beautiful Soup将复杂HTML文档转换成一个复杂的树形结构,每个节点都是Python对象,所有对象可以归纳为4种: Tag,NavigableString,BeautifulSoup,Comment .

<p >Tag

<p >Tag 对象与XML或HTML原生文档中的tag相同:

<p >soup = BeautifulSoup('<b >Extremely bold')

<p >tag = soup.b

<p >type(tag)

<p ># <class 'bs4.element.Tag'>

<p >Tag有很多方法和属性,在 遍历文档树 和 搜索文档树 中有详细解释.现在介绍一下tag中最重要的属性: name和attributes

<p >Name

<p >每个tag都有自己的名字,通过 .name 来获取:

<p >tag.name

<p ># u'b'

<p >如果改变了tag的name,那将影响所有通过当前Beautiful Soup对象生成的HTML文档:

<p >tag.name = "blockquote"

<p >tag

<p ># <blockquote >Extremely bold

<p >Attributes

<p >一个tag可能有很多个属性. tag <b > 有一个 “class” 的属性,值为 “boldest” . tag的属性的 *** 作方法与字典相同:

<p >tag['class']

<p ># u'boldest'

<p >也可以直接”点”取属性,比如: .attrs :

<p >tag.attrs

<p ># {u'class': u'boldest'}

<p >tag的属性可以被添加,删除或修改. 再说一次,tag的属性 *** 作方法与字典一样

<p >tag['class'] = 'verybold'

<p >tag['id'] = 1

<p ># <blockquote id="1">Extremely bold

<p ><span >del tag['class']

<p ><span >del tag['id']

<p >#

Extremely bold

<p ># KeyError: 'class'

<p ><span >print(tag.get('class'))

<p ># None

<p >多值属性

<p >HTML 4定义了一系列可以包含多个值的属性.在HTML5中移除了一些,却增加更多.最常见的多值的属性是 class (一个tag可以有多个CSS的class). 还有一些属性 rel,rev,accept-charset,headers,accesskey . 在Beautiful Soup中多值属性的返回类型是list:

<p >css_soup = BeautifulSoup('<p >

')

<p >css_soup.p['class']

<p ># ["body","strikeout"]

<p >css_soup = BeautifulSoup('<p >

')

<p ># ["body"]

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

<p >id_soup = BeautifulSoup('<p id="my id">

')

<p >id_soup.p['id']

<p ># 'my id'

<p >将tag转换成字符串时,多值属性会合并为一个值

<p >rel_soup = BeautifulSoup('

Back to the <a rel="index">homepage

')

<p >rel_soup.a['rel']

<p ># ['index']

<p >rel_soup.a['rel'] = ['index','contents']

<p ><span >print(rel_soup.p)

<p >#

Back to the <a rel="index contents">homepage

<p >如果转换的文档是XML格式,那么tag中不包含多值属性

<p >xml_soup = BeautifulSoup('<p >

','xml')

<p >xml_soup.p['class']

<p ># u'body strikeout'

<p >可以遍历的字符串

<p >字符串常被包含在tag内.Beautiful Soup用 NavigableString 类来包装tag中的字符串:

<p >tag.string

<p ># u'Extremely bold'

<p >type(tag.string)

<p ># <class 'bs4.element.NavigableString'>

<p >一个 NavigableString 字符串与Python中的Unicode字符串相同,并且还支持包含在 遍历文档树 和 搜索文档树 中的一些特性. 通过 unicode() 方法可以直接将 NavigableString 对象转换成Unicode字符串:

<p >unicode_string = unicode(tag.string)

<p >unicode_string

<p >type(unicode_string)

<p ># <type 'unicode'>

<p >tag中包含的字符串不能编辑,但是可以被替换成其它的字符串,用 replace_with() 方法:

<p >tag.string.replace_with("No longer bold")

<p >#

No longer bold

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

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

<p >BeautifulSoup

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

<p >因为 BeautifulSoup 对象并不是真正的HTML或XML的tag,所以它没有name和attribute属性.但有时查看它的 .name 属性是很方便的,所以 BeautifulSoup 对象包含了一个值为 “[document]” 的特殊属性 .name

<p >soup.name

<p ># u'[document]'

<p >注释及特殊字符串

<p >Tag,BeautifulSoup 几乎覆盖了html和xml中的所有内容,但是还有一些特殊对象.容易让人担心的内容是文档的注释部分:

<p >markup = ""

<p >soup = BeautifulSoup(markup)

<p >comment = soup.b.string

<p >type(comment)

<p ># <class 'bs4.element.Comment'>

<p >Comment 对象是一个特殊类型的 NavigableString 对象:

<p >comment

<p ># u'Hey,buddy. Want to buy a used parser'

<p >但是当它出现在HTML文档中时,Comment 对象会使用特殊的格式输出:

<p ><span >print(soup.b.prettify())

<p >#

<p >Beautiful Soup中定义的其它类型都可能会出现在XML的文档中: CData,ProcessingInstruction,Declaration,Doctype .与 Comment 对象类似,这些类都是 NavigableString 的子类,只是添加了一些额外的方法的字符串独享.下面是用CDATA来替代注释的例子:

<p ><span >from <span >bs4 <span >import CData

<p >cdata = CData("A CDATA block")

<p >comment.replace_with(cdata)

<p ># <![CDATA[A CDATA block]]>

<p >#

<h1 >遍历文档树<p >还拿”爱丽丝梦游仙境”的文档来做例子:

<p >通过这段例子来演示怎样从文档的一段内容找到另一段内容

<p >子节点

<p >一个Tag可能包含多个字符串或其它的Tag,这些都是这个Tag的子节点.Beautiful Soup提供了许多 *** 作和遍历子节点的属性.

<p >注意: Beautiful Soup中字符串节点不支持这些属性,因为字符串没有子节点

<p >tag的名字

<p > *** 作文档树最简单的方法就是告诉它你想获取的tag的name.如果想获取 标签,只要用 soup.head :

<p >soup.head

<p >#

<p >这是个获取tag的小窍门,可以在文档树的tag中多次调用这个方法.下面的代码可以获取标签中的第一个标签:

<p >soup.body.b

<p ># The Dormouse's story

<p >通过点取属性的方式只能获得当前名字的第一个tag:

<p >如果想要得到所有的标签,或是通过名字得到比一个tag更多的内容的时候,就需要用到 Searching the tree 中描述的方法,比如: find_all()

<p >.contents 和 .children

<p >tag的 .contents 属性可以将tag的子节点以列表的方式输出:

<p >head_tag = soup.head

<p >head_tag

<p >head_tag.contents

<p >[]

<p >title_tag = head_tag.contents[0]

<p >title_tag

<p >title_tag.contents

<p ># [u'The Dormouse's story']

<p >BeautifulSoup 对象本身一定会包含子节点,也就是说标签也是 BeautifulSoup 对象的子节点:

<p >len(soup.contents)

<p ># 1

<p >soup.contents[0].name

<p ># u'html'

<p >字符串没有 .contents 属性,因为字符串没有子节点:

<p >text = title_tag.contents[0]

<p >text.contents

<p ># AttributeError: 'NavigableString' object has no attribute 'contents'

<p >通过tag的 .children 生成器,可以对tag的子节点进行循环:

<p ><span >for child <span >in title_tag.children:

<p ><span >print(child)

<p >.descendants

<p >.contents 和 .children 属性仅包含tag的直接子节点.例如,标签只有一个直接子节点]

<p >但是

<p >

<p >...

<p >是否使用 recursive 参数的搜索结果:

<p >soup.html.find_all("title")

<p >soup.html.find_all("title",recursive=False)

<p ># []

<p >像调用 find_all() 一样调用tag

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

<p >soup("a")

<p >这两行代码也是等价的:

<p >soup.title.find_all(text=True)

<p >soup.title(text=True)

<p >find()

<p >find( name,255);">find_all() 方法将返回文档中符合条件的所有tag,尽管有时候我们只想得到一个结果.比如文档中只有一个标签,那么使用 find_all() 方法来查找标签就不太合适,使用 find_all 方法并设置 limit=1 参数不如直接使用 find() 方法.下面两行代码是等价的:

<p >soup.find_all('title',limit=1)

<p >soup.find('title')

<p >唯一的区别是 find_all() 方法的返回结果是值包含一个元素的列表,而 find() 方法直接返回结果.

<p >find_all() 方法没有找到目标是返回空列表,find() 方法找不到目标时,返回 None .

<p ><span >print(soup.find("nosuchtag"))

<p >soup.head.title 是 tag的名字 方法的简写.这个简写的原理就是多次调用当前tag的 find() 方法:

<p >soup.head.title

<p >soup.find("head").find("title")

<p >find_parents() 和 find_parent()

<p >find_parents( name,255);">find_parent( name,255);">我们已经用了很大篇幅来介绍 find_all() 和 find() 方法,Beautiful Soup中还有10个用于搜索的API.它们中的五个用的是与 find_all() 相同的搜索参数,另外5个与 find() 方法的搜索参数类似.区别仅是它们搜索文档的不同部分.

<p >记住: find_all() 和 find() 只搜索当前节点的所有子节点,孙子节点等. find_parents() 和 find_parent() 用来搜索当前节点的父辈节点,搜索方法与普通tag的搜索方法相同,搜索文档搜索文档包含的内容. 我们从一个文档中的一个叶子节点开始:

<p >a_string = soup.find(text="Lacie")

<p >a_string

<p >a_string.find_parents("a")

<p >a_string.find_parent("p")

<p ># <p >Once upon a time there were three little sisters; and their names were

<p ># <a href="http://example.com/lacie" id="link2">Lacie and

<p ># <a href="http://example.com/tillie" id="link3">Tillie;

<p ># and they lived at the bottom of a well.

<p >a_string.find_parents("p",)

<p >文档中的一个标签是是当前叶子节点的直接父节点,所以可以被找到.还有一个

标签,是目标叶子节点的间接父辈节点,所以也可以被找到.包含class值为”title”的

标签不是不是目标叶子节点的父辈节点,所以通过 find_parents() 方法搜索不到.

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

<p >find_next_siblings() 合 find_next_sibling()

<p >find_next_siblings( name,255);">find_next_sibling( name,255);">这2个方法通过 .next_siblings 属性对当tag的所有后面解析 [5] 的兄弟tag节点进行迭代,find_next_siblings() 方法返回所有符合条件的后面的兄弟节点,find_next_sibling() 只返回符合条件的后面的第一个tag节点.

<p >first_link = soup.a

<p >first_link

<p >first_link.find_next_siblings("a")

<p ># [<a href="http://example.com/lacie" id="link2">Lacie,255);">first_story_paragraph = soup.find("p","story")

<p >first_story_paragraph.find_next_sibling("p")

<p >find_prevIoUs_siblings() 和 find_prevIoUs_sibling()

<p >find_prevIoUs_siblings( name,255);">find_prevIoUs_sibling( name,255);">这2个方法通过 .prevIoUs_siblings 属性对当前tag的前面解析 [5] 的兄弟tag节点进行迭代,find_prevIoUs_siblings() 方法返回所有符合条件的前面的兄弟节点,find_prevIoUs_sibling() 方法返回第一个符合条件的前面的兄弟节点:

<p >last_link = soup.find("a",255);">last_link

<p >last_link.find_prevIoUs_siblings("a")

<p ># <a href="http://example.com/elsie" id="link1">Elsie]

<p >first_story_paragraph.find_previous_sibling("p")

<p >find_all_next() 和 find_next()

<p >find_all_next( name,255);">find_next( name,255);">这2个方法通过 .next_elements 属性对当前tag的之后的 [5] tag和字符串进行迭代,find_all_next() 方法返回所有符合条件的节点,find_next() 方法返回第一个符合条件的节点:

<p >first_link.find_all_next(text=True)

<p ># u'; and they lived at the bottom of a well.',u' ',u'...',u' ']

<p >first_link.find_next("p")

<p >第一个例子中,字符串 “Elsie”也被显示出来,尽管它被包含在我们开始查找的标签的里面.第二个例子中,最后一个

标签也被显示出来,尽管它与我们开始查找位置的标签不属于同一部分.例子中,搜索的重点是要匹配过滤器的条件,并且在文档中出现的顺序而不是开始查找的元素的位置.

<p >find_all_previous() 和 find_previous()

<p >find_all_previous( name,255);">find_previous( name,255);">这2个方法通过 .previous_elements 属性对当前节点前面 [5] 的tag和字符串进行迭代,find_all_previous() 方法返回所有符合条件的节点,find_previous() 方法返回第一个符合条件的节点.

<p >first_link.find_all_previous("p")

<p ># [<p >Once upon a time there were three little sisters; ...

,255);"># <p >The Dormouse's story

]

<p >first_link.find_previous("title")

<p >find_all_previous("p") 返回了文档中的第一段(class=”title”的那段),但还返回了第二段,

标签包含了我们开始查找的标签.不要惊讶,这段代码的功能是查找所有出现在指定标签之前的

标签,因为这个

标签包含了开始的标签,所以

标签一定是在之前出现的.

<p >CSS选择器

<p >Beautiful Soup支持大部分的CSS选择器 [6],在 Tag 或 BeautifulSoup 对象的 .select() 方法中传入字符串参数,即可使用CSS选择器的语法找到tag:

<p >soup.select("title")

<p >soup.select("p nth-of-type(3)")

<p ># [<p >...

]

<p >通过tag标签逐层查找:

<p >soup.select("body a")

<p >soup.select("html head title")

<p >找到某个tag标签下的直接子标签 [6] :

<p >soup.select("head > title")

<p >soup.select("p > a")

<p >soup.select("p > a:nth-of-type(2)")

<p >soup.select("p > #link1")

<p >soup.select("body > a")

<p >找到兄弟节点标签:

<p >soup.select("#link1 ~ .sister")

<p >soup.select("#link1 + .sister")

<p >通过CSS的类名查找:

<p >soup.select(".sister")

<p >soup.select("[class~=sister]")

<p >通过tag的id查找:

<p >soup.select("#link1")

<p >soup.select("a#link2")

<p >通过是否存在某个属性来查找:

<p >soup.select('a[href]')

<p >通过属性的值来查找:

<p >soup.select('a[href="http://example.com/elsie"]')

<p >soup.select('a[href^="http://example.com/"]')

<p >soup.select('a[href$="tillie"]')

<p ># [<a href="http://example.com/tillie" id="link3">Tillie]

<p >soup.select('a[href*=".com/el"]')

<p >通过语言设置来查找:

<p >multilingual_markup = """

<p ><p lang="en">Hello

<p ><p lang="en-us">Howdy,y'all

<p ><p lang="en-gb">Pip-pip,old fruit

<p ><p lang="fr">Bonjour mes amis

<p >multilingual_soup = BeautifulSoup(multilingual_markup)

<p >multilingual_soup.select('p[lang|=en]')

<p ># [<p lang="en">Hello

,255);"># <p lang="en-us">Howdy,y'all

,255);"># <p lang="en-gb">Pip-pip,old fruit

]

<p >对于熟悉css选择器语法的人来说这是个非常方便的方法.Beautiful Soup也支持css选择器API,如果你仅仅需要css选择器的功能,那么直接使用 lxml 也可以,而且速度更快,支持更多的css选择器语法,但Beautiful Soup整合了css选择器的语法和自身方便使用API.

<h1 >修改文档树<p >Beautiful Soup的强项是文档树的搜索,但同时也可以方便的修改文档树

<p >修改tag的名称和属性

<p >在 Attributes 的章节中已经介绍过这个功能,但是再看一遍也无妨. 重命名一个tag,改变属性的值,添加或删除属性:

<p >修改 .string

<p >给tag的 .string 属性赋值,就相当于用当前的内容替代了原来的内容:

<p >markup = '<a href="http://example.com/"&gt;I linked to example.com'

<p >tag = soup.a

<p >tag.string = "New link text."

<p ># <a href="http://example.com/"&gt;New link text.

<p >注意: 如果当前的tag包含了其它tag,那么给它的 .string 属性赋值会覆盖掉原有的所有内容包括子tag

<p >append()

<p >Tag.append() 方法想tag中添加内容,就好像Python的列表的 .append() 方法:

<p >soup = BeautifulSoup("Foo")

<p >soup.a.append("bar")

<p >soup

<p ># FooBar

<p >soup.a.contents

<p ># [u'Foo',u'bar']

<p >BeautifulSoup.new_string() 和 .new_tag()

<p >如果想添加一段文本内容到文档中也没问题,可以调用Python的 append() 方法或调用工厂方法 BeautifulSoup.new_string() :

<p >soup = BeautifulSoup("")

<p >tag.append("Hello")

<p >new_string = soup.new_string(" there")

<p >tag.append(new_string)

<p ># Hello there.

<p >tag.contents

<p ># [u'Hello',u' there']

<p >如果想要创建一段注释,或 NavigableString 的任何子类,将子类作为 new_string() 方法的第二个参数传入:

<p ><span >from <span >bs4 <span >import Comment

<p >new_comment = soup.new_string("Nice to see you.",Comment)

<p >tag.append(new_comment)

<p ># Hello there

<p color:rgb(34,255);"># 这是Beautiful Soup 4.2.1 中新增的方法

<p >创建一个tag最好的方法是调用工厂方法 BeautifulSoup.new_tag() :

<p >original_tag = soup.b

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

<p >original_tag.append(new_tag)

<p >original_tag

<p ># <a href="http://www.example.com"&gt;

<p >new_tag.string = "Link text."

<p ># <a href="http://www.example.com"&gt;Link text.

<p >第一个参数作为tag的name,是必填,其它参数选填

<p >insert()

<p >Tag.insert() 方法与 Tag.append() 方法类似,区别是不会把新元素添加到父节点 .contents 属性的最后,而是把元素插入到指定的位置.与python列表总的 .insert() 方法的用法下同:

<p >tag.insert(1,"but dID not endorse ")

<p ># <a href="http://example.com/"&gt;I linked to but did not endorse example.com

<p ># [u'I linked to ',u'but dID not endorse',example.com]

<p >insert_before() 和 insert_after()

<p >insert_before() 方法在当前tag或文本节点前插入内容:

<p >soup = BeautifulSoup("stop")

<p >tag = soup.new_tag("i")

<p >tag.string = "Don't"

<p >soup.b.string.insert_before(tag)

<p >soup.b

<p ># Don'tstop

<p >insert_after() 方法在当前tag或文本节点后插入内容:

<p >soup.b.i.insert_after(soup.new_string(" ever "))

<p ># Don't ever stop

<p >soup.b.contents

<p ># [Don't,u' ever ',u'stop']

<p >clear()

<p >Tag.clear() 方法移除当前tag的内容:

<p >tag.clear()

<p ># <a href="http://example.com/"&gt;

<p >extract()

<p >PageElement.extract() 方法将当前tag移除文档树,并作为方法结果返回:

<p >a_tag = soup.a

<p >i_tag = soup.i.extract()

<p >a_tag

<p ># <a href="http://example.com/"&gt;I linked to

<p >i_tag

<p ># example.com

<p ><span >print(i_tag.parent)

<p >None

<p >这个方法实际上产生了2个文档树: 一个是用来解析原始文档的 BeautifulSoup 对象,另一个是被移除并且返回的tag.被移除并返回的tag可以继续调用 extract 方法:

<p >my_string = i_tag.string.extract()

<p >my_string

<p ># u'example.com'

<p ><span >print(my_string.parent)

<p >#

<p >decompose()

<p >Tag.decompose() 方法将当前节点移除文档树并完全销毁:

<p >soup.i.decompose()

<p >replace_with()

<p >PageElement.replace_with() 方法移除文档树中的某段内容,并用新tag或文本节点替代它:

<p >new_tag = soup.new_tag("b")

<p >new_tag.string = "example.net"

<p >a_tag.i.replace_with(new_tag)

<p ># <a href="http://example.com/"&gt;I linked to example.net

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

<p >wrap()

<p >PageElement.wrap() 方法可以对指定的tag元素进行包装 [8],并返回包装后的结果:

<p >soup = BeautifulSoup("

I wish I was bold.

")

<p >soup.p.string.wrap(soup.new_tag("b"))

<p ># I wish I was bold.

<p >soup.p.wrap(soup.new_tag("div"))

<p >#

I wish I was bold.

<p >该方法在 Beautiful Soup 4.0.5 中添加

<p >unwrap()

<p >Tag.unwrap() 方法与 wrap() 方法相反.将移除tag内的所有tag标签,该方法常被用来进行标记的解包:

<p >a_tag.i.unwrap()

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

<p >与 replace_with() 方法相同,unwrap() 方法返回被移除的tag

<h1 >输出<p >格式化输出

<p >prettify() 方法将Beautiful Soup的文档树格式化后以Unicode编码输出,每个XML/HTML标签都独占一行

<p >soup.prettify()

<p ># ' <a href="http://example.com/"> ...'

<p ># <a href="http://example.com/">

<p ># I linked to

<p >#

<p ># example.com

<p >#

<p >BeautifulSoup 对象和它的tag节点都可以调用 prettify() 方法:

<p ><span >print(soup.a.prettify())

<p >压缩输出

<p >如果只想得到结果字符串,不重视格式,那么可以对一个 BeautifulSoup 对象或 Tag 对象使用Python的 unicode() 或 str() 方法:

<p >str(soup)

<p ># '<a href="http://example.com/"&gt;I linked to example.com'

<p >unicode(soup.a)

<p ># u'<a href="http://example.com/"&gt;I linked to example.com'

<p >str() 方法返回UTF-8编码的字符串,可以指定 编码 的设置.

<p >还可以调用 encode() 方法获得字节码或调用 decode() 方法获得Unicode.

<p >输出格式

<p >Beautiful Soup输出是会将HTML中的特殊字符转换成Unicode,比如“&lquot;”:

<p >soup = BeautifulSoup("“dammit!” he saID.")

<p >unicode(soup)

<p ># u'\u201cdammit!\u201d he saID.'

<p >如果将文档转换成字符串,Unicode编码会被编码成UTF-8.这样就无法正确显示HTML特殊字符了:

<p ># '\xe2\x80\x9cdammit!\xe2\x80\x9d he saID.'

<p >get_text()

<p >如果只想得到tag中包含的文本内容,那么可以嗲用 get_text() 方法,这个方法获取到tag中包含的所有文版内容包括子孙tag中的内容,并将结果作为Unicode字符串返回:

<p >markup = '<a href="http://example.com/"&gt;<span > I linked to example.com<span > '

<p >soup.get_text()

<p >u'<span > I linked to example.com<span > '

<p >soup.i.get_text()

<p >u'example.com'

<p >可以通过参数指定tag的文本内容的分隔符:

<p ># soup.get_text("|")

<p >u'<span > I linked to |example.com|<span > '

<p >还可以去除获得文本内容的前后空白:

<p ># soup.get_text("|",strip=True)

<p >u'I linked to|example.com'

<p >或者使用 .stripped_strings 生成器,获得文本列表后手动处理列表:

<p >[text <span >for text <span >in soup.stripped_strings]

<p ># [u'I linked to',u'example.com']

<h1 >指定文档解析器<p >如果仅是想要解析HTML文档,只要用文档创建 BeautifulSoup 对象就可以了.Beautiful Soup会自动选择一个解析器来解析文档.但是还可以通过参数指定使用那种解析器来解析当前文档.

<p >BeautifulSoup 第一个参数应该是要被解析的文档字符串或是文件句柄,第二个参数用来标识怎样解析文档.如果第二个参数为空,那么Beautiful Soup根据当前系统安装的库自动选择解析器,解析器的优先数序: lxml,HTML5lib,Python标准库.在下面两种条件下解析器优先顺序会变化:

<ul ><li >要解析的文档是什么类型: 目前支持,“HTML”,“xml”,和 “HTML5”<li >指定使用哪种解析器: 目前支持,“lxml”,“HTML5lib”,和 “HTML.parser”<p >安装解析器 章节介绍了可以使用哪种解析器,以及如何安装.

<p >如果指定的解析器没有安装,Beautiful Soup会自动选择其它方案.目前只有 lxml 解析器支持XML文档的解析,在没有安装lxml库的情况下,创建 beautifulsoup 对象时无论是否指定使用lxml,都无法得到解析后的对象

<p >解析器之间的区别

<p >Beautiful Soup为不同的解析器提供了相同的接口,但解析器本身时有区别的.同一篇文档被不同的解析器解析后可能会生成不同结构的树型文档.区别最大的是HTML解析器和XML解析器,看下面片段被解析成HTML结构:

<p >BeautifulSoup("")

<p >#

<p >因为空标签不符合HTML标准,所以解析器把它解析成

<p >同样的文档使用XML解析如下(解析XML需要安装lxml库).注意,空标签依然被保留,并且文档前添加了XML头,而不是被包含在标签内:

<p >BeautifulSoup("","xml")

<p ># <?xml version="1.0" encoding="utf-8"?>

<p >#

<p >HTML解析器之间也有区别,如果被解析的HTML文档是标准格式,那么解析器之间没有任何差别,只是解析速度不同,结果都会返回正确的文档树.

<p >但是如果被解析文档不是标准格式,那么不同的解析器返回结果可能不同.下面例子中,使用lxml解析错误格式的文档,结果

标签被直接忽略掉了:

<p >BeautifulSoup("

","lxml")

<p >#

<p >使用HTML5lib库解析相同文档会得到不同的结果:

<p HTML5lib")

<p >#

<p >HTML5lib库没有忽略掉

标签,而是自动补全了标签,还给文档树添加了标签.

<p >使用pyhton内置库解析结果如下:

<p HTML.parser")

<p >#

<p >与lxml [7] 库类似的,Python内置库忽略掉了

标签,与HTML5lib库不同的是标准库没有尝试创建符合标准的文档格式或将文档片段包含在标签内,与lxml不同的是标准库甚至连标签都没有尝试去添加.

<p >因为文档片段“

”是错误格式,所以以上解析方式都能算作”正确”,HTML5lib库使用的是HTML5的部分标准,所以最接近”正确”.不过所有解析器的结构都能够被认为是”正常”的.

<p >不同的解析器可能影响代码执行结果,如果在分发给别人的代码中使用了 BeautifulSoup,那么最好注明使用了哪种解析器,以减少不必要的麻烦.

<h1 >编码<p >任何HTML或XML文档都有自己的编码方式,比如ASCII 或 UTF-8,但是使用Beautiful Soup解析后,文档都被转换成了Unicode:

<p >markup = "Sacr<span >\xc3\xa9 bleu!"

<p >soup.h1

<p ># Sacré bleu!

<p >soup.h1.string

<p ># u'Sacr\xe9 bleu!'

<p >这不是魔术(但很神奇),Beautiful Soup用了 编码自动检测 子库来识别当前文档编码并转换成Unicode编码. BeautifulSoup 对象的 .original_enCoding 属性记录了自动识别编码的结果:

<p >soup.original_enCoding

<p >'utf-8'

<p >编码自动检测 功能大部分时候都能猜对编码格式,但有时候也会出错.有时候即使猜测正确,也是在逐个字节的遍历整个文档后才猜对的,这样很慢.如果预先知道文档编码,可以设置编码参数来减少自动检查编码出错的概率并且提高文档解析速度.在创建 BeautifulSoup 对象的时候设置 from_enCoding 参数.

<p ><span >私信小编007即可获取数十套pdf！

总结

以上是内存溢出为你收集整理的这是我见过最牛逼，最全面的Beautiful Soup 4.2 教程！没有之一全部内容，希望文章能够帮你解决这是我见过最牛逼，最全面的Beautiful Soup 4.2 教程！没有之一所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/1208928.html