Python爬虫之Beautiful soup模块

未晞~

已于 2022-09-11 18:18:50 修改

阅读量1.2k

点赞数 2

分类专栏：爬虫 Python 文章标签： python 爬虫数据挖掘

于 2022-09-11 18:17:46 首次发布

本文链接：https://blog.csdn.net/qq_61529681/article/details/126807727

版权

Python 同时被 2 个专栏收录

13 篇文章 0 订阅

订阅专栏

爬虫

4 篇文章 0 订阅

订阅专栏

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所支持的解析器：

Python标准库中的HTML解析器
lxml解析器
html5lib解析器

4.1、解析器的安装方法

4.1.1、安装lxml

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

pip3 install lxml

4.1.2、安装html5lib

另一个可供选择的解析器是纯Python实现的html5lib，html5lib的解析方法与浏览器相同，可以选择下列方法来安装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语言库
html5lib	BeautifulSoup(markup,”html5lib”)	最好的容错性、以浏览器的方式解析文档、生成HTML5格式的文档	速度慢、不依赖外部扩展

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

5、前四部分总结

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

Beautiful Soup功能强大、支持多种解析器
使用pip工具安装Beautiful Soup解析库
推荐使用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选择器分为三类：

节点选择器：是获取数据的基础方法
方法选择器：是查找、定位元素的常用选择
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选择器获取文本的方法和节点选择器获取文本的方法一样，使用string和strings属性来获取。

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参数用来决定是否获取子孙节点