Python爬虫 解析库的使用

最新推荐文章于 2024-05-01 21:51:35 发布
最新推荐文章于 2024-05-01 21:51:35 发布
阅读量1.5k 收藏 38
点赞数 11
分类专栏： Python爬虫 文章标签： Python网络爬虫 Python爬虫解析库的使用 BeautifulSoup Xpath jQuery
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46028493/article/details/117002800
版权

已写章节

第一章 网络爬虫入门
第二章 基本库的使用
第三章 解析库的使用
第四章 数据存储
第五章 动态网页的抓取

文章目录

第三章 解析库的使用



3.1BeautifulSoup



BeautifulSoup也被称作为”美味汤“，BeautifulSoup提供了一些简单的、Python式的函数来处理导航、搜索、修改和分析树等功能。它是一个工具箱，通过解析文档为用户提供需要抓取的数据。BeautifulSoup已成为和lxml、html6lib一样出色的Python解释器，为用户灵活的提供不同的解析策略或强劲的速度。

作者提示：当你学习了Xpath后，你会发现BeautifulSoup是非常不好用的，并且学了Xpath之后，基本不用BeautifulSoup了。但是，我想说的是，学习BeautifulSoup会加强你对标签树、子标签、父标签、后代标签以及标签的结构的理解，而这些都是学习Xpath的基础，这也是为什么很多人将BeautifulSoup作为自己学习Python网络爬虫的第一个解析库。

Beautiful Soup库是解析、遍历、维护“标签树"的功能库。

BeautifulSoup文档



3.1.1 BeautifulSoup的安装


在cmd命令行中输入以下命令来使用pip安装BeautifulSoup库：

pip install beautifulsoup4


Beautiful Soup库，也叫beautifulsoup4或bs4，约定导入方式如下：

from bs4 import BeautifulSoup   # 或： import bs4

在Python文件中使用上面的代码导入BeautifulSoup库，如果没有报错，说明你已经成功安装了BeautifulSoup。


3.1.2 BeautifulSoup库的理解


BeautifulSoup是将HTML代码当做一个便签树来处理，BeautifulSoup对应一个HTML/XML文档的全部内容 。其中的每一个标签的结构如下：

在这里插入图片描述

基本元素说明
Tag标签，最基本的信息组织单元，分别用<>和</>标明开头和结尾
Name标签名，<p>...</p>的名字是’p’，格式：<tag>.name
Attributes标签属性，字典形式组织，格式：<tag>.attrs
NavigableString标签内的非属性字符串，<>...</>中的字符串，格式：<tag>.string
Comment标签内字符串的注释部分，一种特殊的comment类型

3.1.3 解析器


Beautiful Soup在解析时需要依赖解析器：

soup = BeautifuSoup('<html>data</html>','html.parser')
解析器使用方法条件
bs4的HTML解析器BeautifulSoup(mk,‘html.parser’)安装bs4库
lxml的解析器BeautifulSoup(mk,‘lxml’)pip install lxml
lxml的XML解析器BeautifulSoup(mk,‘xml’)pip install lxml
html5lib的解析器BeautifulSoup(mk,'html5lib‘)pip install html5lib

3.1.4 BeautifulSoup的基本使用


在上面介绍了Tag（标签），它是最基本的信息组织单元，分别用<>和</>标明开头和结尾，下面介绍BeautifulSoup的基本使用。


3.1.4.1 使用soup.<tag>来获取指定的标签
from bs4 import BeautifulSoup

# 使用soup.<tagname>来获取指定的标签
text = '''
<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>
  <f>
   <!--This is a comment-->
  </f>
  <c>
   This is not a comment
  </c>
 </body>
</html>
'''

soup = BeautifulSoup(text, "html.parser")
print(soup.a)

通过soup.a来获取HTML中的a标签，如果结果有多个，取第一个。下面是运行结果：

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

注意：任何存在于HTML语法中的标签都可以使用soup.<tag>访问获得，当HTML中存在多个相同<tag>标签时，soup.<tag>返回第一个。


3.1.4.2 获取标签的属性
from bs4 import BeautifulSoup

# BeautifulSoup中获取标签的属性
text = '''
<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>
  <f>
   <!--This is a comment-->
  </f>
  <c>
   This is not a comment
  </c>
 </body>
</html>
'''

soup = BeautifulSoup(text, "html.parser")

print("a标签的名字是：", soup.a.name)

print(type(soup.a.attrs))
print("a标签的属性为：", soup.a.attrs)

print("a标签的class属性是", soup.a.attrs['class'])

print(type(soup.a.string))
print("a标签中的非属性字符串为：", soup.a.string)

print(type(soup.f.string))
print("f标签中的注释为：", soup.f.string)

运行结果：

a标签的名字是： a
<class 'dict'>
a标签的属性为： {'href': 'http://example.com/elsie', 'class': ['sister'], 'id': 'link1'}
a标签的class属性是 ['sister']
<class 'bs4.element.NavigableString'>
a标签中的非属性字符串为： Elsie
<class 'bs4.element.Comment'>
f标签中的注释为： This is a comment


3.1.4.3 标签树的遍历

标签树的下行遍历

属性说明
.contents子节点的列表，将<tag>的所有儿子节点存入列表
.children子节点的迭代类型，与.contents类似，用于循环遍历儿子节点
.descendants子孙节点的迭代类型，包含所有子孙节点，用于循环遍历
from bs4 import BeautifulSoup

# 标签树的下行遍历
text = '''
<html><head><title>The Dormouse's story</title></head> 
<body>
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a>
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>
<a><p class="story">...</p>aaa</a>
</body>
</html>
'''

soup = BeautifulSoup(text, 'html.parser')

print(len(soup.body.contents))
print(soup.body.contents)

print("-"*50)
for i, child in enumerate(soup.body.children):
    print(i, child)

print("-"*50)
for i, descendant in enumerate(soup.body.descendants):
    print(i, descendant)

运行结果：

9
['\n', <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>, '\n', <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, '\n', <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>, '\n', <a><p class="story">...</p>aaa</a>, '\n']
--------------------------------------------------
0 

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

3 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
4 

5 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
6 

7 <a><p class="story">...</p>aaa</a>
8 

--------------------------------------------------
0 

1 <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>
2 Elsie
3 

4 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
5 Lacie
6 

7 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
8 Tillie
9 

10 <a><p class="story">...</p>aaa</a>
11 <p class="story">...</p>
12 ...
13 aaa
14

注意：descendants会递归查询所有子节点，得到所有的子孙节点


标签的上行遍历

属性说明
.parent节点的父亲标签
.parents节点的先辈标签的迭代类型，用于循环遍历先辈节点
from bs4 import BeautifulSoup

# 标签树的上行遍历
text = '''
<html><head><title>The Dormouse's story</title></head> 
<body>
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a>
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>
<a><p class="story">...</p>aaa</a>
</body>
</html>
'''

soup = BeautifulSoup(text, 'html.parser')

print(soup.p.parent)

print("-"*50)
for i, parent in enumerate(soup.p.parents):
    print(i, parent)

运行结果：

<a><p class="story">...</p>aaa</a>
--------------------------------------------------
0 <a><p class="story">...</p>aaa</a>
1 <body>
<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>
<a><p class="story">...</p>aaa</a>
</body>
2 <html><head><title>The Dormouse's story</title></head>
<body>
<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>
<a><p class="story">...</p>aaa</a>
</body>
</html>
3 
<html><head><title>The Dormouse's story</title></head>
<body>
<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>
<a><p class="story">...</p>aaa</a>
</body>
</html>

标签的平行遍历

属性说明
.next_sibling返回按照HTML文本顺序的下一个平行节点标签
.previous_sibling返回按照HTML文本顺序的上一个平行节点标签
.next_siblings迭代类型，返回按照HTML文本顺序的后续所有平行节点标签
.privious_siblings迭代类型，返回按照HTML文本顺序的前续所有平行节点标签
from bs4 import BeautifulSoup

# 标签树的平行遍历
text = '''
<html><head><title>The Dormouse's story</title></head> 
<body>
<a></a>
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>
<p>pp</p>
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a>
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>
<a><p class="story">...</p>aaa</a>
</body>
</html>
'''

text = text.replace('\n', '')  # 去除换行符的干扰
soup = BeautifulSoup(text, 'html.parser')

print(soup.p.next_sibling)
print("-"*50)

print(soup.p.previous_sibling)
print("-"*50)

for i, previous_sibling in enumerate(soup.p.previous_siblings):
    print(i, previous_sibling)
print("-"*50)

for i, next_sibling in enumerate(soup.p.next_siblings):
    print(i, next_sibling)

运行结果如下：

<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
--------------------------------------------------
<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>
--------------------------------------------------
0 <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>
1 <a></a>
--------------------------------------------------
0 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
1 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
2 <a><p class="story">...</p>aaa</a>


3.1.4.4 使用BeautifulSoup提供的方法来选择标签

find_all()方法

查询所有符合条件的元素，给它传入一些属性或文本，就可以得到符合条件的元素。

**find_all(name, attrs, recursive, text, limit, **kwargs)


  • name参数：筛选出所有符合标签名条件的标签，可以是一个标签名，也可以是一个Python字典或列表封装的若干个标签名
from bs4 import BeautifulSoup

# soup.find_all()方法中筛选指定标签名的标签
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<p class="title"></p>
<a href="http://example.com" class="sister">Elsie</a>
<a href="http://example.com" class="sister">Tillie</a>
<p class="story">...</p>
</body>
</html>
'''

text = text.replace('\n', '')
soup = BeautifulSoup(text, 'html.parser')

print(soup.find_all('a'))  # 找出所有的a标签

print(soup.find_all('p'))  # 找出所有的p标签

print(soup.find_all(['p', 'title']))  # 找出所有的a标签和title标签

运行结果：

[<a class="sister" href="http://example.com">Elsie</a>, <a class="sister" href="http://example.com">Tillie</a>]
[<p class="title"></p>, <p class="story">...</p>]
[<title>The Dormouse's story</title>, <p class="title"></p>, <p class="story">...</p>]

  • attrs参数：根据标签的属性来筛选满足条件的标签，用字典封装一个标签的若干个属性和对应的属性值
from bs4 import BeautifulSoup

# soup.find_all()中根据标签属性来筛选标签
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<p class="title"></p>
<a href="link1" class="b">Elsie</a>
<a href="link1" class="a">Tillie</a>
<a href="link1" class="c">df</a>
<p class="story">...</p>
</body>
</html>
'''

text = text.replace('\n', '')
soup = BeautifulSoup(text, 'html.parser')

print(soup.find_all('a', {'href': 'link1'}))  # 找出所有的href属性为link1的a标签
print('-'*50)

print(soup.find_all('a', {'href': 'link1', 'class': 'a'}))  # 找出所有的href属性为link1且class属性为a的p标签
print('-'*50)

print(soup.find_all('a', {'class': ['a', 'b']})) # 找出说有的class属性为a或b的a标签
print('-'*50)

print(soup.find_all(['p', 'title']))  # 找出所有的p标签和title标签

运行结果：

[<a class="b" href="link1">Elsie</a>, <a class="a" href="link1">Tillie</a>, <a class="c" href="link1">df</a>]
--------------------------------------------------
[<a class="a" href="link1">Tillie</a>]
--------------------------------------------------
[<a class="b" href="link1">Elsie</a>, <a class="a" href="link1">Tillie</a>]
--------------------------------------------------
[<title>The Dormouse's story</title>, <p class="title"></p>, <p class="story">...</p>]

  • recursive参数：布尔变量，默认为True。它决定了要抓取HTML文档标签结构里的多少层信息。如果设置为True，find_all()方法就会根据你的要求去查找标签参数的所有子标签，以及子标签的子标签。如果设置为False，find_all()方法就只查找文档的一级标签。recursive一般不需要设置，除非你真正了解自己需要哪些信息，而且抓取的速度非常重要，那时你就可以设置递归参数。

  • text参数：用标签的文本内容去匹配
from bs4 import BeautifulSoup
import re

# soup.find_all()中使用文本来筛选标签
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<p class="title"></p>
<a href="link1" class="b">Elsie</a>
<a href="link1" class="a">Tillie</a>
<a href="link1" class="c">df</a>
<p class="story">...</p>
<b>dfd</b>
</body>
</html>
'''

text = text.replace('\n', '')
soup = BeautifulSoup(text, 'html.parser')

print(soup.find_all(text=re.compile('.*df.*')))  # 找出所有标签文本中包含df的文本，返回结果为字符串列表

运行结果：

['df', 'dfd']

  • limit参数：结果数目限制参数，它限制了查找结果标签的数目，它只适用于find_all()方法，find()方法其实等价于find_all()方法的limit为1的时候。
from bs4 import BeautifulSoup

# soup.find_all()中限制结果的个数
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<a href="link1" class="b">Elsie</a>
<a href="link1" class="a">Tillie</a>
<a href="link1" class="c">df</a>
</body>
</html>
'''

soup = BeautifulSoup(text, 'html.parser')
print(soup.find_all('a', limit=2))

运行结果如下：

[<a class="b" href="link1">Elsie</a>, <a class="a" href="link1">Tillie</a>]

  • keyword参数：关键词参数keyword可以让你选择那些具有指定属性的标签，例如：
from bs4 import BeautifulSoup

text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<a href="link1" class="b" id='id1'>Elsie</a>
<a href="link1" class="a" id='id1'>Tillie</a>
<a href="link1" class="c" id='id2'>df</a>
</body>
</html>
'''

soup = BeautifulSoup(text, 'html.parser')
all_label = soup.find_all(id="id1")
print(all_label[0].get_text())

运行结果：

Elsie

使用keyword参数的注意事项：

  • 关键词参数可以使用其他方法替代，例如下面的两行代码功能是一样的：

    bsobj.find_all(id="text")
bsobj.find_all("", {"id": "text"})

  • 在使用keyword偶尔也会出现问题，尤其在用class属性查找标签时，因为class是Python中受保护的关键字，而Python中不能拿关键字作为参数名。不过，BeautifulSoup提供了有点儿臃肿的方案，在class下面添加一个下划线：

    bsobj.find_all(class_="green")

    当然，你也可以这样写：

    bsobj.find_all("", {"class"="green"})

find()方法

除了find_all()方法，还有find()方法，只不过find()方法返回的是单个的标签，也就是第一个匹配的标签，而find_all()方法返回的是所有匹配的标签组成的列表。

from bs4 import BeautifulSoup

# bs_object.find()方法的使用
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<a href="link1" class="b" id='id1'>Elsie</a>
<a href="link1" class="a" id='id1'>Tillie</a>
<a href="link1" class="c" id='id2'>df</a>
</body>
</html>
'''

soup = BeautifulSoup(text, 'html.parser')
print(soup.find(id="id1"))  # 这里如果使用的是find_all方法，返回的将是一个包含两个标签的列表

运行结果：

<a class="b" href="link1" id="id1">Elsie</a>

可以看到，符合id=id1的标签有两个，但是find()方法只会返回第一个符合条件的标签。


prettify()方法

这个方法可以将html文本补齐并且将其美化：

from bs4 import BeautifulSoup

# bs_object.prettify()方法的使用
text = '''
<html><head>
<title>The Dormouse's
 story</title></head> <body> 
<a href="link1" 
class="b" id='id1'>Elsie</a>
<a href="link1" class="a" id='id1'>
Tillie</a>
<a href=
"link1" class="c" id='id2'>df</a>
</body>

'''

soup = BeautifulSoup(text, 'html.parser')
print(soup.prettify())

运行结果：

<html>
 <head>
  <title>
   The Dormouse's
 story
  </title>
 </head>
 <body>
  <a class="b" href="link1" id="id1">
   Elsie
  </a>
  <a class="a" href="link1" id="id1">
   Tillie
  </a>
  <a class="c" href="link1" id="id2">
   df
  </a>
 </body>
</html>

使用prettify()方法之前的HTML文本有一些标签是缺少结束标签的，而且格式是乱的，从执行的结果来看，prettify()方法将结束标签补齐了，也对HTML文本进行了格式化。


其他查询方法:

  • find_parents()和find_parent()：前者返回所有祖先节点，后者返回直接父节点

  • find_next_siblings()和find_next_sibling()：前者返回后面的所有的兄弟节点，后者返回后面的第一个节点

  • find_previous_siblings()和find_previous_sibling()：前者返回前面所有的兄弟节点，后者返回前面的第一个兄弟节点

  • find_all_next()和find_next()：前者返回节点后所有符合条件的节点，后者返回第一个符合添加的节点

  • find_all_previous()和find_previous()：前者返回节点前的所有符合条件的节点，后者返回节点前的第一个符合条件的节点



3.1.4.6 使用Lambda表达式

BeautifulSoup允许我们将特定的函数当做find_all()方法的参数。唯一的限制条件是这些函数必须把一个标签当做参数且返回结果是布尔类型。BeautifulSoup用这个函数来筛选它遇到的每一个标签，将符合Lambda中的删选条件的标签保留下来。

下面的例子就使用Lamabd表达式来筛选出所有有两个属性的标签：

from bs4 import BeautifulSoup

# BeautifulSoup中Lambda表达式的使用
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<a href="link1" class="b" id='id1'>Elsie</a>
<a href="link2" class="a" id='id1'>Tillie</a>
<a href="link3" class="c" >df</a>
<a link="https"></a>
</body>
</html>
'''

soup = BeautifulSoup(text, 'html.parser')
# 使用lambda表达式将标签属性为2的标签筛选出来
print(soup.find_all(lambda tag: len(tag.attrs) == 2))

运行结果：

[<a class="c" href="link3">df</a>]


3.1.4.5 css选择器

BeautifulSoup还提供了另外一种选择器，那就是css选择器。要使用css选择器，只需要调用select()方法，传入相应的css选择器即可。

选择器示例示例说明
elementp选择所有的<p>元素
element,elementdiv,p选择所有<div>元素和<p>元素
element elementdiv p选择<div>元素内的所有<p>元素
.class.intro选择所有class="intro"的元素
#id#firstname选择所有id="firstname"的元素
\*\*选择所有元素
[attribute][target]选择所有带有target属性元素
[attribute=value][target=blank]选择所有target="blank"的元素
[attribute*=value][title*=f]选择所有title属性中包含f单词的元素
[attribute^=value][lang^=en]选择lang属性以en开头的所有元素
[attribute$=value][href$=.jpg]选择所有href属性以.jpg结尾的元素
tag.get_texta.get_text获取a标签中的文本内容
from bs4 import BeautifulSoup

# bs_object.select()方法中使用css选择器
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<a href="link1" class="b" id='id1'>Elsie</a>
<a href="link2" class="a" id='id1'>Tillie</a>
<a href="link3" class="c" id='id2'>df</a>
<a link="https"></a>
<b link="af"></b>
<b link="bba"></b>
</body>
</html>
'''

soup = BeautifulSoup(text, 'html.parser')

print("选取所有的a标签：", soup.select('b'))

print("选取所有class属性为a的a标签", soup.select('a .a'))

print("选取所有class属性为a且id属性为id1的a标签", soup.select('a .a #id1'))

print("选取所有link属性为https的a节点：", soup.select('a[link="https"]'))

print("选取所有link属性中包含f的b节点", soup.select('b[link*="f"]'))

print("选取所有link属性以b开头的b标签", soup.select('b[link^="b"]'))

运行结果：

选取所有的a标签： [<b link="af"></b>, <b link="bba"></b>]
选取所有class属性为a的a标签 []
选取所有class属性为a且id属性为id1的a标签 []
选取所有link属性为https的a节点： [<a link="https"></a>]
选取所有link属性中包含f的b节点 [<b link="af"></b>]
选取所有link属性以b开头的b标签 [<b link="bba"></b>]


嵌套选择
from bs4 import BeautifulSoup

# BeautifulSoup中使用嵌套选择
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<a href="link1" class="b" id='id1'>Elsie</a>
<a href="link2" class="a" id='id1'>Tillie</a>
<a href="link3" class="c" id='id2'>df</a>
<a link="https"></a>
<b link="af"></b>
<b link="bba"></b>
</body>
</html>
'''

soup = BeautifulSoup(text, 'html.parser')
for i in soup.select('html'):
    print(i.select('head'))
    print(i.select('title'))

运行结果：

[<head><title>The Dormouse's story</title></head>]
[<title>The Dormouse's story</title>]


获取属性
from bs4 import BeautifulSoup

#BeautifulSoup支持使用css选择器获取标签
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<b link="af"></b>
<b link="bba"></b>
</body>
</html>
'''

soup = BeautifulSoup(text, 'html.parser')
for i in soup.select('b'):
   print(i['link'])
   print(i.attrs['link'])

af
af
bba
bba


获取文本
from bs4 import BeautifulSoup

#获取标签的文本内容
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<b link="af">def</b>
<b link="bba">oo</b>
</body>
</html>
'''

soup = BeautifulSoup(text, 'html.parser')
for i in soup.select('b'):
   print(i.string)
   print(i.get_text())

运行结果：

def
def
oo
oo


3.1.5 使用BeautifulSoup爬取qq音乐的首发音乐

from bs4 import BeautifulSoup
import requests
from fake_useragent import UserAgent

# 使用BeautifulSoup爬取qq音乐的首发音乐
url = 'https://y.qq.com/'
response = requests.get(url=url, headers={'user-Agent': UserAgent().chrome})
soup = BeautifulSoup(response.text, 'html.parser')

divs_1 = soup.find('div', {'id': 'new_album_box'})
names = divs_1.select('span.playlist__title_txt > a')
authors = divs_1.select('div.playlist__author > a')
for name, author in zip(names, authors):
    print(name.text, author.text, sep="  ")

运行结果：

倒带  刘珂
不再年少  大志
英雄如你  洛天依
愿你可以  王琪玮
爱我的时候  单依纯
鹞  周兴哲
红火中国年  小5
除夕  郭秀枫
一起过年  唐诗
蒙着眼睛走  大志


3.2 Xpath(重点)


3.2.1 Xpath介绍


Xpath，全称是XML Path Language，即XML路径语言，它是一门在XML文档中查找信息的语言。它最初是用来搜索XML文档的，但是同样适用于HTML文档的搜索。

W3C的Xpath教程

菜鸟教程的Xpath教程

Xpath helper插件

Xpath官方文档



3.2.2 Xpath的常用规则


选取节点

Xpath使用路径表达式在XML文档中选取节点

表达式描述实例实例含义
nodename选取此节点的所有子节点a选取a节点的所有子节点
/从根节点开始选取/a选取根节点a
//从任意节点开始选取//a选取所有的a节点，不管它在文档中的位置
.选取当前节点//a[@class="class1" and id="id1"]选取所有的class属性为class1且id属性为id1的节点
..选取当前节点的父节点//a[@class="class1"]//..选取所有class属性为class1的a节点的父节点
@选取属性//a[@class="class1"]选取所有class属性为class1的节点
text()选取节点中的文本//a[class="class1"]/text()选取所有class属性为class1的a节点的文本内容
*匹配任何节点/a/*选取a节点下的所有子节点

谓语

谓语用来查找特定的节点，谓语被嵌在方括号中

路径表达式结果
/a/b[1]选取a节点下的第一个b节点
/a/b[last()]选取a节点下的最后一个b节点
/a/b[last()-1]选取a节点下的倒数第二个b节点
/a/b[position()<3]选取a节点下的前2个b节点
/a[@class]选取所有的有class属性的a节点
/a[@*]选取所有有属性的a节点
/a[@class="class1"]选取所有class属性为class1的a节点
/a/b[@price>20]选取a节点下所有price属性的值大于20的b节点
/a[contains(@class, “a”)]选取所有class属性中包含a单词的节点
/a[@class=“abc” and @id=“abc”]选取所有class属性为abc且id属性为abc的a节点

Xpath的语法推荐大家在Chrome中使用Xpath helper插件来练习，练习熟练之后就可以在Python中使用了！

Xpath helper插件：
链接: https://pan.baidu.com/s/1gOa8vewuIUhQ0GTefjrNsQ
提取码: sp4m



3.2.3 Xpath的使用


3.2.3.1 安装lxml

在Python中使用Xpath要安装lxml库:

pip install lxml

3.2.3.2 使用Xpath

使用Xpath解析HTML文本

from lxml import etree

# 使用etree.HTML()方法解析HTML文本
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<a href="link1" class="b" id='id1'>Elsie</a>
<a href="link2" class="a" id='id1'>Tillie</a>
<a href="link3" class="c" id='id2'>df</a>
<a link="https"></a>
<b link="af"></b>
<b link="bba"></b>
</body>
</html>
'''

html = etree.HTML(text, etree.HTMLParser())
result = html.xpath('/html/head/title/text()')
print(result)

运行结果：

["The Dormouse's story"]

上面的Xpath解析式/html/head/title/text()选取html标签下的head标签下的title标签的文本，再将结果打印出来。

在Python爬虫中使用Xpath的关键就是根据要提取的内容写成对应的Xpath表达式，只要将Xpath表达式写好，替换上面的代码中的Xpath表达式就可以提取到想要的内容了，所有，大家学习Xpath的重点在：会根据需要提取的信息写出对应的Xpath表达式。


使用Xpath解析HTML文档

from lxml import etree

# 使用etree.parse()方法解析HTNL文档
html = etree.parse('htmlText.html', etree.HTMLParser())
result = html.xpath('/html/head/title/text()')
print(result)

使用Xpath解析HTML文档使用的是etree.parse()方法，
htmlTest.html文档中的内容：

<html><head><title>The Dormouse's story</title></head> <body> 
<a href="link1" class="b" id='id1'>Elsie</a>
<a href="link2" class="a" id='id1'>Tillie</a>
<a href="link3" class="c" id='id2'>df</a>
<a link="https"></a>
<b link="af"></b>
<b link="bba"></b>
</body>
</html>

运行结果：

["The Dormouse's story"]


3.2.3.3 xpath使用技巧

  • 可以使用concat()方法将两个xpath表达式的结果合并

    爬取链家网中二手房的价格使用的xpath表达式：

    concat(//div[@class=“price”]/span[1]/text(),//div[@class=“price”]/span[2]/span/text())

  • 可以使用last()方法从筛选出的标签列表的末尾开始提取标签：

    爬取链家网中二手房的供暖情况使用的xpath表达式：

    //div[@class=“base”]/div[@class=“content”]/ul/li[last()-1]/text()

  • contains()的使用

//div[contains(@name,’Tom’)] 查找name属性中包含字符串Tom的所有div标签



3.2.4 使用Xpath爬取穷游网的中国热门城市

import requests
from fake_useragent import UserAgent
import parsel
import csv

def getdata(url):
    headers = {
        "user-Agent": UserAgent().chrome
    }
    response = requests.get(url=url, headers=headers)
    response.encoding = response.apparent_encoding

    selector = parsel.Selector(response.text)  # 把字符串类型转化为对象
    lis = selector.xpath('//ul[@class="plcCitylist"]/li')

    for li in lis:
        city_names = li.xpath('./h3/a/text()').get()
        city_names = city_names.rstrip()
        number_people = li.xpath('./p[2]/text()').get()
        place_hot = li.xpath('./p[@class="pois"]/a/text()').getall()
        place_hot = [place.strip() for place in place_hot]
        place_hot = '、'.join(place_hot)
        place_url = li.xpath('./p[@class="pics"]/a/@href').get()
        img_url = li.xpath('./p[@class="pics"]/a/img/@src').get()
        print(city_names, number_people, place_url, img_url, place_hot, sep='|')

        with open('qiongyouData.csv', mode='a', encoding='utf-8', newline='') as file_object:
            csv_write = csv.writer(file_object)
            csv_write.writerow([city_names, number_people, place_url, img_url, place_hot])

def main():
    for i in range(1, 172):
        url = "https://place.qyer.com/china/citylist-0-0-{}/".format(str(i))
        getdata(url)

if __name__ == '__main__':
    main()

代码运行后将在控制台打印爬取到的数据，并将数据写入qingyouData.csv文件，由于没有使用多线程，所以爬取所有的数据花费时间较长。



3.3 pyquery(了解)


虽然 xpath 与 Beautiful Soup 已经很强大了，不过语法还是过于啰嗦，pyquery提供了更加简洁优雅的语法，你可以像写jquery一般提取数据。

如果你使用过jQuary，那么你可能更适合使用pyquery解析库。

pyquery官方文档

3.3.1 pyquery的安装


和之前一样，在cmd控制台中输入以下代码来使用pip安装pyquery库：

pip install pyquery

3.3.2 初始化

像BeautifulSoup一样，初始化pyquery的时候，也需要传入一个HTML文本来初始化一个pyQuery对象。它的初始化的方式有很多，比如直接传入字符串，传入URL，传入文件名等等。


  • 字符串的初始化
from pyquery import PyQuery as pq

# 将字符串初始化为pyquery对象
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<a href="link1" class="b" id='id1'>Elsie</a>
<a href="link2" class="a" id='id1'>Tillie</a>
<a href="link3" class="c" id='id2'>df</a>
<a link="https"></a>
<b link="af"></b>
<b link="bba"></b>
</body>
</html>
'''

doc = pq(text)
print(doc('b'))

运行结果：

<b link="af"/>
<b link="bba"/>

  • URL初始化

初始化的参数可以是一个URL，此时只需要指定参数为url即可，但是，一般情况下都不会传入一个URL来初始化，因为通常都会出现编码方式出错导致出现乱码。

from pyquery import PyQuery as pq

# 将URL链接初始化为pyquery对象
doc = pq(url='https://www.baidu.com', encoding='utf-8')
print(doc('title'))

运行结果：

<title>百度一下，你就知道</title>

  • 文件初始化

要使用文件来初始化pyquery，只需要指定filename即可：

from pyquery import PyQuery as pq

# 将文件初始化为pyquery对象
doc = pq(filename='pyqueryTest.html')
print(doc('a'))

下面是pyqueryTest.html中的内容：

<html><head><title>The Dormouse's story</title></head> <body>
<a href="link1" class="b" id='id1'>Elsie</a>
<a href="link2" class="a" id='id1'>Tillie</a>
<a href="link3" class="c" id='id2'>df</a>
<a link="https"></a>
<b link="af"></b>
<b link="bba"></b>
</body>
</html>

下面是运行结果：

<a href="link1" class="b" id="id1">Elsie</a>
<a href="link2" class="a" id="id1">Tillie</a>
<a href="link3" class="c" id="id2">df</a>
<a link="https"/>


3.3.3 pyquery的使用


pyquery支持css选择器： 
from pyquery import PyQuery as pq

# pyquery中使用css选择器
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<a href="link1" class="b" id='id1'>Elsie</a>
<a href="link2" class="a" id='id1'>Tillie</a>
<a href="link3" class="c" id='id2'>df</a>
</body>
</html>
'''
html = pq(text)
print(html('a.b#id1'))

首先传入text将pyquery初始化，让后传入’a.b#id1’这个选择器，这个选择器的功能是选择所有class属性为b且id属性为id1的a标签。

运行结果如下：

<a href="link1" class="b" id="id1">Elsie</a>

下面是一些常用的查询函数，这些函数和jQuery中函数的用法完全相同：

方法介绍
PyQuery.find('css')在当前节点的所有子孙节点中查找所有满足css选择器的节点，返回的是PyQuery对象。
PyQuery.children('css')和find()的用法一样，只不过它的查找范围是子节点。
PyQuery.parent()获取当前节点的父节点，返回的是PyQuery对象。
PyQuery.parents('css')获取当前节点的祖先节点，返回的是PyQuery对象。
PyQuery.siblings('css')获取当前节点的兄弟节点，返回的是PyQuery对象。
PyQuery.items()得到当前节点的生成器，用于遍历PyQuery对象。
PyQuery.attr()获取当前节点的属性，当PyQuery中包含多个节点时，attr()只会返回第一个节点的属性。
PyQuery.text()获取文本，但PyQuery中包含多个节点时，它将返回一个将所有节点的文本合并成的字符串。
PyQuery.html()获取标签中的HTML文本，如果PyQuery中包含多个节点，它将返回第一个节点中的HTML文本。
PyQuery.addClass()为节点添加一个class
PyQuery.removeClass()移除节点的一个class
PyQuery.attr(' ', ' ')更改节点的属性内容
PyQuery.text(' ')修改节点内容
PyQuery.html(' ')修改节点内的HTML文本
PyQuery.remove()移除节点

下面使用实例向大家介绍这些方法的使用过程：

find()

from pyquery import PyQuery as pq

# pq_object.find()方法的使用
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<li>
<a href="link1" class="b" id='id1'>Elsie</a>
<a href="link2" class="a" id='id1'>Tillie</a>
<a href="link3" class="c" id='id2'>df</a>
</li>
</body>
</html>
'''
pq_object = pq(text)  # 初始化一个pyquery对象
bod = pq_object('body')  # 在pyquery对象中查找body标签
print(type(bod))

a = bod.find('a.b#id1')  # 在body标签的子孙节点中查找class属性为a,id属性为id1的a标签
print(type(a))
print(a.text())

运行结果：

<class 'pyquery.pyquery.PyQuery'>
<class 'pyquery.pyquery.PyQuery'>
Elsie

children()

from pyquery import PyQuery as pq

# pq_object.children()方法的使用
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<li>
<a href="link1" class="b" id='id1'>Elsie</a>
<a href="link2" class="a" id='id1'>Tillie</a>
<a href="link3" class="c" id='id2'>df</a>
</li>
</body>
</html>
'''

pq_object = pq(text)
bod = pq_object('body')
print(bod.children('a'))

运行代码发现没有打印任何内容，因为children()方法是在body标签的子标签中查找a标签，而body标签的子标签只有li标签，要提取所有的a标签，需要将代码改一下:

from pyquery import PyQuery as pq

# pq_object.children()方法的使用
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<li>
<a href="link1" class="b" id='id1'>Elsie</a>
<a href="link2" class="a" id='id1'>Tillie</a>
<a href="link3" class="c" id='id2'>df</a>
</li>
</body>
</html>
'''

pq_object = pq(text)
bod = pq_object('li')
print(bod.children('a'))

运行结果：

<a href="link1" class="b" id="id1">Elsie</a>
<a href="link2" class="a" id="id1">Tillie</a>
<a href="link3" class="c" id="id2">df</a>

parent()

from pyquery import PyQuery as pq

# pq_object.parent()方法的使用
text = '''
<body> 
<li>
<a class="b" id='id1'>Elsie</a>
</li>
</body>
'''

pq_object = pq(text)
a = pq_object('a.b#id1')
print(a.parent())
print('-'*50)
print(a.parents())

<li>
<a class="b" id="id1">Elsie</a>
</li>

--------------------------------------------------
<body> 
<li>
<a class="b" id="id1">Elsie</a>
</li>
</body><li>
<a class="b" id="id1">Elsie</a>
</li>

siblings()

from pyquery import PyQuery as pq

# pq.object.siblings()方法的使用
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<a href="link1" class="b" id='id1'>Elsie</a>
<a href="link2" class="a" id='id1'>Tillie</a>
<a href="link3" class="c" id='id2'>df</a>
</body>
</html>
'''

pq_object = pq(text)
a = pq_object('a.a#id1')
print(a.siblings())

运行结果：

<a href="link1" class="b" id="id1">Elsie</a>
<a href="link3" class="c" id="id2">df</a>

items()

from pyquery import PyQuery as pq

# pq_object.items()方法的使用
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<a href="link1" class="b" id='id1'>Elsie</a>
<a href="link2" class="a" id='id1'>Tillie</a>
<a href="link3" class="c" id='id2'>df</a>
</body>
</html>
'''

pq_object = pq(text)
a = pq_object('a')
for i in a.items():
    if i.attr('href') == 'link1':
        print(i)

运行结果：

<a href="link1" class="b" id="id1">Elsie</a>

html()

from pyquery import PyQuery as pq

# pq_object.html()方法的使用
text = '''
<head>
<title>The Dormouse's story</title>
</head> 
'''

pq_object = pq(text)
head = pq_object('head')
print(head.html())

运行结果：

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

节点操作

from pyquery import PyQuery as pq

# pyquery对节点的操作
text = '''
<html><head><title>The Dormouse's story</title></head> <body> 
<a href="link1" class="b" id='id1'>Elsie<b>text</b></a>
</body>
</html>
'''

pq_object = pq(text)

a = pq_object('a.b#id1')
a.add_class('new_class')
print("将a节点增加class属性'new_class的结果为：", a)

a.remove_class('b')
print("将a节点移除class属性b的结果为：", a)

a.attr('href', 'new_link')
print("将a节点中的href属性更改为'new_link'后的结果为：", a)

a.text('new_text')
print("将a节点的text更改为'new_text'后的结果为：", a)

a.html('<b>b_new_text</b>')
print("将a节点的HTML更改为'<b>b_new_text</b>'后的结果为：", a)

doc = pq_object('html')
a.remove()
print("将a节点删除后的结果为：", doc)

运行结果：

将a节点增加class属性'new_class的结果为： <a href="link1" class="b new_class" id="id1">Elsie<b>text</b></a>

将a节点移除class属性b的结果为： <a href="link1" class="new_class" id="id1">Elsie<b>text</b></a>

将a节点中的href属性更改为'new_link'后的结果为： <a href="new_link" class="new_class" id="id1">Elsie<b>text</b></a>

将a节点的text更改为'new_text'后的结果为： <a href="new_link" class="new_class" id="id1">new_text</a>

将a节点的HTML更改为'<b>b_new_text</b>'后的结果为： <a href="new_link" class="new_class" id="id1"><b>b_new_text</b></a>

将a节点删除后的结果为： <html><head><title>The Dormouse's story</title></head> <body> 
 
</body>
</html>

好了，上面就介绍完了Python网络爬虫中常用的四个解析库BeautifulSoup、Xpath(重点)、pyquery、re(重点)，其中re在第二章 基本库的使用 中介绍了，要将这些解析库学好，大量的练习是必不可少的，希望大家能多多实践，将学的知识用起来。


最后，感谢你的阅读。

叶 落
关注
  • 11
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
python强大的功能之解析库
Z_suger7的博客
06-01 559
正则表达式虽然提取信息速度很快，但是万一正则表达式有地方写错了，可能导致匹配失败，而且复杂项目的正则表达式很烦琐，这时Python强大的库功能就体现了，我们可以通过快捷高效的方法来解决，那就是——解析库。于一个刚学Python爬虫的新手来说，学习Python爬虫里面的「解析库的使用，要是记忆能力不强肯定会一边学一边忘记，正所谓好记性不如烂笔头，在自己学些爬虫相关的知识点可以记录下来然后多次实践肯定比单凭记忆力要记得牢，下面就是整理的一些解析库的知识，大家参考学习下。
五个 Python 常用数据分析库
DEVELOPERAA的博客
07-27 2696
Python 是常用是数据分析工具，常用的数据分析库有很多，下面主要介绍如下五个分析库：NumPy、Pandas、SciPy、StatsModels、Matplotlib。
2024年最全python爬虫从0到1 -xpath网页解析（lxml库）(1)
最新发布
2401_84689394的博客
05-01 676
/@class（三） lxml库lxml是python的一个解析库，支持HTML和XML的解析，支持XPath解析方式，而且解析效率非常高。在使用前我们需要在pycharm里安装lxml库。在终端输入指令即可：注意：必须安装在我们当前所使用的环境下（四）lxml库的使用tree = etree.parse(xxx.html) #解析本地文件tree = etree.HTML(content) #解析网页文件（五）实例演示Win64;‘wd’ : ‘这里写关键词’
100天精通Python丨黑科技篇 —— 21、大语言模型_100天精通python快速入门到黑科技
m0_60452141的博客
04-26 388
ChatGPT 是 OpenAI 推出的一种基于 GPT-3/4 的聊天机器人。chatgpt 的颠覆性影响主要体现在提高语言交流的便捷性、个性化服务、自动化客服和教育娱乐等方面，这些应用可以为用户带来更多的便利和乐趣，同时也为企业提供了更多的服务和商机。本文收录于，是由的硬核博主倾力打造，分基础知识篇和黑科技应用两大部分，欢迎订阅本专栏，订阅后可私聊进Python全栈VIP交流群（问题解答、互相帮助）还可领取20GPython视频和100本互联网行业电子书。
python爬虫教程（五）：解析库bs4及爬取实例
csdn1561168266的博客
05-04 1万+
大家好，今天分享的是解析库中的bs4，这个库如果是初学者的话肯定听过，本文章的目的是让你知道如何使用bs4。 一、安装及初始印象 1.安装 bs4是一个第三方库，需要安装。如果使用的是默认的IDE，可以在命令行下敲下： pip install bs4 如果是其它的话，建议百度或在论坛上寻找方法。 2.解析器 对于bs4这个库来说，我们主要使用的是BeautifulSoup对象，使用方法如下： # 导包 from bs4 import BeautifulSoup # 创建对象 soup =
爬虫系列-解析库
qq_42370313的博客
09-25 613
概述 在前面的实例中，我们采用正则表达式来提取相关的信息，但正则表达式过于复杂，容易写错，一旦写错就可能匹配不到我们想要的东西。所以这次博客我将介绍另一种提取信息的方法-解析库。 对于网页的节点来说，它可以定义id、class或其他属性。而且节点之间还有层次关系，在网页中可以通过XPath或CSS选择器来定位一个或多个节点。那么，在页面解析时，利用XPath或CSS选择器来提取某个节点，然后再调用...
Python爬虫解析笔记.md
08-27
通过学习可以掌握网络爬虫的基本概念和实现思路,了解异常处理、会话管理等技巧的应用,学会使用相关库解析网页、提取信息。可以通过示例代码学习编写爬虫程序的基本方法。 阅读建议: 可以先了解网络爬虫的基本思想,...
Python爬虫 json库应用详解
01-20
Python爬虫在处理数据时，经常需要与JSON格式的数据打交道，因为JSON作为一种轻量级的数据交换格式，广泛用于网络通信和数据存储。Python内置的json库提供了方便的接口，用于在JSON和Python对象之间进行转换。 一、...
【python爬虫 系列】5.python解析库
01-20
第五节：python解析库 5.1文本清洗 1）编码解码： 编码是信息从一种形式或格式转换为另一种形式的过程，解码则是编码的逆过程 乱码的诞生就是编解码不一样造成的，只有编码和解码的方式一样才会正常显示 编码：...
Python爬虫详细解析.doc
03-24
Python爬虫技术是一种自动化获取网络信息的程序，它遵循特定的规则遍历互联网，抓取所需数据。在Python中，实现爬虫主要涉及到以下几个关键知识点： 1. **HTTP请求与响应**： - **Request**: 当用户通过浏览器访问...
Python爬虫解析网页的4种方式实例及原理解析
09-18
主要介绍了Python爬虫解析网页的4种方式实例及原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
爬虫解析库（bs4，xpath）
weixin_46287157的博客
05-05 1276
爬虫解析库（bs4，xpath）
Python bs4解析库使用详解
永远是少年
12-28 4873
今天继续给大家介绍Python 爬虫相关知识，本文主要内容是Python bs4解析库使用详解。 一、Python bs4库简介与安装 二、Python bs4库获取数据 三、Python bs4库使用 （一）基本标签查找 （二）递进关系标签查找 （三）获取标签间的文本数据 （四）获取标签中的属性值 四、Python bs4库使用示例
Python爬虫之XPath解析库
weixin_43705135的博客
11-04 715
XPath，全称XML Path Language，即XML路径语言，拥有简单明了的路径选择表达式，提供有100个内建函数，实现对字符串、数值、时间的匹配以及节点、序列的处理。应用于在XML文档中查找信息的语言，适用于HTML文档的搜索。
python 解析库pyquery,parsel的学习
weixin_43568101的博客
07-11 805
python的解析库pyquery 适合初学者，希望对其有所帮助
python网络爬虫之各种库的功能介绍及解析库、存储库
妖气当然你
04-28 3397
网络爬虫实践，各种库的功能及爬虫的解析库 爬虫步骤一般分为三个步骤：抓取页面，分析页面，存储数据 其中对于我们而言最重要的就是反爬了，下面为大家介绍python爬虫各种相关的库，以便大家详细了解爬虫的整体架构及思想1、常见库的基本介绍 （1）请求库：实现http请求操作requests：阻塞式http请求库，发出一个请求，一直等待服务器响应后，程序才能进行下一步处理，耗时间，在等待期间做...
Python网络爬虫学习笔记（四）解析库的使用
qq_42138271的博客
12-19 986
解析库的使用 使用正则表达式，比较烦琐，而且万一有地方写错了，可能导致匹配失败。 对于网页的节点来说，有 id 、 class 或其他属性。 而且节点之间还有层次关系，在网页中可以通过 XPath 或 css 选择器来定位一个或多个节点 。 利用 XPath 或 css选择器来提取某个节点，然后再调用相应方法获取它的正文内容或者属性。 在 Python 中，有 lxml 、Beautiful Soup 、 pyquery 等解析库实现这个操作。 使用 XPath XPath ， 全称 XML Path La
python爬虫-3 解析库
千寻的博客
04-05 275
1.XPath 2.BeautifulSoup import requests from bs4 import BeautifulSoup headers = {'Accept-Encoding': 'gzip, deflate', 'Accept-Language': 'zh-CN,zh;q=0.8', 'Connection': 'k...
Python爬虫从入门到精通——解析库XPath的使用
热门推荐
冯·诺依曼
05-28 2万+
分类目录：《Python爬虫从入门到精通》总目录 在《爬取猫眼电影排行Top100》中我们用requests和正则表达式实现了一个最基本的爬虫。但提取页面信息时使用的是正则表达式比较烦琐，而且万一有地方写错了，可能导致匹配失败，所以使用正则表达式提取页面信息多多少少还是有些不方便。而对于网页的节点来说，它可以定义id、class或其他属性。而且节点之间还有层次关系，在网页中可以通过XPath或CS...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值