BeautifulSoup库使用方法

最新推荐文章于 2024-04-17 20:54:27 发布
最新推荐文章于 2024-04-17 20:54:27 发布
阅读量1.6k 收藏 12
点赞数
分类专栏： Python 文章标签： python 爬虫
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Aerialseed/article/details/117339218
版权

文章目录

0.初始化

官方字符串来演示：

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

1.创建 BeautifulSoup 对象

首先导入库 bs4 lxml requests

soup = BeautifulSoup(html,'lxml')  #创建 beautifulsoup 对象
soup = BeautifulSoup(html,'html.parser') # 以html的方式解析，其中html为网页内容字符串

2.四种对象

1.Tag

Tag就是 HTML 中的一个个标签，例如：

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

用 BeautifulSoup 可以很方便地获取 Tags：

print(soup.title)
print(soup.head)
print(soup.a)
print(soup.p)
print(type(soup.a))
//语法：soup对象.标签名
//这种方式查找的是在所有内容中的第一个符合要求的标签。

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

 #获取标签name
print soup.name

#获取a标签name
print soup.a.name 

 #获取所以的属性
print soup.attrs

#在这里，我们把 p 标签的所有属性打印输出了出来，得到的类型是一个字典。
print soup.p.attrs 

#单独获取某个属性
print soup.p['class'] 

#单独获取某个属性 跟上面一样的
print soup.p.get('class') 

#可以对这些属性和内容等等进行修改
soup.p['class']="newClass"

#可以对这个属性进行删除：
del soup.p['class']

2.NavigableString

我们已经得到了标签,我们要想获取标签内部的文字用 .string 即可，例如：

print(bs.title.string) #获取的标签内部文字

3.BeautifulSoup

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

print(type(soup.name))
#<type 'unicode'>

print(soup.name)
# [document]

print(soup.attrs)
#{} 空字典

4.Comment

Comment 对象是一个特殊类型的 NavigableString 对象，其输出的内容不包括注释符号。

print(soup.a)
print(soup.a.string)
print(type(soup.a.string))
# 输出
<a class="sister" id="link1"><!-- AAA --></a>
AAA
<class 'bs4.element.Comment'>
# 判断内容是否为注释可以使用：
soup.a.string==bs4.element.Comment

3.遍历文档树

1.直接子节点

tag 的contents属性可以将tag的子节点以列表的方式输出：

print(soup.head.contents) 
# 运行结果：
[<title>The Dormouse's story</title>]
# 输出方式为列表，我们可以用列表索引来获取它的某一个元素：
print soup.head.contents[0]

children它返回的不是一个 list，不过我们可以通过遍历获取所有子节点。

# 我们打印输出children 看一下，可以发现它是一个 list 生成器对象：
print soup.head.children
运行结果：
<listiterator object at 0x7f71457f5710>

# 遍历一下获得里面的内容：
for item in  soup.body.children:
    print item

2.所有子孙节点

descendants属性可以对所有tag的子孙节点进行递归循环，和 children类似，要获取其中的内容，我们需要对其进行遍历：

# contents和children属性仅包含tag的直接子节点
# descendants包含子孙节点

for item in soup.descendants:
    print item
    
# 查看运行结果，可以发现，所有的节点都被打印出来了：
<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>,

3.节点内容

如果一个标签里面没有标签了，那么.string 就会返回标签里面的内容。

如果标签里面只有唯一的一个标签了，那么 .string 也会返回最里面的内容：

print(soup.head.string)
# 运行结果：
The Dormouse's story

# 第二种情况：
print(soup.title.string)
# 运行结果：
The Dormouse's story

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

4.多个内容

.strings获取多个内容，不过需要遍历获取，比如下面的例子：

for string in soup.strings:
    print(repr(string))

# 输出的字符串中可能包含了很多空格或空行,使用 .stripped_strings 可以去除多余空白内容：
for string in soup.stripped_strings:
    print(repr(string))

5.父节点

p = soup.p
print p.parent.name
# 运行结果:
body

content = soup.head.title.string
print content.parent.name
# 运行结果：
title

6.全部父节点

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

content = soup.head.title.string
for parent in  content.parents:
    print parent.name

7.兄弟节点

兄弟节点可以理解为和本节点处在统一级的节点，也就是同一个父亲，父节点
.next_sibling 属性获取了该节点的下一个兄弟节点，
.previous_sibling 属性获取了该节点的上一个兄弟节点，
如果节点不存在，则返回 None

# 注意：实际文档中的tag的 .next_sibling 和 .previous_sibling 属性通常是字符串或空白，因为空白或者换行也可以被视作一个节点，所以得到的结果可能是空白或者换行。

print soup.p.next_sibling
#       实际该处为空白
print soup.p.prev_sibling
#None   没有前一个兄弟节点，返回 None
print soup.p.next_sibling.next_sibling

8.全部兄弟节点

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

for sibling in soup.a.next_siblings:
    print(repr(sibling))

9.前后节点

与 .next_sibling  .previous_sibling 不同，它并不是针对于兄弟节点，而是在所有节点，不分层次

# 比如 head 节点为：
<head><title>The Dormouse's story</title></head>
# 那么它的下一个节点便是 title，它是不分层次关系的。
print(soup.head.next_element)
#<title>The Dormouse's story</title>

10.所有前后节点

通过.next_elements和.previous_elements的迭代器就可以向前或向后访问文档的解析内容：

for element in last_a_tag.next_elements:
    print(repr(element))

4.搜索文档树

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

find_all()方法搜索当前tag的所有tag子节点,并判断是否符合过滤器的条件

1.name 参数

A.传字符串
name参数可以查找所有名字为name的tag,字符串对象会被自动忽略掉

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

soup.find_all('b')
# [<b>The Dormouse's story</b>]
B.传正则表达式

如果传入正则表达式作为参数,Beautiful Soup会通过正则表达式的match()来匹配内容.

# 下面例子中找出所有以b开头的标签,这表示<body>和<b>标签都应该被找到
import re
for tag in soup.find_all(re.compile("^b")):
    print(tag.name)
# body
# b
C.传列表

如果传入列表参数,Beautiful Soup会将与列表中任一元素匹配的内容返回.下面代码找到文档中所有标签和标签

soup.find_all(["a", "b"])
# [<b>The Dormouse's story</b>,
#  <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
D.传 True

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

for tag in soup.find_all(True):
    print(tag.name)
# html
# head
# title
# body
# p
# b
# p
# a
# a
E.传方法

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

def has_class_but_no_id(tag):
    return tag.has_attr('class') and not tag.has_attr('id')
将这个方法作为参数传入find_all()方法,将得到所有<p>标签：

soup.find_all(has_class_but_no_id)
# [<p class="title"><b>The Dormouse's story</b></p>,
#  <p class="story">Once upon a time there were...</p>,
#  <p class="story">...</p>]

2.keyword 参数

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

soup.find_all(id='link2')
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]
如果传入href参数,Beautiful Soup会搜索每个tag的”href”属性：

soup.find_all(href=re.compile("elsie"))
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]
使用多个指定名字的参数可以同时过滤tag的多个属性：

soup.find_all(href=re.compile("elsie"), id='link1')
# [<a class="sister" href="http://example.com/elsie" id="link1">three</a>]
在这里我们想用 class 过滤，不过 class 是 python 的关键词，加个下划线就可以：

soup.find_all("a", class_="sister")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
有些tag属性在搜索不能使用,比如HTML5中的 data-* 属性：

data_soup = BeautifulSoup('<div data-foo="value">foo!</div>')
data_soup.find_all(data-foo="value")
# SyntaxError: keyword can't be an expression
可以通过find_all()方法的attrs参数定义一个字典参数来搜索包含特殊属性的tag：

data_soup.find_all(attrs={"data-foo": "value"})
# [<div data-foo="value">foo!</div>]

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"The Dormouse's story", u"The Dormouse's story"]

4.limit 参数

find_all() 方法返回全部的搜索结构,如果文档树很大那么搜索会很慢.如果我们不需要全部结果,可以使用 limit 参数限制返回结果的数量.效果与SQL中的limit关键字类似,当搜索到的结果数量达到 limit 的限制时,就停止搜索返回结果.

文档树中有3个tag符合搜索条件,但结果只返回了2个,因为我们限制了返回数量：
soup.find_all("a", limit=2)
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

5.recursive 参数

调用tag的 find_all() 方法时,Beautiful Soup会检索当前tag的所有子孙节点,如果只想搜索tag的直接子节点,可以使用参数 recursive=False：

soup.html.find_all("title")
# [<title>The Dormouse's story</title>]
 
soup.html.find_all("title", recursive=False)

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

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

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() 完全相同，原理均类似。

5. CSS选择器

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

通过标签名查找

print soup.select('title') 
#[<title>The Dormouse's story</title>]
print soup.select('a')
#[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

2.通过类名查找

print soup.select('.sister')
#[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

3.通过 id 名查找

print soup.select('#link1')
#[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>]

4.组合查找

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

print soup.select('p #link1')
#[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>]
直接子标签查找：

print soup.select("head > title")
#[<title>The Dormouse's story</title>]

5.属性查找

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

print soup.select('a[class="sister"]')
#[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
print soup.select('a[href="http://example.com/elsie"]')
#[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>]
属性也可以与上述查找方式组合，不在同一节点的空格隔开，同一节点的不加空格：

print soup.select('p a[href="http://example.com/elsie"]')
#[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>]
以上的 select 方法返回的结果都是列表形式，可以遍历形式输出，然后用 get_text() 方法来获取它的内容：

soup = BeautifulSoup(html, 'lxml')
print type(soup.select('title'))
print soup.select('title')[0].get_text()
 
for title in soup.select('title'):
    print title.get_text()
我不吃辣椒呀
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用BeautifulSoup4解析XML的方法小结
01-19
Beautiful Soup 是一个用来从HTML或XML文件中提取数据的Python库，它利用大家所喜欢的解析器提供了许多惯用方法用来对文档树进行导航、查找和修改。 帮助文档英文版：https://www.crummy.com/software/BeautifulSoup/bs4/doc/ 帮助文档中文版：https://www.crummy.com/software/BeautifulSoup/bs4/doc.zh/ 入门示例 以下是电影《爱丽丝梦游仙境》中的一段HTML内容： 我们以此为例，对如何使用BeautifulSoup解析HTML页面内容进行简单入门示例： from bs4
Python爬虫库BeautifulSoup的介绍与简单使用实例
01-20
一、介绍 BeautifulSoup库是灵活又方便的网页解析库，处理高效，支持多种解析器。利用它不用编写正则表达式即可方便地实现网页信息的提取。 Python常用解析库 解析器 使用方法 优势 劣势 Python标准库 BeautifulSoup(markup, “html.parser”) Python的内置标准库、执行速度适中 、文档容错能力强 Python 2.7.3 or 3.2.2)前的版本中文容错能力差 lxml HTML 解析器 BeautifulSoup(markup, “lxml”) 速度快、文档容错能力强 需要安装C语言库 lxml XML 解析器 Bea
next_siblings()函数介绍
最新发布
weixin_43765541的博客
04-17 256
是一个 BeautifulSoup 库中的函数，用于在 HTML 或 XML 文档中查找当前节点之后的所有兄弟节点。它返回一个生成器对象，可以用于迭代获取当前节点之后的所有兄弟节点。这个函数对于在解析 HTML 或 XML 文档时查找特定节点之后的相关内容非常有用。标签后的所有兄弟节点，即第二个和第三个。
Python利用BeautifulSoup解析Html的方法示例
09-21
BeautifulSoup是python的一个库，最主要的功能是从网页抓取数据。下面这篇文章主要给大家介绍了关于Python利用BeautifulSoup解析Html的方法示例，文中通过示例代码介绍的非常详细，需要的朋友们下面跟着小编来一起学习学习吧。
Python使用BeautifulSoup库解析HTML基本使用教程
01-20
BeautifulSoup是Python的一个第三方库，可用于帮助解析html/XML等内容，以抓取特定的网页信息。目前最新的是v4版本，这里主要总结一下我使用的v3版本解析html的一些常用方法。 准备 1.Beautiful Soup安装 为了能够对页面中的内容进行解析，本文使用Beautiful Soup。当然，本文的例子需求较简单，完全可以使用分析字符串的方式。 执行 sudo easy_install beautifulsoup4 即可安装。 2.requests模块的安装 requests模块用于加载要请求的web页面。 在python的命令行中输入import requests
BeautifulSoup基本用法总结
热门推荐
kikaylee的专栏
02-24 8万+
BeautifulSoup是Python的一个库，最主要的功能就是从网页爬取我们需要的数据。BeautifulSoup将html解析为对象进行处理，全部页面转变为字典或者数组，相对于正则表达式的方式，可以大大简化处理过程。
BeautifulSoup库的基本使用
m0_46926492的博客
10-23 2928
【代码】BeautifulSoup库的基本使用。
Beautiful Soup 基本使用方法
songshao の blog
06-06 6万+
我们就来介绍一个强大的解析工具Beautiful Soup，它借助网页的结构和属性等特性来解析网页。有了它，我们不用再去写一些复杂的正则表达式，只需要简单的几条语句，就可以完成网页中某个元素的提取。 1、简介 简单来说，Beautiful Soup就是Python的一个HTML或XML的解析库，可以用它来方便地从网页中提取数据。官方解释如下： Beautiful Soup提供一些简单的、Py...
python beautiful soup库的用法
weixin_34127717的博客
03-09 2870
参考：http://cuiqingcai.com/1319.html Beautiful Soup 4.2.0 文档 1. Beautiful Soup 简介 简单来说，Beautiful Soup是python的一个库，最主要的功能是从网页抓取数据。官方解释如下： Beautiful Soup提供一些简单的、python式的函数用来处理导航、搜索...
BeautifulSoup的使用与入门
qq_46433748的博客
02-21 1504
它支持多种解析器，包括python标准库、lxml HTML解析器、lxml XML解析器、html5lib等。结合稳定性和速度，这里推荐使用lxml HTML解析器。如果lxml不能正确解析内容，这是可以使用html5lib。
超级详细的BeautifulSoup使用方法
zt772612939的博客
09-09 2万+
BeautifulSoup 的使用 我们学习了正则表达式的相关用法，但是一旦正则写的有问题，可能得到的就不是我们想要的结果了，而且对于一个网页来说，都有一定的特殊的结构和层级关系，而且很多标签都有 id 或 class 来对作区分，所以我们借助于它们的结构和属性来提取不也是可以的吗？ 所以，这一节我们就介绍一个强大的解析工具，叫做 BeautiSoup，它就是借助网页的结构和属性等特性来解析网页...
Python爬虫之BeautifulSoup库
12-22
文章目录1、BeautifulSoup库的介绍2、常用API介绍2.1、prettify()2.2、简单选择元素并获取属性、内容2.3、多级选择、关联选择2.4、find_all()等方法2.5、CSS选择器3、总结 1、BeautifulSoup库的介绍   因为HTML...
python3实现网络爬虫之BeautifulSoup使用详解
09-19
首先，安装BeautifulSoup库是非常简单的。由于它不是Python的标准库，我们需要通过第三方工具如pip或集成开发环境（IDE）如PyCharm来安装。在PyCharm中，你可以通过设置 -> 项目 -> 项目解释器界面找到添加新包的...
Python网页解析利器BeautifulSoup安装使用介绍
09-22
BeautifulSoup通常与`requests`库结合使用，用于发送HTTP请求并获取网页内容。例如，要获取一个网页并解析，可以这样操作： ```python import requests from bs4 import BeautifulSoup url = 'http://example.com'...
BeautifulSoup的基本使用
hacker707的博客
03-21 1万+
BeautifulSoup是一个用于从HTML和XML文件中提取数据的python模块。BeautifulSoup模块的查找提取功能非常强大，而且使用起来非常便捷，可以节约很多时间
BeautifulSoup的使用
zsewer的博客
02-25 625
使用BeautifulSoup解析代码,能够得到一个 BeautifulSoup 的对象,并能按照标准的缩进格式的结构输出 。本文主要介绍了BeautifulSoup的基础使用方法。
Python BeautifulSoup 库使用教程
m0_56208280的博客
11-12 376
BeautiSoup 库主要用来解析 HTML 格式的网络文件，通过解析文档为用户提供需要抓取的数据。
网络爬虫之BeautifulSoup详解（含多个案例）
手把手教你学编程
04-14 6254
BeautifulSoup是Python的一个HTML或XML的第三方解析库，可以用它方便地从网页中提取数据。它提供一些简单的、Python式的函数来处理导航、搜索、修改分析树等功能。它是一个工具箱，利用它可以省去很多烦琐的提取工作，提高了解析效率。
BeautifulSoup库用法总结
Wayne_Dream的博客
06-02 320
0.写在前面 在python的爬虫中，经常需要用到强大的beautifulsoup库，如之前写的股票数据的爬取中就用到了它。在这里，将详细总结beautifulsoup的用法，来巩固相关知识。以下便是我从各种网站搜集的资料，在这里做一个汇总。(我从不生产知识，我只是知识的搬运工） 1.基本介绍 beautifulsoup 2.安装/引用 安装：...
详细说明BeautifulSoup库的使用
06-06
它的使用非常简单，以下是使用BeautifulSoup库的基本步骤： 1. 安装BeautifulSoup库：使用pip命令安装BeautifulSoup库，如：pip install beautifulsoup4。 2. 导入库：在Python脚本中导入BeautifulSoup库，如：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值