Python爬虫之Beautiful soup模块

1、Beautiful soup与Xpath对比

相同点:用来解析HTML和XML,并从中提取数据

独有的特点:

  • API简单,功能强大
  • 支持多种解析器
  • 自动实现编码的转换

2、Beautiful soup的特点

  • API简单,功能强大

Beautiful Soup提供一些简单的方法和Python式函数,用于浏览,搜索和修改解析树,它是一个工具箱,通过解析文档为用户提供需要抓取的数据。

  • 支持多种解析器

Beautiful Soup支持多种解析器,包括Python标准库在的HTML解析器,还支持一些

  • 自动实现编码的转换

Beautiful Soup自动将输入文档转换成Unicode类型,输出文档转换为UTF-8编码。如果文档中没有指定编码,只需我们指定编码即可。

3、安装Beautiful Soup

目前Beautiful Soup的最新版本是4.x,之前的版本已经停止开发了,所以这里推荐使用Beautiful Soup4。

安装beautifulsoup的方式

pip install beautifulsoup4

命令执行完毕后即可完成安装。

在这里插入图片描述

弄了之后还是不能使用,最后我直接手动加入lxml、html5lib、bs4,还迅速,还准确在这里插入图片描述

4、Beautiful soup解析器

beautifulsoup所支持的解析器:

  1. Python标准库中的HTML解析器
  2. lxml解析器
  3. html5lib解析器

4.1、解析器的安装方法

4.1.1、安装lxml

Beautiful soup的HTML和XML解析器是依赖于lxml库的,所以在使用之前先安装lxml库。(如果已经安装,请跳过此步)

pip3 install lxml

4.1.2、安装html5lib

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

pip3 install html5lib

在这里插入图片描述

4.2、解析器的优缺点

下表列出了Beautiful Soup支持的主要的解析器以及他们的优缺点

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

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

5、前四部分总结

本节主要讲解了三个内容:

  1. Beautiful Soup功能强大、支持多种解析器
  2. 使用pip工具安装Beautiful Soup解析库
  3. 推荐使用lxml作为Beautiful Soup解析器,因为它的 解析效率高,并且文档容错能力也不错,适合大多情况下使用。

6、Beautiful Soup基本使用

6.1、使用Beautiful Soup的步骤

第一步:导入Beautiful Soup类

第二步:传递初始化参数,并初始化

第三步:获取实例对象,操作对象获取解析,提取数据

在这里插入图片描述

6.2、初始化Beautiful Soup对象

bs4中导入BeautifulSoup类实例化一个对象

form bs4 import BeautifulSoup
soup = BeautifulSoup(markup,features)

在实例化的过程中,需要给BeautifulSoup这个类传递两个参数:

1、第一个参数, markup

  • 参数解释:被解析的HTML字符串或者文本内容

  • 使用方式两种

    • 使用字符串变量

      #使用第一步的html_str字符串变量
      form bs4 import BeautifulSoup
      soup = BeautifulSoup(html_str)
      
    • 使用open()函数打开文件

      #假设将html_str字符串写入了index.html中
      from bs4 import BeautifulSoup
      soup = BeautifulSoup(open(index.html))
      

2、第二个参数,features

  • 参数解释:解析器的类型

  • 使用方式

    • 指定解析器,BeautifulSoup选择指定的解析器来解析文档

      #指定lxml作为解析器
      from bs4 imprort BeautifulSoup
      soup = BeautifulSoup(html_str,'lxml')
      
    • 未指定解析器,BeautifulSoup选择最默认的解析器来解析文档

      #解析html_str选择默认的解析器
      from bs4 import BeautifulSoup
      soup = BeautifulSoup(html_str)
      

6.3、小结

如何使用BeautifulSoup解析HTML文档?

这个非常的简单,只需要使用BeautifulSoup类初始化一个对象,然后操作这个对象就可以了。

需要注意的是:在初始化的对象的时候,需要给BeautifulSoup类传递两个参数,HTML代码和HTML解析器

这部分的内容为今后使用BeautifulSoup4的基础,需要熟练这部分的内容。

7、BeautifulSoup的深入使用——认识选择器

7.1、Beautiful Soup选择器的作用

BeautifulSoup选择器用来查找、定义元素,并获取数据。因此,学会Beautiful Soup选择器的用法的重中之重。

7.2、BeautifulSoup选择器的分类

BeautifulSoup选择器分为三类:

  1. 节点选择器:是获取数据的基础方法
  2. 方法选择器:是查找、定位元素的常用选择
  3. CSS选择器:是与方法选择器一样的

7.3、BeautifulSoup节点选择器

7.3.1、选取元素的方法

节点选择器就是使用tag对象来选择节点元素。而tag对象与HTML、XML的原生文档中的Tag相同,即标签

例如:

<title>The WEIXI's story</title>
<a href="http://example.com/elsie class="sister" id = "link1"" >Elsie</a>

title和a标签以及里面的内容为Tag对象

获取到的节点是tag对象

当有多个相同节点的时候,之后返回第一个节点

获取元素的方法:

只需要在Beautiful Soup对象后面加上标签名即可,例如soup.title

html_str = """
<html><head><title>百度一下,你就知道</title></head>
<body>
<p>Tittle</p>
<a href = "http://example.com/tillie"></a>
<a href = "https://www.csdn.net/"></a>
</body>
</html>
"""
# 1、导入Beautiful Soup类
from bs4 import BeautifulSoup
# 2、传入参数,实例化这个类
soup = BeautifulSoup(html_str,'lxml')
# 3、定位元素title
print(soup.title)
# 4、查看获取到的结果的类型 获取到的元素的类型是Tag类的对象
print(type(soup.title))
# 5、当html中存在多个相同的节点的时候,只会提取一个节点
print(type(soup.a))
程序运行结果如下:
<title>百度一下,你就知道</title>
<class 'bs4.element.Tag'>
<class 'bs4.element.Tag'>

7.3.2、提取信息的方法

通过选择元素的方式,我们获取了标签的全部信息,如果我们想想要提取标签中的信息,可以通过以下方式:

  • name获取名称
  • attrs获取属性
  • string获取内容

(1)获取名称

  • 格式:soup.tag.name
  • 返回值:字符串

(2)获取属性

  • 格式:soup.tag.attrs
  • 返回值:字典

(3)获取内容

  • 格式:soup.tag.string
  • 返回值:字符串

实战

html_str = """
<html><head><title>百度一下,你就知道</title></head>
<body>
<p>Tittle</p>
<a href = "http://example.com/tillie">Elsie</a>
<a href = "https://www.csdn.net/">Title</a>
</body>
</html>
"""

# 1 导入Beautiful Soup类
from bs4 import BeautifulSoup

# 2 传入参数,实例化这个类
soup = BeautifulSoup(html_str,'lxml')

# 3 获取a标签的名称
print(soup.a.name)#a

# 4 输出a标签的名称的类型
print(type(soup.a.name))#<class 'str'>

# 5 获取a标签的属性
print(soup.a.attrs)#{'href': 'http://example.com/tillie'}

# 6 获取a标签的值'
print(soup.a.string)#Elsie

7.3.3、嵌套选择的方法

我们可以使用soup.tag获取bs4.element.Tag类型的节点,并获取他们的信息。

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

如果提取到的节点中还嵌套了这其他子节点

<head><title>百度一下,你就知道</title></head>

那我们就可以通过下面的操作方式获取子节点的信息。

在Tag类型的基础上,再次选择得到的依然是Tag类型,每次返回的结果相同,就可以进行嵌套选择了。

  • 格式:soup.tag.tag
  • 返回值:节点元素
  • 实例:
html_str = """
<html><head><title>百度一下,你就知道</title></head>
<body>
<p>Tittle</p>
<a href = "http://example.com/tillie" class="sister" id="link1">Elsie</a>
<a href = "https://www.csdn.net/">Title</a>
</body>
</html>
"""
# 1 导入Beautiful Soup类
from bs4 import BeautifulSoup

# 2 传入参数,实例化这个类
soup = BeautifulSoup(html_str,'lxml')

# 3 获取head子节点title
print(soup.head.title)
#输出:<title>百度一下,你就知道</title>

# 4 获取head的子节点title的类型
print(type(soup.head.title))
#输出:<class 'bs4.element.Tag'>

# 5 获取head的子节点title 的内容
print(soup.head.title.string)
#输出:百度一下,你就知道

7.3.4、关联选择的方法

在做选择的时候,有时候不能做到一步就选到想要的节点元素,例如实例中的第二个a结点。

需要先选中某一个节点元素,然后以它为基准再选择它的子节点、父节点、兄弟节点等。

在这里插入图片描述

(1)子节点

  • 格式:soup.tag.contents

  • 返回值:列表

  • 格式:soup.tag.children

  • 返回值:生成器

通过下例子我们可以看出,contents和children返回的结果是一致的,但是就是返回的形式不一样

html_str = """
<html><head><title>百度一下,你就知道</title></head>
<body>
<p class = "story">Tittle
<a href = "http://example.com/tillie" class="sister" id="link1">Elsie</a>and
<a href = "https://www.csdn.net/">Title</a>you
<a href = "https://www.bilibili.com/video/BV1xt4y1U7cu?p=7">Lacie</a>love
</p>
</body>
</html>
"""

# 1 导入Beautiful Soup类
from bs4 import BeautifulSoup

# 2 传入参数,实例化这个类
soup = BeautifulSoup(html_str,'lxml')

# 3 获取p标签的子节点
print(soup.p.contents)

# 4 获取p标签的子节点 Children
print(soup.p.children)

for i,children in enumerate(soup.p.children):
    print(i,children)
运行结果如下:
['Tittle\n', <a class="sister" href="http://example.com/tillie" id="link1">Elsie</a>, 'and\n', <a href="https://www.csdn.net/">Title</a>, 'you\n', <a href="https://www.bilibili.com/video/BV1xt4y1U7cu?p=7">Lacie</a>, 'love\n']
<list_iterator object at 0x0000018EEB4FF280>
0 Tittle

1 <a class="sister" href="http://example.com/tillie" id="link1">Elsie</a>
2 and

3 <a href="https://www.csdn.net/">Title</a>
4 you

5 <a href="https://www.bilibili.com/video/BV1xt4y1U7cu?p=7">Lacie</a>
6 love

(2)子孙节点

我们拿到了p节点的全部直系的子节点,如果我们想要获取p节点中的所有子孙节点的话,可以使用descendants属性。

  • 格式:soup.p.descendants
  • 返回值:生成器

(3)父节点

使用parent属性获取某节点元素的父节点

  • 格式:soup.tag.parent

  • 返回值:节点元素

    获取额父节点,包括父节点与统计的节点

    # 6 获取a节点的父节点, parent
    #print(soup.a.parent)
    
    <p class="story">Tittle
    <a class="sister" href="http://example.com/tillie" id="link1">Elsie</a>and
    <a href="https://www.csdn.net/">Title</a>you
    <a href="https://www.bilibili.com/video/BV1xt4y1U7cu?p=7">Lacie</a>love
    </p>
    

    (4)祖先节点

  • 格式:soup.tag.parents

  • 返回值:

能够获取p节点中的所有祖先节点

# 7 获取a节点的祖先节点 parents
print(soup.a.parents)

print(list(enumerate(soup.a.parents)))
<generator object PageElement.parents at 0x000002459004CD60>
[(0, <p class="story">Tittle
<a class="sister" href="http://example.com/tillie" id="link1">Elsie</a>and
<a href="https://www.csdn.net/">Title</a>you
<a href="https://www.bilibili.com/video/BV1xt4y1U7cu?p=7">Lacie</a>love
</p>), (1, <body>
<p class="story">Tittle
<a class="sister" href="http://example.com/tillie" id="link1">Elsie</a>and
<a href="https://www.csdn.net/">Title</a>you
<a href="https://www.bilibili.com/video/BV1xt4y1U7cu?p=7">Lacie</a>love
</p>
</body>), (2, <html><head><title>百度一下,你就知道</title></head>
<body>
<p class="story">Tittle
<a class="sister" href="http://example.com/tillie" id="link1">Elsie</a>and
<a href="https://www.csdn.net/">Title</a>you
<a href="https://www.bilibili.com/video/BV1xt4y1U7cu?p=7">Lacie</a>love
</p>
</body>
</html>), (3, <html><head><title>百度一下,你就知道</title></head>
<body>
<p class="story">Tittle
<a class="sister" href="http://example.com/tillie" id="link1">Elsie</a>and
<a href="https://www.csdn.net/">Title</a>you
<a href="https://www.bilibili.com/video/BV1xt4y1U7cu?p=7">Lacie</a>love
</p>
</body>
</html>
)]

(5)兄弟节点

上面说明了子节点和父节点的获取方式,那如果我们想要获取同级的节点,应该使用sibling节点

  • 获取后面一个节点

  • 格式:soup.tag,next_sibling

  • 返回值:节点元素

  • 获取后面所有的节点

  • 格式:soup。tag。next_sibling

  • 返回值:生成器

  • 实例:

    # 8 获取a节点的兄弟节点
    print(soup.a.next_sibling)
    
    # 9 获取所有的兄弟节点
    
    print(soup.a.next_siblings)
    
    print(list(enumerate(soup.a.next_siblings)))
    
    #输出结果:
    and
    
    <generator object PageElement.next_siblings at 0x0000020E84DBCDD0>
    [(0, 'and\n'), (1, <a href="https://www.csdn.net/">Title</a>), (2, 'you\n'), (3, <a href="https://www.bilibili.com/video/BV1xt4y1U7cu?p=7">Lacie</a>), (4, 'love\n')]
    
    
  • 获取前面的一个节点

  • 格式:soup.tag.previous_sibling

  • 返回值:节点元素

  • 获取前面的所有节点

  • 格式:soup.tag.previous_siblings

  • 返回值:生成器

html_str = """
<html><head><title>百度一下,你就知道</title></head>
<body>
<p class = "story">Tittle
<a href = "http://example.com/tillie" class="sister" id="link1">Elsie</a>and
<a href = "https://www.csdn.net/">Title</a>you
<a href = "https://www.bilibili.com/video/BV1xt4y1U7cu?p=7">Lacie</a>love
</p>
</body>
</html>
"""

# 1 导入Beautiful Soup类
from bs4 import BeautifulSoup

# 2 传入参数,实例化这个类
soup = BeautifulSoup(html_str,'lxml')

# # 3 获取p标签的子节点
# print(soup.p.contents)
#
# # 4 获取p标签的子节点 Children
# print(soup.p.children)
#
# for i,children in enumerate(soup.p.children):
#     print(i,children)
#

# 6 获取a节点的父节点, parent
# print(soup.a.parent)

# # 7 获取a节点的祖先节点 parents
# print(soup.a.parents)
#
# print(list(enumerate(soup.a.parents)))

# 8 获取a节点的兄弟节点
print(soup.a.next_sibling)

# 9 获取所有的兄弟节点

print(soup.a.next_siblings)

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

8、Beautiful Soup CSS选择器的概括

使用CSS选择器,只需要调用select()方法,并结合CSS选择器语法就可以定位元素的位置

8.1、CSS选择器的基本使用——使用CSS选择器定位元素

8.1.1、获取元素

  • 格式:soup.select()
soup为Beautiful Soup对象
`select()` 中书写CSS选择器的语法

8.1.2、CSS选择器语法

(1)id选择器

id选择器需要使用#来定位元素,例如:获取第一个ul节点 #list-1

(2)类选择器

类选择器需要使用.来定位元素,例如:获取所有的ul .list

(3)标签选择器

标签选择器需要使用标签来进行选择,例如h4

(4)混合使用

获取第一个ul的li节点,。panel-body #list-1 li

实战

"""
案例要求:
    1、获取class="panel-heading"的div
    2、获取所有的li节点
    3、获取第二个ul的li节点
    4、获取第二个ul节点
"""
html_str = """
<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_str,'lxml')

#  1、获取class="panel-heading"的div
print(soup.select(".panel .panel-heading"))#记住这个地方要有一个空格

#  2、获取所有的li节点 标签选择器
print(soup.select("ul li"))

#  3、获取所有的li节点 类选择器
print(soup.select(".list .element"))

print("# 4、获取第二个ul的li节点 id选择器")
print(soup.select("#list-2 li"))

print("# 4、获取第二个ul的li节点 类选择器 ")
print(soup.select(".list-small li"))

print("# 4、获取第二个ul的li节点 列表获取 ")
print(soup.select("ul")[1])
程序运行结果如下:
[<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>, <li class="element">Jay</li>, <li class="element">Foo</li>, <li class="element">Bar</li>]
# 4、获取第二个ul的li节点 id选择器
[<li class="element">Foo</li>, <li class="element">Bar</li>]
# 4、获取第二个ul的li节点 类选择器 
[<li class="element">Foo</li>, <li class="element">Bar</li>]
# 4、获取第二个ul的li节点 列表获取 
<ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>

8.2、CSS选择器的高级使用

8.2.1、嵌套选择

这里的嵌套选择和我们之前所学的嵌套选择是一样的,先选择一个节点,再获取这个节点的子节点。之所以能够进行嵌套选择是因为它依然是一个Tag对象

html_str = """
<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_str,'lxml')

# 3 获取ul节点
print(soup.select("ul"))

# 4 查看ul节点的类型
print(type(soup.select("ul")))

for ul in soup.select("ul"):
    print(ul)
    print(type(ul))
    print(ul.select(("li")))
程序运行结果如下:
     
[<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.ResultSet'>
<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'>
[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>]
<ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>
<class 'bs4.element.Tag'>
[<li class="element">Foo</li>, <li class="element">Bar</li>]

8.2.2、获取属性

CSS选择器获取属性的方法和节点选择器获取属性的方法一眼,使用attrs属性来获取

8.2.3、获取文本

CSS选择器获取文本的方法和节点选择器获取文本的方法一样,使用stringstrings属性来获取。

9、Beautiful Soup方法选择器

前面所讲的选择方法都是通过标签和属性来选择的,这种方法非常快,但是如果在比较复杂的页面中选择元素,无法精确的定位到元素。

比如:

<a href = "http://example.com/tillie" class="sister" id="link1">Elsie</a>
<a href = "https://www.csdn.net/">Title</a>
<a href = "https://www.bilibili.com/video/BV1xt4y1U7cu?p=7">Lacie</a>

在HTML文档中存在多个<a>标签,我们无法使用节点选择器精准的定位到第二个、第三个<a>标签,所以我们在这里学习findall()find()方法,通过传入参数的方法,来进行精确的定位。在这里插入图片描述

9.1、find_all()方法

9.1.1、作用及范围

  • 作用:用于搜索当前节点的所有符合条件的节点
  • 范围:当前节点下的所有节点

9.1.2、用法介绍:

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

(1)name属性

name 参数的作用是用来查找所有名字为名字的节点(tag对象)。在使用的时候,可以接收字符串、正则表达式、列表、布尔值。

在这里插入图片描述

参数形式:字符串
传入一个字符串参数,即标签名(tag),Beautiful Soup会查找与字符串内容完全匹配的内容

# 寻找所有span标签
print(soup.find_all('span'))

# 输出结果
[<span>Elsie</span>]

参数形式:正则表达式
传入正则表达式,Beautiful Soup会通过正则表达式的match()函数来匹配内容

# 使用正则匹配以b开头的标签
import re

for tag in soup.find_all(re.compile('^b')):
    print(tag.name)
    
# 输出结果
body

参数形式:列表
传入列表参数,Beautiful Soup会将与列表中任一元素匹配,并返回结果。

# 使用列表选择包含a和span的所有标签
print(soup.find_all(['a', 'span']))

# 输出结果
[<a class="sister" href="http://example.com/elsie" id="link1"><span>Elsie</span></a>, <span>Elsie</span>, <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可以匹配任何值

# 使用True选择文件中所有标签
for tag in soup.find_all(True):
    print(tag.name)
    
# 输出结果
html
head
title
body
p
a
span
a
a
p

(2) attrs参数

作用:查询含有接受的属性值的标签

参数形式:字典类型

# 获取id为link1的标签
print(soup.find_all(attrs={id: 'link1'}))

# 输出结果
[<a class="sister" href="http://example.com/elsie" id="link1"><span>Elsie</span></a>]

(3) kwargs参数

作用:接收常用的属性参数,如id和class

参数形式:变量赋值的形式

# 获取id为link1的标签
print(soup.find_all(id='link1'))

# 输出结果
[<a class="sister" href="http://example.com/elsie" id="link1"><span>Elsie</span></a>]

这里直接传入id=‘link1’,就查询到id为’link1’的节点元素了。而对于class来说,它在Python中是一个关键字,需要加一个下划线,即class_=‘element’。

(4) text参数

作用:查询含有接收的文本的标签

参数形式:字符串

通过搜索文档中的字符串内容,来确定文件标签。

# 获取文本中包含Elsie内容
print(soup.find_all(text='Elsie'))

# 输出结果
['Elsie']

虽然text参数用于搜索字符串,还可以与其他参数混合使用来过滤tag

# 获取文本中包含Elsie内容的标签
print(soup.find_all('a', text='Elsie'))

# 输出结果
[<a class="sister" href="http://example.com/elsie" id="link1"><span>Elsie</span></a>]

(5) limit参数

作用:用于限制返回结果的数量
参数形式:整数

# 获取前两个a标签
print(soup.find_all('a', limit=2))

# 输出结果
[<a class="sister" href="http://example.com/elsie" id="link1"><span>Elsie</span></a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

(6) recursive参数

作用:决定是否获取子孙节点

参数形式:布尔值,默认是True

print(soup.find_all('title'))
print(soup.find_all('title', recursive=False))
      
# 输出结果
[<title>The Dormouse's story</title>]
[]

9.2、方法选择器之find()方法

find()方法和find_all()方法类似,作用都是在文档中查找需要的信息

区别点在于:

find_all()方法返回所有符合条件的元素列表,而find()方法就是返回符合条件的第一个元素

除了limit参数不能在find()方法中使用,find()方法的其他参数和find_all()的参数用法一样
find()方法

作用:查找当前节点下,符合条件的一个元素节点

范围:当前节点下的一个元素

(1) name参数

# 获取a标签
print(soup.find('a'))

# 输出结果
<a class="sister" href="http://example.com/elsie" id="link1"><span>Elsie</span></a>

(2) attrs参数

# 获取class等于sister的标签
print(soup.find(attrs={'class': 'sister'}))

# 输出结果
<a class="sister" href="http://example.com/elsie" id="link1"><span>Elsie</span></a>

(3) kwargs参数
作用:接收常用的属性参数,如id和class
参数形式:变量赋值的形式

# 获取class等于sister的标签
print(soup.find(class_='sister'))

# 输出结果
<a class="sister" href="http://example.com/elsie" id="link1"><span>Elsie</span></a>

(4) text参数
作用:查询含有接收的文本的标签
参数形式:字符串
通过搜索文档中的字符串内容,来确定文件标签。

# 获取文本中包含story的标签
print(soup.find(text=re.compile('.*?story')))

# 输出结果
The Dormouse's story

(5) recursive参数
作用:决定是否获取子孙节点
参数形式:布尔值,默认是True

# 获取文本中包含story的标签
print(soup.find('a', recursive=False)

# 输出结果
None

9.3、其他方法

在Beautiful Soup中还存在其他的方法,根据自己的业务需求使用就行可以。参数的用法相同,唯一的区别点在于搜索的范围。在这里插入图片描述

小结:

name参数用来接收tag名称,有四种形式:字符串,正则,列表和True
attrs参数用来接收属性的键值对字典
kwargs参数用来接收常用属性的变量赋值的形式 例如:id=‘link1’,class_=“sister”
text参数用来接收文本信息
limit参数用来限制返回结果的数量
recursive参数用来决定是否获取子孙节点

  • 2
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值