爬虫基础---4.bs4解析

最新推荐文章于 2023-09-27 17:41:19 发布
最新推荐文章于 2023-09-27 17:41:19 发布
阅读量283 收藏
点赞数
分类专栏： python爬虫基础 文章标签： 爬虫 python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42538329/article/details/127316467
版权

beautifulsoup

一、beautifulsoup-------使用

Beautiful Soup可以用来处理导航、搜索、修改分析树等功能。在爬虫学习过程中，可以用来抓取数据。

1、安装

1.1、安装beautifulsoup4
pip install beautifulsoup4
1.2、安装lxml
pip install lxml

2、基础代码

下面的一段HTML代码将作为例子（搬运学习时的资料）：

html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title"><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>
"""

使用BeautifulSoup解析,能够得到一个 BeautifulSoup 的对象,并能按照标准的缩进格式的结构输出:

from bs4 import BeautifulSoup

soup = BeautifulSoup(html_doc, 'lxml')
# html进行美化
print(soup.prettify())

优化后的代码：

<html>
 <head>
  <title>
   The Dormouse's story
  </title>
 </head>
 <body>
  <p class="title">
   <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>

简单的浏览结构化数据的方法：

soup.title  # 获取标签title # <title>The Dormouse's story</title>

soup.title.name   # 获取标签名称 # 'title'

soup.title.string   # 获取标签title内的内容 #    'The Dormouse's story'

soup.title.parent  # 获取父级标签

soup.title.parent.name  # 获取父级标签名称  # 'head'

soup.p # 获得p标签内容 # <p class="title"><b>The Dormouse's story</b></p>

soup.p['class']  # 获取p的class属性值  # 'title'

soup.a # 获得第一个a标签内容
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>

soup.find_all('a') # 获得全部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>]

soup.find(id="link3")  # 获取id为link3的标签
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>

从文档中找到所有<a>标签的链接:

for i in soup.find_all('a'):  # 遍历出a标签的内容信息
    print(i.get('href'))  # 打印出含有href的值。
    # http://example.com/elsie
    # http://example.com/lacie
    # http://example.com/tillie

从文档中获取所有文字内容:

print(soup.get_text())

3、对象的种类

Beautiful Soup可以将复杂HTML文档转换成一个复杂的树形结构,每个节点都是Python对象,所有对象可以归纳为 Tag , NavigableString , BeautifulSoup , Comment 。

3.1 Tag对象

Tag 对象就是 HTML 中的一个个标签。

from bs4 import BeautifulSoup
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title"><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>
"""
soup = BeautifulSoup(html_doc, 'lxml')
a = soup.b
print(a)  # <b>The Dormouse's story</b>
print(type(a))  # <class 'bs4.element.Tag'>

通过标签属性可以获取到需要的内容信息。

from bs4 import BeautifulSoup
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title"><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>
"""
soup = BeautifulSoup(html_doc, 'lxml')
a = soup.head
b = soup.title
print(a) # <head><title>The Dormouse's story</title></head>
print(b) # <title>The Dormouse's story</title>

可以通过标签.标签的形式快速获得需要的某个内容。

soup.body.b # <b>The Dormouse's story</b>

注意：当获取内容中有多个一样的tag，通过点取属性的方式只能获得当前名字的第一个tag。

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

使用 find_all()函数可以获得所有的重复tag的内容信息。

soup.find_all('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>]
3.2 NavigableString(字符串)

通过标签.string可以获得标签内容的内容信息。

from bs4 import BeautifulSoup
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title"><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>
"""
soup = BeautifulSoup(html_doc, 'lxml')
a = soup.p.string
b = type(soup.p.string)
print(a)  # The Dormouse's story
print(b)  # <class 'bs4.element.NavigableString'>
3.3 BeautifulSoup

BeautifulSoup 对象表示的是一个文档的全部内容。我们可以分别获取它的类型，名称，以及属性。

from bs4 import BeautifulSoup
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title"><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>
"""
soup = BeautifulSoup(html_doc, 'lxml')
a = type(soup.name) # 类型
b = soup.name  # 名称
c = soup.attrs  # 属性
print(a)  # <class 'str'>
print(b)  # [document]
print(c)  # {}
3.4 Comment

如果字符串内容为注释 则为Comment。

html_doc='<a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>'
soup = BeautifulSoup(html_doc, 'html.parser')
print(soup.a.string)   # Elsie
print(type(soup.a.string))  #  <class 'bs4.element.Comment'>

a 标签里的内容实际上是注释，但是如果利用 .string 来输出它的内容，我们发现它已经把注释符号去掉了。

二、beautifulsoup-------遍历

html_doc = """
<html><head><title>The Dormouse's story</title></head>
    <body>
<p class="title"><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_doc, 'lxml')

通过这段例子来演示怎样从文档的一段内容找到另一段内容。

1、子节点

Beautiful Soup提供了许多操作和遍历子节点的属性。

1.1 .contents 和 .children

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

soup = BeautifulSoup(html_doc, 'lxml')
head_tag = soup.head  # <head><title>The Dormouse's story</title></head>
b = head_tag.contents  # [<title>The Dormouse's story</title>]
title_tag = head_tag.contents[0]  # <title>The Dormouse's story</title>
d = title_tag.contents # ["The Dormouse's story"]
# [u'The Dormouse's story']
print(head_tag )
print(b)
print(title_tag)
print(d)

字符串没有 .contents 属性,因为字符串没有子节点。

text = title_tag.contents[0]
text.contents
# AttributeError: 'NavigableString' object has no attribute 'contents'

通过tag的 .children 生成器,可以对tag的子节点进行循环:

print(title_tag.children)       # <list_iterator object at 0x101b78860>
print(type(title_tag.children)) # <class 'list_iterator'>

for child in title_tag.children:
    print(child)     # The Dormouse's story
1.2 .descendants

.contents 和 .children 属性仅包含tag的直接子节点.例如,<head>标签只有一个直接子节点<title>

head_tag.contents # [<title>The Dormouse's story</title>]

但是<title>标签也包含一个子节点:字符串 “The Dormouse’s story”,这种情况下字符串 “The Dormouse’s story”也属于<head>标签的子孙节点.

.descendants 属性可以对所有tag的子孙节点进行递归循环 。

for child in head_tag.descendants:
    print(child)     # The Dormouse's story

2、 节点内容

2.1 .string
print (soup.head.string)  # The Dormouse's story

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

print (soup.html.string)  # None
2.2 .text

如果tag包含了多个子节点, text则会返回内部所有文本内容

print (soup.html.text)

3、 多个内容

.strings .stripped_strings 属性
3.1**.strings**

使用.strings获取多个内容，比如下面的例子：

for string in soup.strings:
    print(repr(string))
'''
  '\n'
"The Dormouse's story"
'\n'
'\n'
"The Dormouse's story"
'\n'
'Once upon a time there were three little sisters; and their names were\n'
'Elsie'
',\n'
'Lacie'
' and\n'
'Tillie'
';\nand they lived at the bottom of a well.'
'\n'
'...'
'\n'  
    
'''
3.2 .stripped_strings

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

for string in soup.stripped_strings:
    print(repr(string))
'''

"The Dormouse's story"
"The Dormouse's story"
'Once upon a time there were three little sisters; and their names were'
'Elsie'
','
'Lacie'
'and'
'Tillie'
';\nand they lived at the bottom of a well.'
'...'

'''

4、 父节点

4.1 .parent

通过 .parent 属性来获取某个元素的父节点。

from bs4 import BeautifulSoup
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title"><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>
"""
soup = BeautifulSoup(html_doc, 'lxml')
a = soup.title
b = a.parent # 获取父节点
print(a)  # <title>The Dormouse's story</title>
print(b)  # <head><title>The Dormouse's story</title></head>

文档的顶层节点比如<html>的父节点是 BeautifulSoup 对象:

html_tag = soup.html
type(html_tag.parent)
# <class 'bs4.BeautifulSoup'>
4.2 .parents

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

from bs4 import BeautifulSoup
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title"><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>
"""
soup = BeautifulSoup(html_doc, 'lxml')
a = soup.a
for i in a.parents:
    print(i.name)  # p body html [document]

三、beautifulsoup-------搜索

1、find_all（）

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

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

soup.find_all("title") # [<title>The Dormouse's story</title>]
soup.find_all("p", "title")  # [<p class="title"><b>The Dormouse's story</b></p>]
soup.find_all("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>]
soup.find_all(id="link2")
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

import re
# 模糊查询 包含sisters的就可以
soup.find(string=re.compile("sisters"))
# 'Once upon a time there were three little sisters; and their names were\n'
1.1 name 参数

name 参数可以查找所有名字为 name 的tag。

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

（1） 传字符串

soup.find_all('b')  # [<b>The Dormouse's story</b>]

（2）传正则表达式

import re
for tag in soup.find_all(re.compile("^b")):
    print(tag.name)
# body
# b

（3） 传列表

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>]
1.2 keyword 参数
soup.find_all(id='link2')
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

import re
# 超链接包含elsie标签
print(soup.find_all(href=re.compile("elsie")))
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]
# 以The作为开头的字符串
print(soup.find_all(text=re.compile("^The"))) 
# ["The Dormouse's story", "The Dormouse's story"]
# class选择器包含st的节点
print(soup.find_all(class_=re.compile("st")))

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

soup.find_all(href=re.compile("elsie"), id='link1')
# [<a class="sister" href="http://example.com/elsie" id="link1">three</a>]

class 过滤：（由于class是有特殊含义，需要在后面加下划线）

print(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>
]

'''

通过 find_all() 方法的 attrs 参数定义一个字典参数来搜索包含特殊属性的tag:

data_soup.find_all(attrs={"data-foo": "value"}) # [<div data-foo="value">foo!</div>]
1.3 text 参数
import re

print(soup.find_all(text="Elsie"))  # ['Elsie']

print(soup.find_all(text=["Tillie", "Elsie", "Lacie"])) # ['Elsie', 'Lacie', 'Tillie']
 
# 只要包含Dormouse就可以
print(soup.find_all(text=re.compile("Dormouse")))  # ["The Dormouse's story", "The Dormouse's story"]
1.4 limit 参数

find_all() 方法返回全部的搜索结构,如果文档树很大那么搜索会很慢.如果我们不需要全部结果,可以使用 limit 参数限制返回结果的数量。

print(soup.find_all("a",limit=2))
print(soup.find_all("a")[0: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>]
'''

2、find（）

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

find_all() 方法将返回文档中符合条件的所有tag,但如果只需要找一个内容的时候，可以使用find()

soup.find_all('title', limit=1)  # [<title>The Dormouse's story</title>]
soup.find('title')  # <title>The Dormouse's story</title>

唯一的区别是 find_all() 方法的返回结果是值包含一个元素的列表,而 find() 方法直接返回结果。该函数可以多次调用。

soup.head.title  # <title>The Dormouse's story</title>
soup.find("head").find("title")  # <title>The Dormouse's story</title>

3、find_parents() 和 find_parent()

a_string = soup.find(text="Lacie")
print(a_string)  # Lacie

print(a_string.find_parent())
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
print(a_string.find_parents())
print(a_string.find_parent("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>

'''

四、beautifulsoup-------css选择器

1、通过标签名查找

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

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 #link2"))

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

直接子标签查找

print(soup.select("p > #link2"))
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

查找既有class也有id选择器的标签

a_string = soup.select(".story#test")

查找有多个class选择器的标签

a_string = soup.select(".story.test")

查找有多个class选择器和一个id选择器的标签

a_string = soup.select(".story.test#book")

5、属性查找

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

print(soup.select("a[href='http://example.com/tillie']"))
#[<a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

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

for title in soup.select('a'):
    print (title.get_text())

'''
Elsie
Lacie
Tillie
'''
狐狸v糊涂
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
6. python爬虫——基于bs4数据解析技术爬取文章
STAR GAME
08-27 899
python爬虫——基于bs4数据解析技术爬取文章1.需求2.分析3.代码实现4.实现效果 1.需求 爬取https://www.shicimingju.com/book/sanguoyanyi.html上三国演义的所有内容 2.分析 进入网站后，发现为单页，内容在跳转链接里 使用抓包工具进行查看，发现跳转到详情内容的章节，均存在于< div calss=“book-mulu”>下的a标签中，< a >具有属性href具有对应的详情内容URL和每一章的章节名字。 因为需要获取所有
python爬虫教程（五）：解析库bs4及爬取实例
csdn1561168266的博客
05-04 1万+
大家好，今天分享的是解析库中的bs4，这个库如果是初学者的话肯定听过，本文章的目的是让你知道如何使用bs4。 一、安装及初始印象 1.安装 bs4是一个第三方库，需要安装。如果使用的是默认的IDE，可以在命令行下敲下： pip install bs4 如果是其它的话，建议百度或在论坛上寻找方法。 2.解析器 对于bs4这个库来说，我们主要使用的是BeautifulSoup对象，使用方法如下： # 导包 from bs4 import BeautifulSoup # 创建对象 soup =
Python爬虫编程：数据解析模块之bs4，超详细
lu_jianjun的专栏
09-27 4627
BeautifulSoup，是python中的一个库，是一个可以从HTML或XML文件中提取数据的Python库；它能够通过提供一些简单的函数用来处理导航、搜索、修改分析树等功能。它是一个工具箱，通过解析文档为用户提供需要抓取的数据，因为简单，所以不需要多少代码就可以写出一个完整的应用程序。会帮你节省数小时甚至数天的工作时间。自动将输入文档转换为Unicode编码，输出文档转换为utf-8编码。你不需要考虑编码方式，除非文档没有指定一个编码方式，这时，就不能自动识别编码方式了。
Python爬虫编程4——数据解析模块之bs4
qq_52914337的博客
01-21 2538
目录 一.bs4简介 1.基本概念 2.源码分析 二.bs4的使用 1.快速开始 2.bs4的对象种类 三.遍历文档树 遍历子节点 1.contents children descendants 2.string strings stripped_strings 四.遍历文档树 遍历父节点 1.parent和parents 五.遍历文档树 遍历兄弟节点 六.搜索树 七.find_all() 和 find() 八.select（）方法 九...
python爬虫之bs4模块（超详细）
weixin_54787921的博客
06-09 3万+
python爬虫之bs4模块一、bs4简介二、使用方法三、BeautifulSoup四大对象种类（1）tag（2）NavigableString（3）BeautifulSoup（4）Comment四、CSS选择器 一、bs4简介 即BeautifulSoup，是python种的一个库，最主要的内容就是从网页中抓取数据。 Beautiful Soup提供一些简单的、python式的函数用来处理导航、搜索、修改分析树等功能。它是一个工具箱，通过解析文档为用户提供需要抓取的数据，因为简单，所以不需要多少代码就可以
24期爬虫-04-bs4解析-马浩然.py
11-09
24期爬虫-04-bs4解析-马浩然.py
bs4-reptile 爬虫
08-26
bs4-reptile 是一个基于 Python 的网络爬虫框架，利用了 BeautifulSoup（简称 bs4）库来解析 HTML 和 XML 文档，实现高效的数据提取。爬虫是信息技术领域中用于自动化地从互联网上获取大量数据的一种工具。在大数据...
python爬虫数据可视化-10-where条件语句-模糊查询.ev4.rar
最新发布
05-31
from bs4 import BeautifulSoup import requests url = 'http://example.com' response = requests.get(url) soup = BeautifulSoup(response.text, 'html.parser') # 查找所有标签 headings = soup.find_all('h1')...
Python爬虫 - 使用python爬取微博热搜.zip
02-02
from bs4 import BeautifulSoup soup = BeautifulSoup(response.text, 'html.parser') ``` 接下来，我们需要找到存储热搜关键词的HTML元素，通过CSS选择器或XPath来定位。例如，如果热搜列表是通过`...
python网络爬虫-入门基础学习爬虫原理.zip
05-18
from bs4 import BeautifulSoup url = "http://example.com" response = requests.get(url) soup = BeautifulSoup(response.text, 'html.parser') ``` 接下来，要提取数据，你可以使用BeautifulSoup提供的选择器...
python爬虫-bs4详解--小林月
qq_53953480的博客
04-02 591
bs4进行数据解析。
python爬虫数据解析之bs4
A__superman的博客
07-15 397
步骤： 1、导入bs4库 from bs4 import BeautifulSoup 2、获取soup对象 #html为你获取的网页源代码，将html转化为特定的格式lxml #为后面提取信息做准备 soup=BeautifulSoup(html,'lxml') 3、利用方法选择器解析 find_all()##查询所有符合条件的节点信息，例如soup.find_all(name=“h4”)，查询所有节点名称为h4的节点信息 for ul in soup.find_all(name="ul"):#寻找名为
Python网络爬虫与信息提取（四）bs4的内容遍历方法及注意事项
Abgler的博客
04-30 4440
  HTML文本是一种树形结构，所以bs4的内容遍历方法也是基于树形结构的，它共有下行遍历、上行遍历和平行遍历这三种遍历方法。标签树的下行遍历属性说明.contents子节点的列表，将&lt;tag&gt;所有子节点存入列表.children子节点的迭代类型，与.contents类似，用于循环遍历子节点.descendants子孙节点的迭代类型，包含所有子孙节点，用于循环遍历  我们仍以上一节中的...
python is beautiful_python 模块BeautifulSoup使用
weixin_39821718的博客
11-24 77
转自：http://www.pythonclub.org/modules/beautifulsoup/starthttp://www.crummy.com/software/BeautifulSoup/bs4/doc/一篇文章------------------------------------汤料——Soup中的对象标签（Tag）标签对应于HTML元素，也就是应于一对HTML标签以及括起来的内...
37-python中bs4获取的标签中如何提取子标签
weixin_30721899的博客
11-20 2779
如果只是要提取一个标签 里面的属性值啥的，直接看这篇文章就可以了： 23-python用BeautifulSoup用抓取a标签内所有数据 如果是标签的嵌套，可以参考下面的思路，虽然不是很简洁，但是可以解决你的问题： 可以看到不能直接 findAll 所有的 tr 标签，否则会有许多杂质的， 所以，可以知道 table, 根据id 或者class, 则可以唯一找到； 下面的重点就...
爬虫之bs4解析
A496608119的博客
04-14 357
目录 bs4解析-HTML语法 bs4拿到想要的自己的内容，通过标签名精准拿到数据 bs4解析-HTML语法 bs4解析比较简单，但是呢，首先你需要了解一丢丢的html知识，然后再去适应bs4去提取，逻辑和编写难度就会非常简单和清晰。 HTML（Hyper Text Markup Language）超文本标记语言，是我们编写网页的最基本也是最核心的一种语言，其语法规则就是用不同的标签对网页上的内容进行标记 从而使网页显示除不同的展示效果。 <h1> 我爱你 &lt.
python soup attrs_Python3 BeautifulSoup模块（3）：bs4通过contents[0]获取子节点中不包含span标签，并且a标签本身不包含class属性的a标签...
weixin_35795675的博客
01-28 802
子节点一个Tag可能包含多个字符串或其它的Tag,这些都是这个Tag的子节点.BeautifulSoup提供了许多操作和遍历子节点的属性.注意: BeautifulSoup中字符串节点不支持这些属性,因为字符串没有子节点一、实例代码import urllibfrom urllib import requestfrom bs4 import BeautifulSoupimport re#获取页面ba...
Python 如何解决'NoneType' object has no attribute '...'的问题
热门推荐
莫罗列科夫斯基先生的博客
10-29 17万+
Python 如何解决’NoneType’ object has no attribute '…'的问题 用 Python + selenium 和Beautifulsoup 爬取MOCC中国大学慕课网上某网上课程的课堂评论，在爬取少量数据时不出现标题所示错误，在爬取大量数据（运用到翻页操作）时出现 ‘NoneType’ object has no attribute ‘text’ 的错误。请...
python爬虫-bs4案例
08-15
当然，我可以给你提供一个简单的 Python 爬虫案例，使用 Beautiful Soup 4 (bs4) 库进行网页解析。以下是一个示例，用于爬取一个网页上的文章标题和链接： ```python import requests from bs4 import ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值