python爬虫开发之Beautiful Soup模块从安装到详细使用方法与实例

2023-07-29 14:55:04 74

python爬虫模块BeautifulSoup简介

简单来说，BeautifulSoup是python的一个库，最主要的功能是从网页抓取数据。官方解释如下：BeautifulSoup提供一些简单的、python式的函数用来处理导航、搜索、修改分析树等功能。它是一个工具箱，通过解析文档为用户提供需要抓取的数据，因为简单，所以不需要多少代码就可以写出一个完整的应用程序。BeautifulSoup自动将输入文档转换为Unicode编码，输出文档转换为utf-8编码。你不需要考虑编码方式，除非文档没有指定一个编码方式，这时，BeautifulSoup就不能自动识别编码方式了。然后，你仅仅需要说明一下原始编码方式就可以了。BeautifulSoup已成为和lxml、html6lib一样出色的python解释器，为用户灵活地提供不同的解析策略或强劲的速度。

python爬虫模块BeautifulSoup安装

BeautifulSoup3目前已经停止开发，推荐在现在的项目中使用BeautifulSoup4，不过它已经被移植到BS4了，也就是说导入时我们需要importbs4。所以这里我们用的版本是BeautifulSoup4.3.2(简称BS4)，另外据说BS4对Python3的支持不够好，不过我用的是Python2.7.7，如果有小伙伴用的是Python3版本，可以考虑下载BS3版本。可以利用pip或者easy_install来安装，以下两种方法均可

easy_installbeautifulsoup4

pipinstallbeautifulsoup4

如果想安装最新的版本，请直接下载安装包来手动安装，也是十分方便的方法。下载完成之后解压，运行下面的命令即可完成安装

sudopythonsetup.pyinstall

然后需要安装lxml

easy_installlxml

pipinstalllxml

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

easy_installhtml5lib

pipinstallhtml5lib

BeautifulSoup支持Python标准库中的HTML解析器,还支持一些第三方的解析器，如果我们不安装它，则Python会使用Python默认的解析器，lxml解析器更加强大，速度更快，推荐安装。

解析器	使用方法	优势	劣势
Python标准库	BeautifulSoup(markup,“html.parser”)	Python的内置标准库执行速度适中文档容错能力强	Python2.7.3or3.2.2)前的版本中文档容错能力差
lxmlHTML解析器	BeautifulSoup(markup,“lxml”)	速度快文档容错能力强	需要安装C语言库
lxmlXML解析器	BeautifulSoup(markup,[“lxml”,“xml”])BeautifulSoup(markup,“xml”)	速度快唯一支持XML的解析器	需要安装C语言库
html5lib	BeautifulSoup(markup,“html5lib”)	最好的容错性以浏览器的方式解析文档生成HTML5格式的文档	速度慢

创建BeautifulSoup对象

首先必须要导入bs4库

frombs4importBeautifulSoup

我们创建一个字符串，后面的例子我们便会用它来演示

html="""
TheDormouse'sstory

TheDormouse'sstory
Onceuponatimetherewerethreelittlesisters;andtheirnameswere
,
Lacieand
Tillie;
andtheylivedatthebottomofawell.
...
"""

创建beautifulsoup对象

soup=BeautifulSoup(html)

另外，我们还可以用本地HTML文件来创建对象，例如

soup=BeautifulSoup(open('index.html'))

上面这句代码便是将本地index.html文件打开，用它来创建soup对象。下面我们来打印一下soup对象的内容，格式化输出

printsoup.prettify()

指定编码：当html为其他类型编码（非utf-8和ascii），比如GB2312的话，则需要指定相应的字符编码，BeautifulSoup才能正确解析。

htmlCharset="GB2312"
soup=BeautifulSoup(respHtml,fromEncoding=htmlCharset)

#!/usr/bin/python
#-*-coding:UTF-8-*-
frombs4importBeautifulSoup
importre

#待分析字符串
html_doc="""


TheDormouse'sstory




TheDormouse'sstory


Onceuponatimetherewerethreelittlesisters;andtheirnameswere
Elsie,
Lacie
and
Tillie;
andtheylivedatthebottomofawell.

...
"""

#html字符串创建BeautifulSoup对象
soup=BeautifulSoup(html_doc,'html.parser',from_encoding='utf-8')

#输出第一个title标签
printsoup.title

#输出第一个title标签的标签名称
printsoup.title.name

#输出第一个title标签的包含内容
printsoup.title.string

#输出第一个title标签的父标签的标签名称
printsoup.title.parent.name

#输出第一个p标签
printsoup.p

#输出第一个p标签的class属性内容
printsoup.p['class']

#输出第一个a标签的href属性内容
printsoup.a['href']
'''
soup的属性可以被添加,删除或修改.再说一次,soup的属性操作方法与字典一样
'''
#修改第一个a标签的href属性为http://www.baidu.com/
soup.a['href']='http://www.baidu.com/'

#给第一个a标签添加name属性
soup.a['name']=u'百度'

#删除第一个a标签的class属性为
delsoup.a['class']

##输出第一个p标签的所有子节点
printsoup.p.contents

#输出第一个a标签
printsoup.a

#输出所有的a标签，以列表形式显示
printsoup.find_all('a')

#输出第一个id属性等于link3的a标签
printsoup.find(id="link3")

#获取所有文字内容
print(soup.get_text())

#输出第一个a标签的所有属性信息
printsoup.a.attrs

forlinkinsoup.find_all('a'):
#获取link的href属性内容
print(link.get('href'))

#对soup.p的子节点进行循环输出
forchildinsoup.p.children:
print(child)

#正则匹配，名字中带有b的标签
fortaginsoup.find_all(re.compile("b")):
print(tag.name)

importbs4#导入BeautifulSoup库Soup=BeautifulSoup(html)#其中html可以是字符串，也可以是句柄需要注意的是，BeautifulSoup会自动检测传入文件的编码格式，然后转化为Unicode格式通过如上两句话，BS自动把文档生成为如上图中的解析树。

BeautifulSoup四大对象种类

BeautifulSoup将复杂HTML文档转换成一个复杂的树形结构,每个节点都是Python对象,所有对象可以归纳为4种:

Tag
NavigableString
BeautifulSoup
Comment

（1）Tag

Tag是什么？通俗点讲就是HTML中的一个个标签，例如

TheDormouse'sstory
jb51

上面的titlea等等HTML标签加上里面包括的内容就是Tag，下面我们来感受一下怎样用BeautifulSoup来方便地获取Tags下面每一段代码中注释部分即为运行结果

printsoup.title
#TheDormouse'sstory

printsoup.head
#TheDormouse'sstory

printsoup.a
#

printsoup.p
#TheDormouse'sstory

利用soup加标签名轻松地获取这些标签的内容，是不是感觉比正则表达式方便多了？不过有一点是，它查找的是在所有内容中的第一个符合要求的标签，如果要查询所有的标签，我们在后面进行介绍。soup.title得到的是title标签，soup.p得到的是文档中的第一个p标签，要想得到所有标签，得用find_all函数。find_all函数返回的是一个序列，可以对它进行循环，依次得到想到的东西.。我们可以验证一下这些对象的类型

printtype(soup.a)
#

对于Tag，它有两个重要的属性，是name和attrs

name

printsoup.name
printsoup.head.name
#[document]
#head

soup对象本身比较特殊，它的name即为[document]，对于其他内部标签，输出的值便为标签本身的名称。attrs

printsoup.p.attrs
#{'class':['title'],'name':'dromouse'}

在这里，我们把p标签的所有属性打印输出了出来，得到的类型是一个字典。如果我们想要单独获取某个属性，可以这样，例如我们获取它的class叫什么

printsoup.p['class']
#['title']

还可以这样，利用get方法，传入属性的名称，二者是等价的

printsoup.p.get('class')
#['title']

我们可以对这些属性和内容等等进行修改，例如

soup.p['class']="newClass"
printsoup.p
#TheDormouse'sstory

还可以对这个属性进行删除，例如

delsoup.p['class']
printsoup.p
#TheDormouse'sstory

不过，对于修改删除的操作，不是我们的主要用途，在此不做详细介绍了，如果有需要，请查看前面提供的官方文档

head=soup.find('head')
#head=soup.head
#head=soup.contents[0].contents[0]
printhead

html=soup.contents[0]#...
head=html.contents[0]#...
body=html.contents[1]#...

可以通过Tag.attrs访问，返回字典结构的属性。或者Tag.name这样访问特定属性值，如果是多值属性则以列表形式返回。

（2）NavigableString

既然我们已经得到了标签的内容，那么问题来了，我们要想获取标签内部的文字怎么办呢？很简单，用.string即可，例如

printsoup.p.string
#TheDormouse'sstory

这样我们就轻松获取到了标签里面的内容，想想如果用正则表达式要多麻烦。它的类型是一个NavigableString，翻译过来叫可以遍历的字符串，不过我们最好还是称它英文名字吧。来检查一下它的类型

printtype(soup.p.string)
#

（3）BeautifulSoup

BeautifulSoup对象表示的是一个文档的全部内容.大部分时候,可以把它当作Tag对象，是一个特殊的Tag，我们可以分别获取它的类型，名称，以及属性来感受一下

printtype(soup.name)
#
printsoup.name
#[document]
printsoup.attrs
#{}空字典

（4）Comment

Comment对象是一个特殊类型的NavigableString对象，其实输出的内容仍然不包括注释符号，但是如果不好好处理它，可能会对我们的文本处理造成意想不到的麻烦。我们找一个带注释的标签

printsoup.a
printsoup.a.string
printtype(soup.a.string)

运行结果如下

Elsie

a标签里的内容实际上是注释，但是如果我们利用.string来输出它的内容，我们发现它已经把注释符号去掉了，所以这可能会给我们带来不必要的麻烦。另外我们打印输出下它的类型，发现它是一个Comment类型，所以，我们在使用前最好做一下判断，判断代码如下

iftype(soup.a.string)==bs4.element.Comment:
printsoup.a.string

上面的代码中，我们首先判断了它的类型，是否为Comment类型，然后再进行其他操作，如打印输出。

BeautifulSoup模块遍历文档树

（1）直接子节点

Tag.Tag_child1：直接通过下标名称访问子节点。Tag.contents：以列表形式返回所有子节点。Tag.children：生成器，可用于循环访问：forchildinTag.children要点：.contents.children属性.contentstag的.content属性可以将tag的子节点以列表的方式输出。可以使用[num]的形式获得。使用contents向后遍历树，使用parent向前遍历树

printsoup.head.contents
#[TheDormouse'sstory]

输出方式为列表，我们可以用列表索引来获取它的某一个元素

printsoup.head.contents[0]
#TheDormouse'sstory

.children它返回的不是一个list，不过我们可以通过遍历获取所有子节点。我们打印输出.children看一下，可以发现它是一个list生成器对象。可以使用list可以将其转化为列表。当然可以使用for语句遍历里面的孩子。

printsoup.head.children
#

我们怎样获得里面的内容呢？很简单，遍历一下就好了，代码及结果如下

forchildin soup.body.children:
printchild

TheDormouse'sstory

Onceuponatimetherewerethreelittlesisters;andtheirnameswere
,
Lacieand
Tillie;
andtheylivedatthebottomofawell.


...

（2）所有子孙节点

知识点：.descendants属性.descendants.contents和.children属性仅包含tag的直接子节点，.descendants属性可以对所有tag的子孙节点进行递归循环，和children类似，我们也需要遍历获取其中的内容。Tag.descendants：生成器，可用于循环访问：fordesinTag.descendants

forchildinsoup.descendants:
printchild

运行结果如下，可以发现，所有的节点都被打印出来了，先生成最外层的HTML标签，其次从head标签一个个剥离，以此类推。

TheDormouse'sstory

TheDormouse'sstory
Onceuponatimetherewerethreelittlesisters;andtheirnameswere
,
Lacieand
Tillie;
andtheylivedatthebottomofawell.
...

TheDormouse'sstory
TheDormouse'sstory
TheDormouse'sstory



TheDormouse'sstory
Onceuponatimetherewerethreelittlesisters;andtheirnameswere
,
Lacieand
Tillie;
andtheylivedatthebottomofawell.
...



TheDormouse'sstory
TheDormouse'sstory
TheDormouse'sstory


Onceuponatimetherewerethreelittlesisters;andtheirnameswere
,
Lacieand
Tillie;
andtheylivedatthebottomofawell.
Onceuponatimetherewerethreelittlesisters;andtheirnameswere


Elsie
,

Lacie
Lacie
and

Tillie
Tillie
;
andtheylivedatthebottomofawell.


...
...

（3）节点内容

知识点：.string属性Tag.String：Tag只有一个String子节点是，可以这么访问，否则返回NoneTag.Strings：生成器，可用于循环访问：forstrinTag.Strings如果tag只有一个NavigableString类型子节点,那么这个tag可以使用.string得到子节点。如果一个tag仅有一个子节点,那么这个tag也可以使用.string方法,输出结果与当前唯一子节点的.string结果相同。通俗点说就是：如果一个标签里面没有标签了，那么.string就会返回标签里面的内容。如果标签里面只有唯一的一个标签了，那么.string也会返回最里面的内容。如果超过一个标签的话，那么就会返回None。例如

printsoup.head.string
#TheDormouse'sstory
printsoup.title.string
#TheDormouse'sstory

如果tag包含了多个子节点,tag就无法确定，string方法应该调用哪个子节点的内容,.string的输出结果是None

printsoup.html.string
#None

（4）多个内容

知识点：.strings.stripped_strings属性.strings获取多个内容，不过需要遍历获取，比如下面的例子

forstringinsoup.strings:
print(repr(string))
#u"TheDormouse'sstory"
#u'\n\n'
#u"TheDormouse'sstory"
#u'\n\n'
#u'Onceuponatimetherewerethreelittlesisters;andtheirnameswere\n'
#u'Elsie'
#u',\n'
#u'Lacie'
#u'and\n'
#u'Tillie'
#u';\nandtheylivedatthebottomofawell.'
#u'\n\n'
#u'...'
#u'\n'

.stripped_strings 输出的字符串中可能包含了很多空格或空行,使用.stripped_strings可以去除多余空白内容

forstringinsoup.stripped_strings:
print(repr(string))
#u"TheDormouse'sstory"
#u"TheDormouse'sstory"
#u'Onceuponatimetherewerethreelittlesisters;andtheirnameswere'
#u'Elsie'
#u','
#u'Lacie'
#u'and'
#u'Tillie'
#u';\nandtheylivedatthebottomofawell.'
#u'...'

（5）父节点

知识点：.parent属性使用parent获取父节点。Tag.parent：父节点Tag.parents：父到根的所有节点

body=soup.bodyhtml=body.parent #html是body的父亲

p=soup.p
printp.parent.name
#body

content=soup.head.title.string
printcontent.parent.name
#title

（6）全部父节点

知识点：.parents属性通过元素的.parents属性可以递归得到元素的所有父辈节点，例如

content=soup.head.title.string
forparentincontent.parents:
printparent.name

title
head
html
[document]

（7）兄弟节点

知识点：.next_sibling.previous_sibling属性
使用nextSibling,previousSibling获取前后兄弟
Tag.next_sibling
Tag.next_siblings
Tag.previous_sibling
Tag.previous_siblings
兄弟节点可以理解为和本节点处在统一级的节点，.next_sibling属性获取了该节点的下一个兄弟节点，.previous_sibling则与之相反，如果节点不存在，则返回None。
注意：实际文档中的tag的.next_sibling和.previous_sibling属性通常是字符串或空白，因为空白或者换行也可以被视作一个节点，所以得到的结果可能是空白或者换行

printsoup.p.next_sibling
#实际该处为空白
printsoup.p.prev_sibling
#None没有前一个兄弟节点，返回None
printsoup.p.next_sibling.next_sibling
#Onceuponatimetherewerethreelittlesisters;andtheirnameswere
#,
#Lacieand
#Tillie;
#andtheylivedatthebottomofawell.
#下一个节点的下一个兄弟节点是我们可以看到的节点

.next方法：只能针对单一元素进行.next，或者说是对contents列表元素的挨个清点。比如

soup.contents[1]=u'HTML'
soup.contents[2]=u'\n'

则soup.contents[1].next等价于soup.contents[2]

head=body.previousSibling #head和body在同一层，是body的前一个兄弟
p1=body.contents[0] #p1,p2都是body的儿子，我们用contents[0]取得p1
p2=p1.nextSibling #p2与p1在同一层，是p1的后一个兄弟,当然body.content[1]也可得到

contents[]的灵活运用也可以寻找关系节点,寻找祖先或者子孙可以采用findParent(s),findNextSibling(s),findPreviousSibling(s)

（8）全部兄弟节点

知识点：.next_siblings.previous_siblings属性通过.next_siblings和.previous_siblings属性可以对当前节点的兄弟节点迭代输出

forsiblinginsoup.a.next_siblings:
print(repr(sibling))
#u',\n'
#Lacie
#u'and\n'
#Tillie
#u';andtheylivedatthebottomofawell.'
#None

（9）前后节点

知识点：.next_element.previous_element属性与.next_sibling.previous_sibling不同，它并不是针对于兄弟节点，而是在所有节点，不分层次。比如head节点为

TheDormouse'sstory

那么它的下一个节点便是title，它是不分层次关系的

printsoup.head.next_element
#TheDormouse'sstory

（10）所有前后节点

知识点：.next_elements.previous_elements属性通过.next_elements和.previous_elements的迭代器就可以向前或向后访问文档的解析内容,就好像文档正在被解析一样

forelementinlast_a_tag.next_elements:
print(repr(element))
#u'Tillie'
#u';\nandtheylivedatthebottomofawell.'
#u'\n\n'
#...
#u'...'
#u'\n'
#None

以上是遍历文档树的基本用法。

搜索文档树

最常用的是find_all()函数（1）find_all(name,attrs,recursive,text,**kwargs)find_all()方法搜索当前tag的所有tag子节点,并判断是否符合过滤器的条件1）name参数name参数可以查找所有名字为name的tag,字符串对象会被自动忽略掉

#第一个参数为Tag的名称
tag.find_all(‘title')
#得到”&%^&*”,结果为一个列表

第二个参数为匹配的属性
tag.find_all(“title”,class=”sister”)
#得到如”%^*&
#第二个参数也可以为字符串，得到字符串匹配的结果
tag.find_all(“title”,”sister”)
#得到如”%^*&

A.传字符串最简单的过滤器是字符串.在搜索方法中传入一个字符串参数,BeautifulSoup会查找与字符串完整匹配的内容,下面的例子用于查找文档中所有的标签

soup.find_all('b') #[TheDormouse'sstory] printsoup.find_all('a') #[,Lacie,Tillie]

B.传正则表达式如果传入正则表达式作为参数,BeautifulSoup会通过正则表达式的match()来匹配内容.下面例子中找出所有以b开头的标签,这表示和标签都应该被找到

importre fortaginsoup.find_all(re.compile("^b")): print(tag.name) #body #b

C.传列表如果传入列表参数,BeautifulSoup会将与列表中任一元素匹配的内容返回.下面代码找到文档中所有标签和标签
soup.find_all(["a","b"]) #[TheDormouse'sstory, #Elsie, #Lacie, #Tillie]

D.传TrueTrue可以匹配任何值,下面代码查找到所有的tag,但是不会返回字符串节点

fortaginsoup.find_all(True): print(tag.name) #html #head #title #body #p #b #p #a #a

E.传方法如果没有合适过滤器,那么还可以定义一个方法,方法只接受一个元素参数[4],如果这个方法返回True表示当前元素匹配并且被找到,如果不是则反回False。下面方法校验了当前元素,如果包含class属性却不包含id属性,那么将返回True:

defhas_class_but_no_id(tag): returntag.has_attr('class')andnottag.has_attr('id')

将这个方法作为参数传入find_all()方法,将得到所有
标签:

soup.find_all(has_class_but_no_id) #[TheDormouse'sstory
, #Onceuponatimetherewere...
, #...
]

2）keyword参数注意：如果一个指定名字的参数不是搜索内置的参数名,搜索时会把该参数当作指定名字tag的属性来搜索,如果包含一个名字为id的参数,BeautifulSoup会搜索每个tag的”id”属性

soup.find_all(id='link2')
#[Lacie]

如果传入href参数,BeautifulSoup会搜索每个tag的”href”属性

soup.find_all(href=re.compile("elsie"))
#[Elsie]

使用多个指定名字的参数可以同时过滤tag的多个属性

soup.find_all(href=re.compile("elsie"),id='link1')
#[three]

在这里我们想用class过滤，不过class是python的关键词，这怎么办？加个下划线就可以

soup.find_all("a",class_="sister")
#[Elsie,
#Lacie,
#Tillie]

有些tag属性在搜索不能使用,比如HTML5中的data-*属性

data_soup=BeautifulSoup('foo!

')
data_soup.find_all(data-foo="value")
#SyntaxError:keywordcan'tbeanexpression
但是可以通过find_all()方法的attrs参数定义一个字典参数来搜索包含特殊属性的tag

data_soup.find_all(attrs={"data-foo":"value"})
#[foo!

]
3）text参数通过text参数可以搜搜文档中的字符串内容.与name参数的可选值一样,text参数接受字符串,正则表达式,列表,True

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"TheDormouse'sstory",u"TheDormouse'sstory"]

4）limit参数find_all()方法返回全部的搜索结构,如果文档树很大那么搜索会很慢.如果我们不需要全部结果,可以使用limit参数限制返回结果的数量.效果与SQL中的limit关键字类似,当搜索到的结果数量达到limit的限制时,就停止搜索返回结果.文档树中有3个tag符合搜索条件,但结果只返回了2个,因为我们限制了返回数量

soup.find_all("a",limit=2)
#[Elsie,
# Lacie]

5）recursive参数调用tag的find_all()方法时,BeautifulSoup会检索当前tag的所有子孙节点,如果只想搜索tag的直接子节点,可以使用参数recursive=False。一段简单的文档:

TheDormouse'sstory ...

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

soup.html.find_all("title")
#[TheDormouse'sstory]

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

（2）find(name=None,attrs={},recursive=True,text=None,**kwargs)
它与find_all()方法唯一的区别是find_all()方法的返回结果是值包含一个元素的列表,而find()方法直接返回结果。

.find('p'),.findAll('p')：find返回的是字符串值，而且是返回从头查找到的第一个tag对。但是如果这第一个tag对包括大量的内容，父等级很高，则同时其内部所包含的，此级标签也全部都find。findAll返回值是个列表，如果发现了一个同名标签内含多个同名标签，则内部的标签一并归于该父标签显示，列表其他元素也不再体现那些内含的同名子标签。即findAll会返回所有符合要求的结果，并以list返回。

soup.findAll(οnclick='document.location...')
soup.findAll(attrs={'style':r'outline:none;'})#用来查找属性中有style='outline:none;的标签体。

tag搜索

find(tagname) #直接搜索名为tagname的tag如：find('head')
find(list) #搜索在list中的tag，如:find(['head','body'])
find(dict) #搜索在dict中的tag，如:find({'head':True,'body':True})
find(re.compile('')) #搜索符合正则的tag,如:find(re.compile('^p'))搜索以p开头的tag
find(lambda) #搜索函数返回结果为true的tag,如:find(lambdaname:iflen(name)==1)搜索长度为1的tag
find(True) #搜索所有tag

attrs搜索

find(id='xxx') #寻找id属性为xxx的
find(attrs={id=re.compile('xxx'),algin='xxx'})#寻找id属性符合正则且algin属性为xxx的
find(attrs={id=True,algin=None}) #寻找有id属性但是没有algin属性的

resp1=soup.findAll('a',attrs={'href':match1})
resp2=soup.findAll('h1',attrs={'class':match2})
resp3=soup.findAll('img',attrs={'id':match3})

text搜索文字的搜索会导致其他搜索给的值如：tag,attrs都失效。方法与搜索tag一致

printp1.text
#u'Thisisparagraphone.'
printp2.text
#u'Thisisparagraphtwo.'
#注意：1，每个tag的text包括了它以及它子孙的text。2，所有text已经被自动转为unicode，如果需要，可以自行转码encode(xxx)

recursive和limit属性

recursive=False表示只搜索直接儿子，否则搜索整个子树，默认为True。
当使用findAll或者类似返回list的方法时，limit属性用于限制返回的数量，
如:findAll('p',limit=2)：返回首先找到的两个tag

（3）find_parents() find_parent()

find_all()和find()只搜索当前节点的所有子节点,孙子节点等.find_parents()和find_parent()用来搜索当前节点的父辈节点,搜索方法与普通tag的搜索方法相同,搜索文档搜索文档包含的内容

（4）find_next_siblings() find_next_sibling()

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

（5）find_previous_siblings() find_previous_sibling()

这2个方法通过.previous_siblings属性对当前tag的前面解析的兄弟tag节点进行迭代,find_previous_siblings()方法返回所有符合条件的前面的兄弟节点,find_previous_sibling()方法返回第一个符合条件的前面的兄弟节点

（6）find_all_next() find_next()

这2个方法通过.next_elements属性对当前tag的之后的tag和字符串进行迭代,find_all_next()方法返回所有符合条件的节点,find_next()方法返回第一个符合条件的节点

（7）find_all_previous()和find_previous()

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

注：以上（2）（3）（4）（5）（6）（7）方法参数用法与find_all()完全相同，原理均类似，在此不再赘述。

CSS选择器

在写CSS时，标签名不加任何修饰，类名前加点，id名前加#在这里我们也可以利用类似的方法来筛选元素，用到的方法是soup.select()，返回类型是list（1）通过标签名查找

printsoup.select('title')
#[TheDormouse'sstory]

printsoup.select('a')
#[,Lacie,Tillie]

printsoup.select('b')
#[TheDormouse'sstory]

（2）通过类名查找

printsoup.select('.sister')
#[,Lacie,Tillie]

（3）通过id名查找

printsoup.select('#link1')
#[]

（4）组合查找组合查找即和写class文件时，标签名与类名、id名进行的组合原理是一样的，例如：查找p标签中，id等于link1的内容，二者需要用空格分开

printsoup.select('p#link1')
#[]

直接子标签查找

printsoup.select("head>title")
#[TheDormouse'sstory]

（5）属性查找查找时还可以加入属性元素，属性需要用中括号括起来，注意属性和标签属于同一节点，所以中间不能加空格，否则会无法匹配到。

printsoup.select('a[class="sister"]')
#[,Lacie,Tillie]

printsoup.select('a[href="http://jb51.net/elsie"]')
#[]

同样，属性仍然可以与上述查找方式组合，不在同一节点的空格隔开，同一节点的不加空格

printsoup.select('pa[href="http://jb51.net/elsie"]')
#[]

以上的select方法返回的结果都是列表形式，可以遍历形式输出，然后用get_text()方法来获取它的内容。

soup=BeautifulSoup(html,'lxml')
printtype(soup.select('title'))
printsoup.select('title')[0].get_text()

fortitleinsoup.select('title'):
printtitle.get_text()

这就是另一种与find_all方法有异曲同工之妙的查找方法，是不是感觉很方便？

printsoup.find_all("a",class_="sister") printsoup.select("p.title") #通过属性进行查找 printsoup.find_all("a",attrs={"class":"sister"}) #通过文本进行查找 printsoup.find_all(text="Elsie") printsoup.find_all(text=["Tillie","Elsie","Lacie"]) #限制结果个数 printsoup.find_all("a",limit=2)

本文详细讲解了python爬虫块BeautifulSoup从安装到详细使用方法与实例，更多关于python爬虫块BeautifulSoup的使用方法请查看下面的相关链接
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。