当前位置:主页 > 资料 >

Python3中BeautifulSoup的使用方法
栏目分类:资料   发布日期:2017-05-28   浏览次数:

导读:本文为去找网小编(www.7zhao.net)为您推荐的Python3中BeautifulSoup的使用方法,希望对您有所帮助,谢谢! 我们学习了正则表达式的相关用法,但是一旦正则写的有问题,可能得到的就不是我

本文为去找网小编(www.7zhao.net)为您推荐的Python3中BeautifulSoup的使用方法,希望对您有所帮助,谢谢! 本文来自去找www.7zhao.net



我们学习了正则表达式的相关用法,但是一旦正则写的有问题,可能得到的就不是我们想要的结果了,而且对于一个网页来说,都有一定的特殊的结构和层级关系,而且很多标签都有id或class来对作区分,所以我们借助于它们的结构和属性来提取不也是可以的吗? 欢迎访问www.7zhao.net

所以,这一节我们就介绍一个强大的解析工具,叫做BeautiSoup,它就是借助网页的结构和属性等特性来解析网页的工具,有了它我们不用再去写一些复杂的正则,只需要简单的几条语句就可以完成网页中某个元素的提取。 欢迎访问www.7zhao.net

废话不多说,接下来我们就来感受一下BeautifulSoup的强大之处吧。 欢迎访问www.7zhao.net

BeautifulSoup简介

简单来说,BeautifulSoup就是Python的一个HTML或XML的解析库,我们可以用它来方便地从网页中提取数据,官方的解释如下: 去找(www.7zhao.net欢迎您

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

所以说,利用它我们可以省去很多繁琐的提取工作,提高解析效率。 www.7zhao.net

安装

使用之前,我们当然需要首先说明一下它的安装方式。目前BeautifulSoup的最新版本是4.x版本,之前的版本已经停止开发了,推荐使用pip来安装,安装命令如下: 去找(www.7zhao.net欢迎您

pip3 install beautifulsoup4 www.7zhao.net 

当然也可以从pypi下载whl文件安装,链接如下: www.7zhao.net

去找(www.7zhao.net欢迎您

好,安装完成之后可以验证一下,写一段Python程序试验一下。

去找(www.7zhao.net欢迎您

from bs4 import BeautifulSoup

soup = BeautifulSoup('<p>Hello</p>', 'html.parser')

print(soup.p.string)
 本文来自去找www.7zhao.net 

运行结果

内容来自www.7zhao.net

Hello 

www.7zhao.net

如果没有报错,则证明安装没有问题,关于它的解析用法我们在后面会详细介绍。

本文来自去找www.7zhao.net

注意在这里我们虽然安装的是beautifulsoup4这个包,但是在引入的时候是引入的bs4,这是因为这个包源代码本身的库文件夹名称就是bs4,所以安装完成之后,这个库文件夹就被移入到我们本机Python3的lib库里,所以识别到的库文件名称就叫做bs4,所以我们引入的时候就引入bs4这个包。因此,包本身的名称和我们使用时导入的包的名称并不一定是一致的。 内容来自www.7zhao.net

解析器

BeautifulSoup在解析的时候实际上是依赖于解析器的,它除了支持Python标准库中的HTML解析器,还支持一些第三方的解析器比如lxml,下面我们对BeautifulSoup支持的解析器及它们的一些优缺点做一个简单的对比。 内容来自www.7zhao.net

解析器使用方法优势劣势

www.7zhao.net

Python标准库BeautifulSoup(markup, "html.parser")Python的内置标准库、执行速度适中 、文档容错能力强Python 2.7.3 or 3.2.2)前的版本中文容错能力差

本文来自去找www.7zhao.net

lxml HTML 解析器BeautifulSoup(markup, "lxml")速度快、文档容错能力强需要安装C语言库

本文来自去找www.7zhao.net

lxml XML 解析器BeautifulSoup(markup, "xml")速度快、唯一支持XML的解析器需要安装C语言库

去找(www.7zhao.net欢迎您

html5libBeautifulSoup(markup, "html5lib")最好的容错性、以浏览器的方式解析文档、生成HTML5格式的文档速度慢、不依赖外部扩展

本文来自去找www.7zhao.net

所以通过以上对比可以看出,lxml这个解析器有解析HTML和XML的功能,而且速度快,容错能力强,所以推荐使用这个库来进行解析,但是这里的劣势是必须安装一个C语言库,它叫做lxml,我们在这里依然使用pip安装即可,命令如下:

欢迎访问www.7zhao.net

pip3 install lxml 

www.7zhao.net

安装完成之后,我们就可以使用lxml这个解析器来解析了,在初始化的时候我们可以把第二个参数改为lxml,如下: 去找(www.7zhao.net欢迎您

from bs4 import BeautifulSoup

soup = BeautifulSoup('<p>Hello</p>', 'lxml')

print(soup.p.string)
 
本文来自去找www.7zhao.net

运行结果是完全一致的,后面BeautifulSoup的用法实例也统一用这个库来演示。 去找(www.7zhao.net欢迎您

基本使用

下面我们首先用一个实例来感受一下BeautifulSoup的基本使用:

欢迎访问www.7zhao.net

html = """

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

<body>

<p class="title" name="dromouse"><b>The Dormouse's story</b></p>

<p class="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.</p>

<p class="story">...</p>

"""

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

print(soup.prettify())

print(soup.title.string)
 
copyright www.7zhao.net

运行结果:

去找(www.7zhao.net欢迎您

<html>

 <head>

  <title>

   The Dormouse's story

  </title>

 </head>

 <body>

  <p class="title" name="dromouse">

   <b>

    The Dormouse's story

   </b>

  </p>

  <p class="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="link3">

    Tillie

   </a>

   ;

and they lived at the bottom of a well.

  </p>

  <p class="story">

   ...

  </p>

 </body>

</html>

The Dormouse's story
 www.7zhao.net 

首先我们声明了一个变量html,它是一个HTML字符串,但是注意到,它并不是一个完整的HTML字符串, <body><html> 标签都没有闭合,但是我们将它当作第一个参数传给BeautifulSoup对象,第二个参数传入的是解析器的类型,在这里我们使用lxml,这样就完成了BeaufulSoup对象的初始化,将它赋值给soup这个变量。 www.7zhao.net

那么接下来我们就可以通过调用soup的各个方法和属性对这串HTML代码解析了。 欢迎访问www.7zhao.net

我们首先调用了prettify()方法,这个方法可以把要解析的字符串以标准的缩进格式输出,在这里注意到输出结果里面包含了 </body></html> 标签,也就是说对于不标准的HTML字符串BeautifulSoup可以自动更正格式,这一步实际上不是由prettify()方法做的,这个更正实际上在初始化BeautifulSoup时就完成了。 copyright www.7zhao.net

然后我们调用了 soup.title.string ,这个实际上是输出了HTML中 <title> 标签的文本内容。所以 soup.title 就可以选择出HTML中的 <title> 标签,再调用string属性就可以得到里面的文本了,所以我们就可以通过简单地调用几个属性就可以完成文本的提取了,是不是非常方便?

本文来自去找www.7zhao.net

标签选择器

刚才我们选择元素的时候直接通过调用标签的名称就可以选择节点元素了,然后再调用string属性就可以得到标签内的文本了,这种选择方式速度非常快,如果单个标签结构话层次非常清晰,可以选用这种方式来解析。 www.7zhao.net

选择元素

下面我们再用一个例子详细说明一下它的选择方法。

www.7zhao.net

html = """

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

<body>

<p class="title" name="dromouse"><b>The Dormouse's story</b></p>

<p class="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.</p>

<p class="story">...</p>

"""

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

print(soup.title)

print(type(soup.title))

print(soup.title.string)

print(soup.head)

print(soup.p)
 
去找(www.7zhao.net欢迎您

运行结果:

去找(www.7zhao.net欢迎您

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

<class 'bs4.element.Tag'>

The Dormouse's story

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

<p class="title" name="dromouse"><b>The Dormouse's story</b></p>
 内容来自www.7zhao.net 

在这里我们依然选用了刚才的HTML代码,我们首先打印输出了title标签的选择结果,输出结果正是title标签加里面的文字内容。接下来输出了它的类型,是 bs4.element.Tag 类型,这是BeautifulSoup中的一个重要的数据结构,经过选择器选择之后,选择结果都是这种Tag类型,它具有一些属性比如string属性,调用Tag的string属性,就可以得到节点的文本内容了,所以接下来的输出结果正是节点的文本内容。 www.7zhao.net

接下来我们又尝试选择了head标签,结果也是标签加其内部的所有内容,再接下来选择了p标签,不过这次情况比较特殊,我们发现结果是第一个p标签的内容,后面的几个p标签并没有选择到,也就是说,当有多个标签时,这种选择方式只会选择到第一个匹配的标签,其他的后面的标签都会忽略。 去找(www.7zhao.net欢迎您

提取信息

在上面我们演示了调用string属性来获取文本的值,那我们要获取标签属性值怎么办呢?获取标签名怎么办呢?下面我们来统一梳理一下信息的提取方式 内容来自www.7zhao.net

获取名称

可以利用name属性来获取标签的名称。还是以上面的文本为例,我们选取title标签,然后调用name属性就可以得到标签名称。

本文来自去找www.7zhao.net

print(soup.title.name)
 
copyright www.7zhao.net

运行结果:

本文来自去找www.7zhao.net

title 
欢迎访问www.7zhao.net

获取属性

每个标签可能有多个属性,比如id,class等等,我们选择到这个节点元素之后,可以调用attrs获取所有属性。

去找(www.7zhao.net欢迎您

print(soup.p.attrs)

print(soup.p.attrs['name'])
 

www.7zhao.net

运行结果:

copyright www.7zhao.net

{'class': ['title'], 'name': 'dromouse'}

dromouse
 欢迎访问www.7zhao.net 

可以看到attrs的返回结果是字典形式,把选择的标签的所有属性和属性值组合成一个字典,接下来如果要获取name属性,就相当于从字典中获取某个键值,只需要用中括号加属性名称就可以得到结果了,比如获取name属性就可以通过 attrs['name'] 得到相应的属性值。 copyright www.7zhao.net

其实这样的写法还有点繁琐,还有一种更简单的获取方式,我们可以不用写attrs,直接节点元素后面加中括号,传入属性名就可以达到属性值了,样例如下:

欢迎访问www.7zhao.net

print(soup.p['name'])

print(soup.p['class'])
 

欢迎访问www.7zhao.net

运行结果: copyright www.7zhao.net

dromouse

['title'] 

去找(www.7zhao.net欢迎您

在这里注意到有的返回结果是字符串,有的返回结果是字符串组成的列表。比如name属性的值是唯一的,返回的结果就是单个字符串,而对于class,一个节点元素可能由多个class,所以返回的是列表,所以在实际处理过程中要注意判断类型。

欢迎访问www.7zhao.net

获取内容

可以利用string属性获取节点元素包含的文本内容,比如上面的文本我们获取第一个p标签的文本: 本文来自去找www.7zhao.net

print(soup.p.string)
 copyright www.7zhao.net 

运行结果:

本文来自去找www.7zhao.net

The Dormouse's story www.7zhao.net 

再次注意一下这里选择到的p标签是第一个p标签,获取的文本也就是第一个p标签里面的文本。 内容来自www.7zhao.net

嵌套选择

在上面的例子中我们知道每一个返回结果都是 bs4.element.Tag 类型,它同样可以继续调用标签进行下一步的选择,比如我们获取了head节点元素,我们可以继续调用head来选取其内部的head节点元素。 www.7zhao.net

html = """

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

<body>

"""

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

print(soup.head.title)

print(type(soup.head.title))

print(soup.head.title.string)
 
欢迎访问www.7zhao.net

运行结果: copyright www.7zhao.net

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

<class 'bs4.element.Tag'>

The Dormouse's story 

去找(www.7zhao.net欢迎您

第一行结果是我们调用了head之后再次调用了title来选择的title节点元素,然后我们紧接着打印输出了它的类型,可以看到它仍然是 bs4.element.Tag 类型,也就是说我们在Tag类型的基础上再次选择得到的依然还是Tag类型,每次返回的结果都相同,所以这样我们就可以这样做嵌套的选择了。 本文来自去找www.7zhao.net

最后输出了一下它的string属性,也就是标签里的文本内容。 www.7zhao.net

关联选择

我们在做选择的时候有时候不能做到一步就可以选择到想要的节点元素,有时候在选择的时候需要先选中某一个节点元素,然后以它为基准再选择它的子节点、父节点、兄弟节点等等。所以在这里我们就介绍下如何来选择这些节点元素。 copyright www.7zhao.net

子节点和子孙节点

选取到了一个节点元素之后,如果想要获取它的直接子节点可以调用contents属性,我们用一个实例来感受一下:

欢迎访问www.7zhao.net

html = """

<html>

    <head>

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

    </head>

    <body>

        <p class="story">

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

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

                <span>Elsie</span>

            </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.

        </p>

        <p class="story">...</p>

"""
 内容来自www.7zhao.net 

运行结果:

欢迎访问www.7zhao.net

['\n            Once upon a time there were three little sisters; and their names were\n            ', <a class="sister" href="http://example.com/elsie" id="link1">

<span>Elsie</span>

</a>, '\n', <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, ' \n            and\n            ', <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>, '\n            and they lived at the bottom of a well.\n        ']
 内容来自www.7zhao.net 

返回的结果是列表形式,p标签里面既包含文本,又包含标签,返回的结果会将他们以列表形式都统一返回。 本文来自去找www.7zhao.net

注意得到的列表的每一个元素都是p标签的直接子节点,比如第一个a标签里面包含了一层span标签,这个就相当于孙子节点了,但是返回结果中并没有单独把span标签选出来作为结果的一部分,所以说contents属性得到的结果是直接子节点的列表。 欢迎访问www.7zhao.net

同样地我们可以调用children属性,得到相应的结果。 去找(www.7zhao.net欢迎您

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

print(soup.p.children)

for i, child in enumerate(soup.p.children):

    print(i, child)
 
copyright www.7zhao.net

运行结果: 去找(www.7zhao.net欢迎您

<list_iterator object at 0x1064f7dd8>

0 

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

            

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

<span>Elsie</span>

</a>

2 



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

4  

            and

            

5 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>

6 

            and they lived at the bottom of a well. 
www.7zhao.net

还是同样的HTML文本,在这里我们调用了children属性来进行选择,返回结果可以看到是生成器类型,所以接下来我们用for循环输出了一下相应的内容,内容其实是一样的,只不过children返回的是生成器类型,而contents返回的是列表类型。

www.7zhao.net

如果我们要得到所有的子孙节点的话可以调用descendants属性。

去找(www.7zhao.net欢迎您

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

print(soup.p.descendants)

for i, child in enumerate(soup.p.descendants):

    print(i, child)
 

内容来自www.7zhao.net

运行结果: 本文来自去找www.7zhao.net

<generator object descendants at 0x10650e678>

0 

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

            

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

<span>Elsie</span>

</a>

2 



3 <span>Elsie</span>

4 Elsie

5 



6 



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

8 Lacie

9  

            and

            

10 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>

11 Tillie

12 

            and they lived at the bottom of a well. 

本文来自去找www.7zhao.net

返回结果还是生成器,遍历输出一下可以看到这次的输出结果就包含了span标签,descendants会递归地查询所有子节点,得到的是所有的子孙节点。 本文来自去找www.7zhao.net

父节点和祖先节点

如果要获取某个节点元素的父节点,可以调用parent属性。 www.7zhao.net

html = """

<html>

    <head>

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

    </head>

    <body>

        <p class="story">

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

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

                <span>Elsie</span>

            </a>

        </p>

        <p class="story">...</p>

"""

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

print(soup.a.parent)
 欢迎访问www.7zhao.net 

运行结果:

copyright www.7zhao.net

<p class="story">

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

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

<span>Elsie</span>

</a>

</p>
 

欢迎访问www.7zhao.net

在这里我们选择的是第一个a标签的父节点元素,很明显它的父节点是p标签,输出结果便是p标签及其内部的内容。 去找(www.7zhao.net欢迎您

注意到这里输出的仅仅是a标签的直接父节点,而没有再向外寻找父节点的祖先节点,如果我们要想获取所有的祖先节点,可以调用parents属性。

去找(www.7zhao.net欢迎您

html = """

<html>

    <body>

        <p class="story">

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

                <span>Elsie</span>

            </a>

        </p>

"""

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

print(type(soup.a.parents))

print(list(enumerate(soup.a.parents)))
 

去找(www.7zhao.net欢迎您

运行结果:

去找(www.7zhao.net欢迎您

<class 'generator'>

[(0, <p class="story">

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

<span>Elsie</span>

</a>

</p>), (1, <body>

<p class="story">

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

<span>Elsie</span>

</a>

</p>

</body>), (2, <html>

<body>

<p class="story">

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

<span>Elsie</span>

</a>

</p>

</body></html>), (3, <html>

<body>

<p class="story">

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

<span>Elsie</span>

</a>

</p>

</body></html>)]
 本文来自去找www.7zhao.net 

返回结果是一个生成器类型,我们在这里用列表输出了它的索引和内容,可以发现列表中的元素就是a标签的祖先节点。

copyright www.7zhao.net

兄弟节点

上面说明了子节点和父节点的获取方式,如果要获取同级的节点也就是兄弟节点应该怎么办?我们先用一个实例来感受一下:

copyright www.7zhao.net

html = """

<html>

    <body>

        <p class="story">

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

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

                <span>Elsie</span>

            </a>

            Hello

            <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.

        </p>

"""

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

print('Next Sibling', soup.a.next_sibling)

print('Prev Sibling', soup.a.previous_sibling)

print('Next Siblings', list(enumerate(soup.a.next_siblings)))

print('Prev Siblings', list(enumerate(soup.a.previous_siblings)))
 www.7zhao.net 

运行结果: 去找(www.7zhao.net欢迎您

Next Sibling 

            Hello

            

Prev Sibling 

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

            

Next Siblings [(0, '\n            Hello\n            '), (1, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>), (2, ' \n            and\n            '), (3, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>), (4, '\n            and they lived at the bottom of a well.\n        ')]

Prev Siblings [(0, '\n            Once upon a time there were three little sisters; and their names were\n            ')]
 www.7zhao.net 

可以看到在这里我们调用了四个不同的属性,next_sibling和previous_sibling分别可以获取节点的下一个和上一个兄弟元素,next_siblings和previous_siblings则分别返回所有前面和后面的兄弟节点的生成器。

www.7zhao.net

提取信息

在上面我们讲解了关联元素节点的选择方法,如果我们想要获取它们的一些信息,比如文本、属性等等也是同样的方法。 本文来自去找www.7zhao.net

html = """

<html>

    <body>

        <p class="story">

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

            <a href="http://example.com/elsie" class="sister" id="link1">Bob</a><a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> 

        </p>

"""

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

print('Next Sibling:')

print(type(soup.a.next_sibling))

print(soup.a.next_sibling)

print(soup.a.next_sibling.string)

print('Parent:')

print(type(soup.a.parents))

print(list(soup.a.parents)[0])

print(list(soup.a.parents)[0].attrs['class'])
 

www.7zhao.net

运行结果:

www.7zhao.net

Next Sibling:

<class 'bs4.element.Tag'>

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

Lacie

Parent:

<class 'generator'>

<p class="story">

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

            <a class="sister" href="http://example.com/elsie" id="link1">Bob</a><a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>

</p>

['story']
 

欢迎访问www.7zhao.net

如果返回结果是单个节点,那么可以直接调用string、attrs等属性来获得其文本和属性,如果返回结果是多个节点的生成器,则可以转为list后取出某个元素,然后再调用string、attrs等属性来获取其对应节点等文本和属性。

欢迎访问www.7zhao.net

方法选择器

前面我们所讲的选择方法都是用 . 这种运算符来选择元素的,这种选择方法非常快,但是如果要进行比较复杂的选择的话则会比较繁琐,不够灵活。所以BeautifulSoup还为我们提供了一些查询的方法,比如find_all()、find()等方法,我们可以调用方法然后传入相应等参数就可以灵活地进行查询了。 copyright www.7zhao.net

最常用的查询方法莫过于find_all()和find()了,下面我们对它们的用法进行详细的介绍。 copyright www.7zhao.net

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

find_all,顾名思义,就是查询所有符合条件的元素,可以给它传入一些属性或文本来得到符合条件的元素,功能十分强大。 copyright www.7zhao.net

name

我们可以根据标签名来查询元素,下面我们用一个实例来感受一下:

本文来自去找www.7zhao.net

html='''

<div class="panel">

    <div class="panel-heading">

        <h4>Hello</h4>

    </div>

    <div class="panel-body">

        <ul class="list" id="list-1">

            <li class="element">Foo</li>

            <li class="element">Bar</li>

            <li class="element">Jay</li>

        </ul>

        <ul class="list list-small" id="list-2">

            <li class="element">Foo</li>

            <li class="element">Bar</li>

        </ul>

    </div>

</div>

'''

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

print(soup.find_all(name='ul'))

print(type(soup.find_all(name='ul')[0]))
 
欢迎访问www.7zhao.net

运行结果: www.7zhao.net

[<ul class="list" id="list-1">

<li class="element">Foo</li>

<li class="element">Bar</li>

<li class="element">Jay</li>

</ul>, <ul class="list list-small" id="list-2">

<li class="element">Foo</li>

<li class="element">Bar</li>

</ul>]

<class 'bs4.element.Tag'>
 copyright www.7zhao.net 

在这里我们调用了find_all()方法,传入了一个name参数,参数值为ul,也就是说我们想要查询所有ul标签,返回结果是list类型,长度为2,每个元素依然都是 bs4.element.Tag 类型。 www.7zhao.net

因为都是Tag类型,所以我们依然可以进行嵌套查询,还是同样的文本,在这里我们查询出所有ul标签后再继续查询其内部的li标签。 欢迎访问www.7zhao.net

for ul in soup.find_all(name='ul'):

    print(ul.find_all(name='li'))
 

www.7zhao.net

运行结果: 内容来自www.7zhao.net

[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>]

[<li class="element">Foo</li>, <li class="element">Bar</li>]
 
欢迎访问www.7zhao.net

返回结果是列表类型,列表中的每个元素依然还是Tag类型。 www.7zhao.net

接下来我们就可以遍历每个li获取它的文本了。 内容来自www.7zhao.net

for ul in soup.find_all(name='ul'):

    print(ul.find_all(name='li'))

    for li in ul.find_all(name='li'):

        print(li.string)
 

copyright www.7zhao.net

运行结果:

内容来自www.7zhao.net

[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>]

Foo

Bar

Jay

[<li class="element">Foo</li>, <li class="element">Bar</li>]

Foo

Bar
 

去找(www.7zhao.net欢迎您

attrs

除了根据标签名查询,我们也可以传入一些属性来进行查询,我们用一个实例感受一下:

欢迎访问www.7zhao.net

html='''

<div class="panel">

    <div class="panel-heading">

        <h4>Hello</h4>

    </div>

    <div class="panel-body">

        <ul class="list" id="list-1" name="elements">

            <li class="element">Foo</li>

            <li class="element">Bar</li>

            <li class="element">Jay</li>

        </ul>

        <ul class="list list-small" id="list-2">

            <li class="element">Foo</li>

            <li class="element">Bar</li>

        </ul>

    </div>

</div>

'''

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

print(soup.find_all(attrs={'id': 'list-1'}))

print(soup.find_all(attrs={'name': 'elements'}))
 内容来自www.7zhao.net 

运行结果: 内容来自www.7zhao.net

[<ul class="list" id="list-1" name="elements">

<li class="element">Foo</li>

<li class="element">Bar</li>

<li class="element">Jay</li>

</ul>]

[<ul class="list" id="list-1" name="elements">

<li class="element">Foo</li>

<li class="element">Bar</li>

<li class="element">Jay</li>

</ul>] 本文来自去找www.7zhao.net 

在这里我们查询的时候传入的是attrs参数,参数的类型是字典类型,比如我们要查询id为list-1的节点,那就可以传入 attrs={'id': 'list-1'} 的查询条件,得到的结果是列表形式,包含的内容就是符合id为list-1的所有节点,上面的例子中符合条件的元素个数是1,所以结果是长度为1的列表。 copyright www.7zhao.net

对于一些常用的属性比如id、class等,我们可以不用attrs来传递,比如我们要查询id为list-1的节点,我们可以直接传入id这个参数,还是上面的文本,我们换一种方式来查询。 欢迎访问www.7zhao.net

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

print(soup.find_all(id='list-1'))

print(soup.find_all(class_='element'))
 内容来自www.7zhao.net 

运行结果:

www.7zhao.net

[<ul class="list" id="list-1">

<li class="element">Foo</li>

<li class="element">Bar</li>

<li class="element">Jay</li>

</ul>]

[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>, <li class="element">Foo</li>, <li class="element">Bar</li>]
 去找(www.7zhao.net欢迎您 

在这里我们直接传入 id='list-1' 就可以查询id为list-1的节点元素了。而对于class来说,由于class在python里是一个关键字,所以在这里后面需要加一个下划线, class_='element' ,返回的结果依然还是Tag组成的列表。

本文来自去找www.7zhao.net

text

text参数可以用来匹配节点的文本,传入的形式可以是字符串,可以是正则表达式对象,我们用一个实例来感受一下: 去找(www.7zhao.net欢迎您

import re

html='''

<div class="panel">

    <div class="panel-body">

        <a>Hello, this is a link</a>

        <a>Hello, this is a link, too</a>

    </div>

</div>

'''

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

print(soup.find_all(text=re.compile('link')))
 
copyright www.7zhao.net

运行结果: 本文来自去找www.7zhao.net

['Hello, this is a link', 'Hello, this is a link, too']
 内容来自www.7zhao.net 

在这里有两个a节点,其内部包含有文本信息,在这里我们调用find_all()方法传入text参数,参数为正则表达式对象,结果会返回所有匹配正则表达式的节点文本组成的列表。

本文来自去找www.7zhao.net

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

除了find_all()方法,还有find()方法,只不过find()方法返回的是单个元素,也就是第一个匹配的元素,而find_all()返回的是所有匹配的元素组成的列表。 copyright www.7zhao.net

html='''

<div class="panel">

    <div class="panel-heading">

        <h4>Hello</h4>

    </div>

    <div class="panel-body">

        <ul class="list" id="list-1">

            <li class="element">Foo</li>

            <li class="element">Bar</li>

            <li class="element">Jay</li>

        </ul>

        <ul class="list list-small" id="list-2">

            <li class="element">Foo</li>

            <li class="element">Bar</li>

        </ul>

    </div>

</div>

'''

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

print(soup.find(name='ul'))

print(type(soup.find(name='ul')))

print(soup.find(class_='list'))
 

内容来自www.7zhao.net

运行结果:

copyright www.7zhao.net

<ul class="list" id="list-1">

<li class="element">Foo</li>

<li class="element">Bar</li>

<li class="element">Jay</li>

</ul>

<class 'bs4.element.Tag'>

<ul class="list" id="list-1">

<li class="element">Foo</li>

<li class="element">Bar</li>

<li class="element">Jay</li>

</ul> 去找(www.7zhao.net欢迎您 

返回结果不再是列表形式,而是第一个匹配的节点元素,类型依然是Tag类型。 www.7zhao.net

另外还有许多的查询方法,用法与前面介绍的find_all()、find()方法完全相同,只不过查询范围不同,在此做一下简单的说明。

copyright www.7zhao.net

find_parents() find_parent()

find_parents()返回所有祖先节点,find_parent()返回直接父节点。 去找(www.7zhao.net欢迎您

find_next_siblings() find_next_sibling()

find_next_siblings()返回后面所有兄弟节点,find_next_sibling()返回后面第一个兄弟节点。

去找(www.7zhao.net欢迎您

find_previous_siblings() find_previous_sibling()

find_previous_siblings()返回前面所有兄弟节点,find_previous_sibling()返回前面第一个兄弟节点。 欢迎访问www.7zhao.net

find_all_next() find_next()

find_all_next()返回节点后所有符合条件的节点, find_next()返回第一个符合条件的节点。 www.7zhao.net

find_all_previous() 和 find_previous()

find_all_previous()返回节点后所有符合条件的节点, find_previous()返回第一个符合条件的节点

www.7zhao.net

CSS选择器

BeautifulSoup还提供了另外一种选择器,那就是CSS选择器,如果对web开发熟悉对话,CSS选择器肯定也不陌生,如果不熟悉的话,可以看一下 。

欢迎访问www.7zhao.net

使用CSS选择器,只需要调用select()方法,传入相应的CSS选择器即可,我们用一个实例来感受一下:

本文来自去找www.7zhao.net

html='''

<div class="panel">

    <div class="panel-heading">

        <h4>Hello</h4>

    </div>

    <div class="panel-body">

        <ul class="list" id="list-1">

            <li class="element">Foo</li>

            <li class="element">Bar</li>

            <li class="element">Jay</li>

        </ul>

        <ul class="list list-small" id="list-2">

            <li class="element">Foo</li>

            <li class="element">Bar</li>

        </ul>

    </div>

</div>

'''

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

print(soup.select('.panel .panel-heading'))

print(soup.select('ul li'))

print(soup.select('#list-2 .element'))

print(type(soup.select('ul')[0]))
 
内容来自www.7zhao.net

运行结果:

本文来自去找www.7zhao.net

[<div class="panel-heading">

<h4>Hello</h4>

</div>]

[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>, <li class="element">Foo</li>, <li class="element">Bar</li>]

[<li class="element">Foo</li>, <li class="element">Bar</li>]

<class 'bs4.element.Tag'>
 

内容来自www.7zhao.net

在这里我们用了三次CSS选择器,返回的结果均是符合CSS选择器的节点组成的列表。例如 select('ul li') 则是选择所有ul节点下面的所有li节点,结果便是所有的li节点组成的列表。

欢迎访问www.7zhao.net

最后一句我们打印输出了列表中元素的类型,可以看到类型依然是Tag类型。

copyright www.7zhao.net

嵌套选择

select()方法同样支持嵌套选择,例如我们先选择所有ul节点,再遍历每个ul节点选择其li节点,样例如下: 欢迎访问www.7zhao.net

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

for ul in soup.select('ul'):

    print(ul.select('li'))
 copyright www.7zhao.net 

运行结果: www.7zhao.net

[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>]

[<li class="element">Foo</li>, <li class="element">Bar</li>]
 
欢迎访问www.7zhao.net

可以看到正常输出了遍历每个ul节点之后,其下的所有li节点组成的列表。 copyright www.7zhao.net

获取属性

我们知道节点类型是Tag类型,所以获取属性还是可以用原来的方法获取,仍然是上面的HTML文本,我们在这里尝试获取每个ul节点的id属性。

本文来自去找www.7zhao.net

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

for ul in soup.select('ul'):

    print(ul['id'])

    print(ul.attrs['id'])
 www.7zhao.net 

运行结果:

本文来自去找www.7zhao.net

list-1

list-1

list-2

list-2 
内容来自www.7zhao.net

可以看到直接传入中括号和属性名和通过attrs属性获取属性值都是可以成功的。

内容来自www.7zhao.net

获取文本

那么获取文本当然也可以用前面所讲的string属性,还有一个方法那就是get_text(),同样可以获取文本值。 本文来自去找www.7zhao.net

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')

for li in soup.select('li'):

    print('Get Text:', li.get_text())

    print('String:', li.string)
 www.7zhao.net 

运行结果: 欢迎访问www.7zhao.net

Get Text: Foo

String: Foo

Get Text: Bar

String: Bar

Get Text: Jay

String: Jay

Get Text: Foo

String: Foo

Get Text: Bar

String: Bar 

本文来自去找www.7zhao.net

二者的效果是完全一致的,都可以获取到节点的文本值。

去找(www.7zhao.net欢迎您

综述

到此BeautifulSoup的使用介绍基本就结束了,最后做一下简单的总结: copyright www.7zhao.net

  • 推荐使用lxml解析库,必要时使用html.parser
  • 标签选择筛选功能弱但是速度快
  • 建议使用find()、find_all() 查询匹配单个结果或者多个结果
  • 如果对CSS选择器熟悉的话可以使用select()选择法

本文由崔庆才 创作,采用 进行许可。 www.7zhao.net

转载、引用前需联系作者,并署名作者且注明文章出处。 欢迎访问www.7zhao.net

本站文章版权归原作者及原出处所有 。内容为作者个人观点, 并不代表本站赞同其观点和对其真实性负责。本站是一个个人学习交流的平台,并不用于任何商业目的,如果有任何问题,请及时联系我们,我们将根据著作权人的要求,立即更正或者删除有关内容。本站拥有对此声明的最终解释权。

欢迎访问www.7zhao.net

内容来自www.7zhao.net


本文原文地址:https://ask.hellobi.com/blog/cuiqingcai/8408

以上为Python3中BeautifulSoup的使用方法文章的全部内容,若您也有好的文章,欢迎与我们分享!

本文来自去找www.7zhao.net

Copyright ©2008-2017去找网版权所有   皖ICP备12002049号-2 皖公网安备 34088102000435号   关于我们|联系我们| 免责声明|友情链接|网站地图|手机版