浅析Python爬虫之bs4库

最新推荐文章于 2024-12-21 10:37:44 发布
原创 最新推荐文章于 2024-12-21 10:37:44 发布 · 3.1k 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python

本文深入解析了bs4库的安装与使用方法，包括如何从HTML和XML中提取信息，详细介绍了bs4的各种对象类型及其操作，如Tag、NavigableString、Comment等。同时，文章还讲解了遍历HTML树的多种方式，如下行遍历、上行遍历和平行遍历，以及如何使用字符串过滤器、列表过滤器等进行树的搜索。此外，还涵盖了find_all、find_parent等方法的应用，以及如何修改文档树和删除不需要的内容。

1.bs4库的简介

bs4的概念

  • Beautiful Soup 是一个可以从 html 和 xml 中提取网页信息的库

bs4 的安装

  • pip install lxml
  • pip install bs4
  • 安装 bs4 之前一定要先安装 lxml

2. bs4 的使用

2.1 bs4的快速入手

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

# 一般导入bs4模块的方法
from bs4 import BeautifulSoup
# 获取bs对象
# soup = BeautifulSoup(html_doc)  # GuessedAtParserWarning：so I'm using the best available HTML parser for this system ("lxml")
# bs4将网页字符串生成对象的时候需要用到解析器，就用 lxml 或者官方自带的解析器html.parser
soup = BeautifulSoup(html_doc, 'lxml')

# 美化页面代码
print(soup.prettify())

# 获取标签的内容（soup.标签）
print(soup.p)

# 获取标签的名字（soup.标签.name）
print(soup.p.name)

# 获取标签里面的内容（soup.标签.string）
print(soup.p.string)

2.2 bs4 的对象种类

  • Tag：标签
  • Beautiful Soup ：bs4 对象
  • Navigablestring：可导航字符串
  • comment：注释
title_tag = soup.title  # soup.标签
print(type(title_tag))  # <class 'bs4.element.Tag'>

print(type(soup))  # <class 'bs4.BeautifulSoup'>

title_tag = soup.title.string  # soup.标签.string
print(type(title_tag))  # <class 'bs4.element.NavigableString'>

html = '''
<div><!-- --></div>
'''
bs = BeautifulSoup(html, 'lxml')
# 标签的内容为 html 注释
print(type(bs.div.string))  # <class 'bs4.element.Comment'>

3. 遍历

  • HTML 是个树形结构，<> </> 构成了从属关系。对 HTML 遍历，有上行遍历、下行遍历和平行遍历三种途径和方法

3.1 下行遍历

  • .contents 子节点的列表将该标签的所有儿子节点存入列表
  • .children 子节点的迭代类型，与.content 类似，主要用于循环遍历子节点
  • .descendants 子孙节点的迭代类型，包含所有子孙节点用于遍历
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')
#  .contents  子节点的列表将该标签的所有儿子节点存入列表
r = soup.head.contents  # [<title>The Dormouse's story</title>]
r1 = soup.body.contents
print(r, r1)

# .children 子节点的迭代类型，与.content 类似，主要用于循环遍历子节点
# r_tag = soup.body.children
# print(r_tag)  # <list_iterator object at 0x00000216C0EFE0B8>

r_tags = soup.body.children
for r_tag in r_tags:
    print(r_tag)

# .descendants  子孙节点的迭代类型，包含所有子孙节点用于遍历（犹如洋葱层层蜕皮）
# r_tag = soup.head.descendants
# print(r_tag)  # <generator object descendants at 0x0000025A674A0A40>
r_tags = soup.head.descendants
for r_tag in r_tags:
    print(r_tag)
# <title>The Dormouse's story</title>
# The Dormouse's story

3.2 上行遍历

  • .parent 节点的父节点
  • .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')

# .parent 节点的父节点
r_tag = soup.title.parent  # <head><title>The Dormouse's story</title></head>
print(r_tag)

# .parents 节点的所有父节点
r_tags = soup.title.parents
for r_tag in r_tags:
    print(r_tag)
    print('-----------')

3.3 平行遍历

  • next_sibling 下一个兄弟节点，按照HTML文本顺序返回
  • previous_sibling 上一个兄弟节点，按照HTML文本顺序返回
  • next_siblings 下一个所有兄弟节点，按照HTML文本顺序返回
  • previous_siblings 上一个所有兄弟节点，按照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>
"""
#  next_sibling  下一个兄弟节点，按照HTML文本顺序返回
html = '<a><b>afaef</b><c>faefaef</c></a>'
bs = BeautifulSoup(html, 'lxml')
# print(bs.prettify())
print(bs.b)
print(bs.b.next_sibling)


soup = BeautifulSoup(html_doc, 'lxml')
# 下一个所有兄弟节点，按照HTML文本顺序返回
# r_tag = soup.a
# print(r_tag)
# print(r_tag.next_siblings)  # <generator object next_siblings at 0x000001C73A119BA0>

r_tags = soup.a.next_siblings
for r_tag in r_tags:
    print(r_tag)

3.4 .string .strings .stripped strings

  • string 获取标签里面的内容
  • strings 返回一个生成器对象用来获取多个标签的内容
  • stripped_strings 和 strings 基本一致，但是它可以去掉多余的空格
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>
"""
# string   获取标签里面的内容
r_tag = soup.title.string
print(r_tag) 

# strings 返回一个生成器对象用来获取多个标签的内容
r_tags = soup.strings
for r_tag in r_tags:
    print(r_tag)
    
# stripped_strings  和 strings 基本一致，但是它可以去掉多余的空格
r_tags = soup.stripped_strings
for r_tag in r_tags:
    print(r_tag)

4. 搜索树

  • 字符串过滤器
  • 列表过滤器
  • 正则表达式过滤器
  • True 过滤器
  • 方法过滤器
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')

# 字符串过滤器
t_tag1 = soup.a  # 这里的 a 是一个Tag标签

t_tag = soup.find('a')  # 'a'为字符串过滤器
t_Tag = soup.find_all('a')  # 获取所有的 a
print(t_Tag)

# 列表过滤器
t_tag = soup.find_all(['a', 'head'])
print(t_tag)


# 自定义方法过滤器

def demo(tag):
    return tag.has_attr('id')

print(soup.find_all(demo))

7 find（） 和 find_all（）

7.1 find_all（）

  • find_all（）方法将以列表形式将搜索的标签数据返回
  • find（）方法将搜索到的第一条数据返回
  • find_all（）方法的参数
def find_all(self, name=None, attrs={}, recursive=True, text=None,
                 limit=None, **kwargs)
  • name：标签的名称
  • attrs ：标签的属性
  • recursive：是否递归，默认为True
  • text：文本内容
  • limit：限制搜索的条数
  • **kwargs：不定长参数，以关键字传参
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>
"""

7.2 find_parent（）、find_parents()、find_next_sibling()和find_next_siblings()

  • find_parent()：搜索个别父标签
  • find_parents()：搜索所有父标签
  • find_next_sibling()：搜索兄弟标签
  • find_next_siblings()：搜索所有兄弟标签
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_tag = soup.find('title')
print(a_tag.find_parent('head'))  # <head><title>The Dormouse's story</title></head>

# find_parents返回一个列表
a_Tag = soup.find(text='Elsie')
print(a_Tag.find_parents('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>]


a_tag = soup.find('a')
print(a_tag.find_next_sibling())  # <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>

a_tag = soup.find('a')
print(a_tag.find_next_siblings())  # 返回一个列表
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

7.3 find_previous_siblings()、find_previous_sibling()、find_all_next()和find_next()

  • find_previous_siblings()：往上搜索所有兄弟标签
  • find_previous_sibling（）：往上搜索兄弟标签
  • find_all_next()：往下搜索所有元素
  • find_next()：往下查找单个元素
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_tag = soup.find(id='link3')  # <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
print(a_tag.find_previous_sibling())

# 查找往上所有兄弟标签
a_Tag = soup.find(id='link3')
print(a_Tag.find_previous_siblings())
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]

# 查找以下所有元素
a_Tag = soup.find(id='link3')
print(a_Tag.find_all_next())
# [<p class="story">...</p>]

# 往下查找单个元素
a_tag = soup.p
print(a_tag.find_next('a'))
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>

8. 修改文档树

  • 修改标签的名称和属性
  • 修改字符串 属性赋值，就相当于Python列表的append（）方法
  • decompose（）修改删除起点，对于一些没有必要的或者重复的文章可以直接删除
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>
"""
#     def find_all(self, name=None, attrs={}, recursive=True, text=None,
#                  limit=None, **kwargs):

soup = BeautifulSoup(html_doc, 'lxml')

# 1.修改tag的名称和属性

a_tag = soup.find('a')
print(a_tag)

a_tag.name = 'w'
a_tag['id'] = '123'
a_tag['class'] = 'content'
print(a_tag)

# 2. 修改string
a_tag = soup.a
print(a_tag.string)
# Elsie
a_tag.string = 'hello'
print(a_tag.string)
# hello

# append()方法 向tag中添加内容与列表相似

a_tag = soup.a
print(a_tag)
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>
a_tag.append(' hello world')
print(a_tag)
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie hello world</a>

# 3.decompose()删除多余的内容
a_Tag = soup.find(class_='title')
# print(a_Tag)
a_Tag.decompose()
print(soup)
# <html><head><title>The Dormouse's story</title></head>
# <body>
# 
# <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>
superliminal
关注
python--爬虫（2）bs4模块
m0_37206112的博客
02-20 5435
1. BS4简介 Beautiful Soup提供一些简单的、python式的函数用来处理导航、搜索、修改分析树等功能。它是一个 工具箱，通过解析文档为tiful Soup自动将输入文档转换为Unicode编码，输出文档转换为utf-8编码。 你不需要考虑编码方式，除非文档没有指定一个编一下原始编码方式就可以了。 2. BS4的4种对象 2-1. BeautifulSoup对象 2-2. Tag对...
Python BS4解析库用法详解
weixin_68789096的博客
02-29 2059
Beautiful Soup 简称 BS4（其中 4 表示版本号）是一个 Python 第三方库，它可以从 HTML 或 XML 文档中快速地提取指定的数据。Beautiful Soup 语法简单，使用方便，并且容易理解.图1：BS4官网LOGO图。
python 常用库 bs4 htmllib pandas request
07-03
python3 bs4 htmllib pandas request
python中bs4_python bs4库
weixin_39603505的博客
12-03 209
Beautiful Soup parses anything you give it, and does the tree traversal stuff for you.BeautifulSoup库是解析、遍历、维护 “标签树” 的功能库(遍历，是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问)。https://www.crummy.com/software/BeautifulSo...
python bs4库_python bs4库
weixin_30548481的博客
03-01 293
Beautiful Soup parses anything you give it, and does the tree traversal stuff for you.BeautifulSoup库是解析、遍历、维护 “标签树” 的功能库(遍历，是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问)。https://www.crummy.com/software/BeautifulSo...
浅析Python爬虫获取数据实现调查研究的应用.zip
10-16
其中，BeautifulSoup、Scrapy、Requests和Selenium等库是Python爬虫开发中常用的工具。 BeautifulSoup库是用于解析HTML和XML文档的工具，它可以帮助我们方便地提取和导航网页元素。而Scrapy是一个完整的框架，用于...
浅析python实现scrapy定时执行爬虫
09-20
首先，最简单的方法之一是使用Python内置的time模块中的sleep函数来暂停程序的执行。这可以通过无限循环实现，循环中包含爬虫的执行命令和一定时间的暂停。例如，如果想让爬虫每隔一天执行一次，可以设置暂停时间为...
精选资源
浅析Python爬虫获取数据实现调查研究的应用.pdf
06-28
第一阶段是利用Python编写的爬虫程序，从2012年4月至2016年10月间在***网站的Caregiver论坛中，爬取公开的2500个帖子及其解决方案。第二阶段则涉及对这2500个帖子及其4219份回复进行深入分析。第三阶段是对分析结果...
浅析Python3爬虫登录模拟
12-23
在Python3爬虫领域，模拟登录是一项非常关键的技术，它使得爬虫程序能够访问需要登录后才能看到的网页内容。本文将深入浅出地探讨如何使用Python3进行爬虫登录模拟，涉及的主要知识点包括前端加密处理、JavaScript...
python爬虫8：bs4库
weixin_46676835的博客
08-19 2465
python爬虫8：bs4库
【Python】【进阶篇】二十二、Python爬虫的BS4解析库
deepboat的博客
04-18 1455
【Python】【进阶篇】二十二、Python爬虫的BS4解析库
Python爬虫之bs4库
qq_33995765的博客
03-22 1万+
python爬虫常用库之bs4 bs4全名BeautifulSoup，是编写python爬虫常用库之一，主要用来解析html标签。 1.安装 pip install beautifulsoup4 或 python -m pip install beautifulsoup4 2.基本使用方法 bs4中最基础的使用是BeautifulSoup类的使用，注意大小写哦
python bs4库_Python爬虫之bs4库-Go语言中文社区
weixin_30017913的博客
03-01 359
python爬虫常用库之bs4bs4全名BeautifulSoup，是编写python爬虫常用库之一，主要用来解析html标签。1.安装pip install beautifulsoup4或python -m pip install beautifulsoup42.基本使用方法bs4中最基础的使用是BeautifulSoup类的使用，注意大小写哦。用BeautifulSoup来解析html:fro...
Python爬虫编程：数据解析模块之bs4，超详细
热门推荐
lu_jianjun的专栏
09-27 1万+
BeautifulSoup，是python中的一个库，是一个可以从HTML或XML文件中提取数据的Python库；它能够通过提供一些简单的函数用来处理导航、搜索、修改分析树等功能。它是一个工具箱，通过解析文档为用户提供需要抓取的数据，因为简单，所以不需要多少代码就可以写出一个完整的应用程序。会帮你节省数小时甚至数天的工作时间。自动将输入文档转换为Unicode编码，输出文档转换为utf-8编码。你不需要考虑编码方式，除非文档没有指定一个编码方式，这时，就不能自动识别编码方式了。
Python中bs4库的详细介绍
最新发布
wanganqiqi的博客
12-21 1198
Python中bs4库的详细介绍
从零开始写Python爬虫 --- 1.2 BS4库的安装与使用
技术、思维
10-02 2172
从零开始写Python爬虫 --- 1.2 BS4库的安装与使用 Ehco 5 个月前 Beautiful Soup 库一般被称为bs4库，支持Python3，是我们写爬虫非常好的第三方库。因用起来十分的简便流畅。所以也被人叫做“美味汤”。目前bs4库的最新版本是4.40。下文会介绍该库的最基本的使用，具体详细的细节还是要看：[官方文档](Beautiful Soup D
python bs4库_python库：bs4，BeautifulSoup库、Requests库
weixin_39995943的博客
12-21 607
Beautiful Souphttp://www.imooc.com/learn/712　　视频课程：python遇见数据采集https://segmentfault.com/a/1190000005182997　　PyQuery的使用方法importbs4print(bs4.__version__) #当前版本是4.5.3　　2017-4-6安装第三方库C:\Python3\scripts...
python3 bs4库
weixin_30823001的博客
04-08 478
#BeautifulSoup #python 标准库 BeautifulSoup (markup,"html.parser") #lxml HTML 解析器 BeautifulSoup (markup,"lxml") #lxml XML 解析器 BeautifulSoup (markup,"xml") #html5lib BeautifulSoup (markup,"html5...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值