BeautifulSoup模块
【一】初识
1)介绍
- Beautiful Soup是python的一个库
- 最主要的功能是从网页抓取数据。
- 官方文档:https://beautifulsoup.readthedocs.io/zh_CN/v4.4.0/
# 安装
pip install BeautifulSoup4
# 导入
from bs4 import BeautifulSoup
2)HTML解析器
解析当前页面生成的dom对象
-
内置解析器:html.parser
# 语法 soup=BeautifulSoup(页面源码,'html.parser')
-
第三方解析器:lxml
# 安装 pip install lxml # 语法 soup=BeautifulSoup(页面源码,'lxml')
-
第三方解析器:html5lib
# 安装 pip install html5lib # 语法 soup=BeautifulSoup(页面源码,'html5lib')
3)三种解析器
解析器 | 使用方法 | 优势 | 劣势 |
---|---|---|---|
Python标准库 | BeautifulSoup(markup, "html.parser") | Python的内置标准库 执行速度适中 文档容错能力强 | Python 2.7.3 or 3.2.2)前 的版本中文档容错能力差 |
lxml HTML 解析器 | BeautifulSoup(markup, "lxml") | 速度快 文档容错能力强 | 需要安装C语言库 |
lxml XML 解析器 | BeautifulSoup(markup, ["lxml", "xml"]) 或BeautifulSoup(markup, "xml") | 速度快 唯一支持XML的解析器 | 需要安装C语言库 |
html5lib | BeautifulSoup(markup, "html5lib") | 最好的容错性 以浏览器的方式解析文档 生成HTML5格式的文档 | 速度慢 不依赖外部扩展 |
4)示例 生成soup对象
from bs4 import BeautifulSoup
#模拟网页获取的源码
with open("./test.html", "r", encoding="utf-8") as f:
data = f.read()
# 生成一个soup解析器对象
soup = soup=BeautifulSoup(data,'lxml')
# 获取所有文本内容
text = soup.get_text()
print(text)
【二】四种对象
1)介绍
- Beautiful Soup将复杂HTML文档转换成一个复杂的树形结构,并将每个节点都表示为Python对象
- 在Beautiful Soup中,有四种主要的对象类型:
- BeautifulSoup
- Tag
- NavigableString
- Comment
2)BeautifulSoup对象
- 代表整个解析后的HTML文档,是最顶层的对象
- 其包含了整个文档的全部内容,并提供了操作HTML文档的方法和属性
soup = BeautifulSoup(页面源码,'html.parser')
3)Tag对象
- 表示HTML中的标签,如
<p>
,<div>
等 - 其包含了标签的名称和对应的属性,并可以通过Tag对象来获取标签内的内容或进行进一步的操作
- 可以通过传递HTML文档给BeautifulSoup类初始的方式创建Tag对象
0.示例文档模型
<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>
</body>
</html>
1.查找tag对象
# 输出head标签,类型
print(soup.head, type(soup.head))
# <head><title>The Dormouse's story</title></head>
# <class 'bs4.element.Tag'>
# 输出title标签及其类型
print(soup.title, type(soup.title))
# <title>The Dormouse's story</title>
# <class 'bs4.element.Tag'>
# 输出第一个a标签及其类型
print(soup.a, type(soup.a))
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>
# <class 'bs4.element.Tag'>
# 输出第一个p标签下的第一个b标签
print(soup.p.b)
# <b>The Dormouse's story</b>
2.查找tag对象的标签、属性
# 输出第一个a标签的name属性值
print(soup.a.name)
# a
# 输出第一个p标签下的第一个b标签的name属性值
print(soup.p.b.name)
# b
# 输出第一个a标签的href属性值
print(soup.a["href"])
# http://example.com/elsie
# 输出第一个a标签的id属性值
print(soup.a.attrs)
# {'href': 'http://example.com/elsie', 'class': ['sister'], 'id': 'link1'}
# 返回当前标签的 class 属性值
print(soup.a["class"])
# ['sister']
3.修改tag的属性
# 修改第一个a标签的class属性值
soup.a["class"] = ["sister c1"]
# ['sister'] ---> ['sister c1']
# 删除第一个a标签的id属性值
del soup.a["id"]
print(soup)
# 第一个a标签的id值被删除
4.获取标签对象的文本内容
# 直接使用标签对象获取中间的文本内容
print(soup.p.get_text())
# The Dormouse's story
# 获取生成器对象,在遍历
print([i for i in soup.p.strings])
# <generator object Tag._all_strings at 0x00000190859A7E40>
# The Dormouse's story
# 获取当前标签的文本
print(soup.p.b.string)
# The Dormouse's story
# 若是多层级,string不生效,返回None
4)NavigableString对象
- 表示标签内的文本内容,即非标签字符串
- 当tag只包含单一的字符串时,可用tag.string、tag.text来获取该字符串
# 获取p标签的文本内容
print(soup.p.string)
# The Dormouse's story
# 获取p标签下所有的文本内容
print(soup.p.strings)
# <generator object Tag._all_strings at 0x102b7b300>
for i in soup.p.strings:
print(i)
# The Dormouse's story
5)Comment对象
- 表示HTML文档的注释内容
- 遇到HTML文档中的注释时,将其注释封装成Comment对象
markup = "<b><!--Hey, buddy. Want to buy a used parser?--></b>"
soup = BeautifulSoup(markup, "html.parser")
# 输出注释内容
comment = soup.b.string
print(comment,type(comment))
# Hey, buddy. Want to buy a used parser?
# <class 'bs4.element.Comment'>
【三】文档树操作
1)概念
- 遍历文档树,也被称为导航文档树,是指在一个文档对象模型(DOM)中按照特定的方法和规则来遍历和浏览其中的节点。
- DOM是一种处理XML或HTML文档的标准编程接口,它将文档解析成由节点和对象组成的树状结构。
- 在遍历文档树的过程中,可以通过访问当前节点及其相关属性、子节点、父节点、兄弟节点等信息,来对文档进行操作和分析
2)常见的文档树遍历算法
- 选择起始节点:
- 首先需要确定遍历的起始节点,可以是整个文档的根节点,也可以是某个指定的节点。
- 访问当前节点:
- 从起始节点开始,首先访问当前节点,可以获取当前节点的标签名、属性、文本内容等信息。
- 处理当前节点:
- 根据需要,对当前节点进行一些处理操作,比如判断节点类型、执行特定的任务等。
- 遍历子节点:
- 如果当前节点有子节点,将从第一个子节点开始递归遍历,重复步骤2和步骤3。
- 遍历兄弟节点:
- 如果当前节点没有子节点或者子节点已经遍历完毕,将继续遍历当前节点的下一个兄弟节点,重复步骤2和步骤3。
- 返回父节点:
- 当遍历到某个节点的兄弟节点都被遍历完毕后,返回到该节点的父节点,并继续遍历父节点的下一个兄弟节点。
- 结束条件:
- 当整个文档树的节点都被遍历完毕,或者满足某个结束条件时,结束遍历过程。
3)语法
from bs4 import BeautifulSoup
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title" name="first_p"><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')
1.获取标签的名称
# 使用`tag.name`属性可以获取当前标签的名称
print(soup.p.name)
# p
2.获取标签的属性
# 使用`tag.attrs`属性可以获取当前标签的属性字典。
print(soup.p.attrs)
# {'class': ['title'], 'name': 'first_p'}
3.获取标签的内容
- tag.string
# 使用`tag.string`属性可以获取当前标签内的文本内容。
# 如果标签内只有一个字符串,可以直接使用该属性获取内容。
print(soup.p.string)
# The Dormouse's story
- tag.strings
# 使用`tag.strings`方法可以获取当前标签内所有子节点的文本内容,返回一个生成器对象。
print(soup.p.strings)
# <generator object Tag._all_strings at 0x120eff370>
print(list(soup.p.strings))
# ["The Dormouse's story"]
- tag.text
# 使用`tag.text`属性可以获取当前标签内所有子节点的文本内容,并将其连接在一起。
print(soup.p.text)
# The Dormouse's story
- tag.stripped_strings
# 使用`tag.stripped_strings`方法可以获取当前标签内所有子节点的文本内容,并去掉多余的空白字符。
for line in soup.stripped_strings:
print(line)
# Once upon a time there were three little sisters; and their names were
# Elsie
# ,
# Lacie
# and
# Tillie
# ;
# and they lived at the bottom of a well.
# ...
4.嵌套选择
print(soup.head.title.text)
# 输出:The Dormouse's story
print(soup.body.a.text)
# 输出:Elsie
5.子节点、子孙节点
# p下所有子节点
print(soup.p.contents)
# [<b>The Dormouse's story</b>]
# 得到一个迭代器,包含p下所有子节点
print(soup.p.children)
# <list_iterator object at 0x123583fa0>
for i, child in enumerate(soup.p.children, 1):
print(i, child)
# 1 <b>The Dormouse's story</b>
# 获取子孙节点,p下所有的标签都会被选择出来
print(soup.p.descendants)
# <generator object Tag.descendants at 0x12327f300>
for i, child in enumerate(soup.p.descendants, 1):
print(i, child)
# 1 <b>The Dormouse's story</b>
# 2 The Dormouse's story
# 针对第二个p标签的子孙节点进行遍历
for i, child in enumerate(soup.find_all("p")[1].descendants, 1):
print(i, child)
# 1 Once upon a time there were three little sisters; and their names were
# 2 <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>
# 3 Elsie
# 4 ,
# 5 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
# 6 Lacie
# 7 and
# 8 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
# 9 Tillie
# 10 ;
# and they lived at the bottom of a well.
6.父节点、祖先节点
# 获取a标签的父节点
print(soup.a.parent)
# 获取a标签的父节点的文本内容
print(soup.a.parent.text)
# 找到a标签所有的祖先节点,父亲的父亲,父亲的父亲的父亲...
print(soup.a.parents)
7.兄弟节点
print(soup.a.next_sibling)
# 输出:<class 'bs4.element.NavigableString'>
print(soup.a.next_sibling.next_sibling)
#下一个兄弟
print(soup.a.previous_sibling.previous_sibling)
#上一个兄弟
print(list(soup.a.next_siblings))
#下面的兄弟们=>生成器对象
print(soup.a.previous_siblings)
# 输出:生成器对象,包含上面的兄弟节点
# 上面的兄弟们=>生成器对象
【四】搜索文档树
1)介绍
- recursive 是否从当前位置递归往下查询,如果不递归,只会查询当前soup文档的子元素
- string 这里是通过tag的内容来搜索,并且返回的是类容,而不是tag类型的元素
- kwargs 自动拆包接受属性值,所以才会有soup.find_all('a',id='title') ,id='title'为kwargs自动拆包掺入
- BeautifulSoup定义了很多搜索方法,这里着重介绍2个:
- find() 和 find_all()
- 其它方法的参数和用法类似
2)语法
from bs4 import BeautifulSoup
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title" name="first_p"><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')
1.查找所有语法
- 根据标签名查找
# 根据标签名查找到所有符合当前标签名的标签
print(soup.find_all("a"))
# 根据标签名和属性名确定唯一的那个标签
print(soup.find_all("a", attrs={"class": "sister"}))
- 根据正则表达式查找
print(soup.find_all(name=re.compile("^b")))
- 可以放列表
print(soup.find_all(name=["a", 'b']))
- 放函数方法
def has_class_but_no_id(tag):
return tag.has_attr('class') and not tag.has_attr('id')
print(soup.find_all(name=has_class_but_no_id))
# 只返回具有 class 属性而没有 id 属性的 标签
- True
- 通过find_all(True)可以匹配所有的tag,不会返回字符串节点。
- 在代码中,会使用循环打印出每个匹配到的tag的名称(tag.name)
# ● 通过find_all(True)可以匹配所有的tag,不会返回字符串节点。
# ● 在代码中,会使用循环打印出每个匹配到的tag的名称(tag.name)。
print(soup.find_all(name=True))
- keyword 参数
- keyword 参数用于按照属性值进行搜索
#指定属性值:
print(soup.find_all(href="http://example.com/elsie"))
# 返回所有 href 属性等于 "http://example.com/tillie" 的标签。
# 正则表达式匹配属性值:
soup.find_all(href=re.compile("^http://"))
# 返回所有 href 属性以 "http://" 开头的标签。
# 多个属性:
soup.find_all(href=re.compile("http://"), id='link1')
# 返回同时满足 href 以 "http://" 开头并且 id 等于 "link1" 的标签。
- text参数
- text 参数用于根据内容搜索标签。可以接受字符串、列表或正则表达式
# 字符串:
soup.find_all(text="Elsie")
#返回所有包含文本 "Elsie" 的标签。
# 列表:
soup.find_all(text=["Tillie", "Elsie", "Lacie"])
# 返回所有包含文本 "Tillie"、"Elsie" 或 "Lacie" 的标签。
# 正则表达式:
soup.find_all(text=re.compile("Dormouse"))
# 返回所有包含文本中包含 "Dormouse" 的标签。
- limit参数
- find_all() 方法返回全部的搜索结构,如果文档树很大那么搜索会很慢.
- 如果我们不需要全部结果,可以使用 limit 参数限制返回结果的数量
- 效果与SQL中的limit关键字类似
- 当搜索到的结果数量达到 limit 的限制时,就停止搜索返回结果.
print(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>]
- recursive 参数
- recursive 参数用于控制是否递归往下查询。
- 默认情况下,Beautiful Soup会检索当前tag的所有子孙节点。
- 如果想要仅搜索tag的直接子节点,可以设置 recursive=False。
print(soup.find_all("p", recursive=False))
2.查找单个find
find( name , attrs , recursive , string , **kwargs )
- name: 指定要查找的tag名称,可以是字符串或正则表达式。
- attrs: 指定tag的属性,可以是字典或字典的列表。
- recursive: 指定是否递归查找子孙tag,默认为True。
- string: 指定查找的文本内容,可以是字符串或正则表达式
3.find_all() 和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() 方法直接返回结果
4.标签名多次调用
soup.head.title
# <title>The Dormouse's story</title>
soup.find("head").find("title")
# <title>The Dormouse's story</title>
5.拓展
-
find_parents() 和 find_parent()
-
- find_parents():
-
-
- 返回所有符合条件的父级tag,结果是一个生成器。
- 可以传入参数来进一步筛选父级tag。
-
-
- find_parent():
-
-
- 返回第一个符合条件的父级tag。
-
-
find_next_siblings() 和 find_next_sibling()
-
- ind_next_siblings():
-
-
- 返回所有符合条件的后续兄弟tag,结果是一个列表。
- 可以传入参数来进一步筛选兄弟tag。
-
-
- find_next_sibling():
-
-
- 返回第一个符合条件的后续兄弟tag。
-
-
find_all_next() 和 find_next()
-
- find_all_next():
-
-
- 返回所有符合条件的后续tag和文本内容,结果是一个生成器。
- 可以传入参数来进一步筛选结果。
-
-
- find_next():
-
-
- 返回第一个符合条件的后续tag或文本内容。
-
【五】CSS选择器
1)官网
2)select
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title">
<b>The Dormouse's story</b>
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>;
<div class='panel-1'>
<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'><h1 class='yyyy'>Foo</h1></li>
<li class='element xxx'>Bar</li>
<li class='element'>Jay</li>
</ul>
</div>
and they lived at the bottom of a well.
</p>
<p class="story">...</p>
"""
from bs4 import BeautifulSoup
soup=BeautifulSoup(html_doc,'lxml')
# 选取title元素
soup.select("title")
'''
[<title>The Dormouse's story</title>]
'''
# 选取第三个p元素(class为story)
soup.select("p:nth-of-type(3)")
'''
[<p class="story">...</p>]
'''
# 选取body下的所有a元素
soup.select("body 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>]
'''
# 选取html head title元素
soup.select("html head title")
'''
[<title>The Dormouse's story</title>]
'''
# 选取head下直接子元素title
soup.select("head > title")
'''
[<title>The Dormouse's story</title>]
'''
# 返回所有<p>标签下的直接子级<a>标签
soup.select("p > 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.select("p > a:nth-of-type(2)")
# 返回所有<p>标签下第二个<a>标签(直接子级)
'''
[<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]
'''
soup.select("p > #link1")
# 返回所有<p>标签下拥有id="link1"的<a>标签(直接子级)
'''
[<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]
'''
# 返回所有<body>标签下的直接子级<a>标签
soup.select("body > a")
# 返回拥有id="link1"的<a>标签之后所有同级的class="sister"的<a>标签
soup.select("#link1 ~ .sister")
'''
[<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
<a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
'''
# 返回拥有id="link1"的<a>标签之后紧邻的下一个同级的class="sister"的<a>标签
soup.select("#link1 + .sister")
'''
[<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]
'''
# 返回所有class="sister"的<a>标签
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>]
'''
# 返回所有class属性中包含“sister”的<a>标签
soup.select("[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>]
'''
# 返回拥有id="link1"的<a>标签
soup.select("#link1")
'''
[<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]
'''
# 返回拥有id="link2"且为<a>标签的元素
soup.select("a#link2")
'''
[<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]
'''
# 返回拥有id="link1"或id="link2"的<a>标签
soup.select("#link1,#link2")
'''
[<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]
'''
# 选取包含 href 属性的所有 <a> 标签
soup.select('a[href]')
'''
[<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>]
'''
# 选取 href 属性等于 "http://example.com/elsie" 的 <a> 标签
soup.select('a[href="http://example.com/elsie"]')
'''
[<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]
'''
# 选取 href 属性以 "http://example.com/" 开头的 <a> 标签
soup.select('a[href^="http://example.com/"]')
'''
[<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>]
'''
# 选取 href 属性以 "tillie" 结尾的 <a> 标签
soup.select('a[href$="tillie"]')
'''
[<a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
'''
# 选取 href 属性中包含 ".com/el" 的 <a> 标签
soup.select('a[href*=".com/el"]')
'''
[<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]
'''
multilingual_markup = """
<p lang="en">Hello</p>
<p lang="en-us">Howdy, y'all</p>
<p lang="en-gb">Pip-pip, old fruit</p>
<p lang="fr">Bonjour mes amis</p>
"""
multilingual_soup = BeautifulSoup(multilingual_markup)
# 选取 lang 属性以 "en" 开头的 <p> 标签
multilingual_soup.select('p[lang|=en]')
'''
[<p lang="en">Hello</p>,
<p lang="en-us">Howdy, y'all</p>,
<p lang="en-gb">Pip-pip, old fruit</p>]
'''
3)select_one
- 返回查找到的元素的第一个
# 获取属性值
print(soup.select('#list-2 h1')[0].attrs)
# 获取内容
print(soup.select('#list-2 h1')[0].get_text())
【六】案例
# 豆掰 Top250
import requests
from fake_useragent import UserAgent
from bs4 import BeautifulSoup
class SpiderTop250(object):
def __init__(self):
# 【1】定义目标网址
# self.target_url = "https://movie.douban.com/top250"
# https://movie.douban.com/top250?start=25&filter=
# https://movie.douban.com/top250?start=50&filter=
# 【2】定义请求头参数
self.headers = {
"User-Agent": UserAgent().random
}
def create_target_url(self):
target_url_list = []
# 循环取到每一页
for i in range(1, 11):
if i == 1:
target_url = "https://movie.douban.com/top250"
target_url_list.append(target_url)
else:
target_url = f"https://movie.douban.com/top250?start={25 * (i - 1)}&filter="
target_url_list.append(target_url)
return target_url_list
# 写入文档
def save(self, page_text):
with open("doubai.html", "w", encoding="utf-8") as fp:
fp.write(page_text)
# 读取文档
def read(self):
with open("doubai.html", "r", encoding="utf-8") as fp:
data = fp.read()
return data
def main(self):
target_url_list = self.create_target_url()
top_data = {}
for target_url in target_url_list:
top_data.update(self.spider_page_text(target_url))
return top_data
def spider_page_text(self, target_url):
# 【3】发起请求获取响应对象
response = requests.get(
url=target_url,
headers=self.headers
)
# 【4】获取到响应源码
page_text = response.text
return self.parse_page(page_text)
def parse_page(self, page_text):
# 【5】生成soup对象
soup = BeautifulSoup(page_text, "lxml")
# 【6】获取到每一个电影信息所在的li标签
li_list = soup.select("#content > div > div.article > ol > li")
# 【7】遍历获取每一个li标签中间的内容
top_data = {}
for li in li_list:
# 获取数据,并美化
info_list = [span.text.strip() for span in li.select("div > div.info > div.hd > a > span")]
movie_title = info_list[0]
movie_director = info_list[1].strip("/").strip()
movie_type = None
if len(info_list) == 3:
movie_type = ", ".join([i.strip() for i in info_list[2].strip("/").strip().split("/")])
movie_actors = [i.strip().replace("\xa0", "") for i in
list(li.select("div > div.info > div.bd > p:nth-child(1)")[0].strings)]
movie_star = li.select("div > div.info > div.bd > div > span.rating_num")[0].text
movie_comment_num = li.select("div > div.info > div.bd > div > span:nth-child(4)")[0].text
# 判断存在
try:
movie_motto = li.select("div > div.info > div.bd > p.quote > span")[0].text
except Exception as e:
movie_motto = ""
top_data[movie_title] = {
"movie_title": movie_title,
"movie_director": movie_director,
"movie_type": movie_type,
"movie_actors": movie_actors,
"movie_star": movie_star,
"movie_comment_num": movie_comment_num,
"movie_motto": movie_motto
}
return top_data
if __name__ == '__main__':
s = SpiderTop250()
top_data = s.main()
print(len(top_data))
标签:soup,标签,BeautifulSoup,find,61,tag,模块,print,节点
From: https://www.cnblogs.com/Mist-/p/18336143